Skip to main content

miniextendr_macros/
rust_conversion_builder.rs

1//! Shared utilities for converting R SEXP parameters to Rust types.
2//!
3//! This module provides a builder for generating Rust conversion code from R SEXP arguments,
4//! ensuring consistent behavior across standalone functions and impl methods.
5
6use crate::miniextendr_fn::CoercionMapping;
7use proc_macro2::TokenStream;
8use quote::{quote, quote_spanned};
9use syn::spanned::Spanned;
10
11/// Builder for generating Rust conversion statements from R SEXP parameters.
12///
13/// Handles:
14/// - Unit types `()` → identity binding
15/// - `&Dots` → special wrapper with storage
16/// - Slices `&[T]` → TryFromSexp
17/// - `&str` → a borrow of R's CHARSXP (`TryFromRoot`)
18/// - Scalar references → DATAPTR_RO_unchecked
19/// - Coercion → multi-source numeric conversion (incl. widened native `i32`/`f64`) or logical/integer bool conversion
20/// - Default → TryFromSexp
21pub struct RustConversionBuilder {
22    /// Infer copied trait signature types from a concrete method item.
23    inferred_types: bool,
24    /// Enable coercion for all parameters
25    coerce_all: bool,
26    /// Parameter names that should use coercion
27    coerce_params: Vec<String>,
28    convert_params: Vec<String>,
29    /// Enable strict input conversion for lossy types
30    strict: bool,
31    /// Parameter names with `match_arg + several_ok` — use `match_arg_vec_from_sexp` instead of `TryFromSexp`.
32    match_arg_several_ok_params: Vec<String>,
33    /// Choice parameters whose type wraps the choice in `Missing` / `Option`
34    /// layers (#1473, #1551), with the kind of their innermost value. Decoded
35    /// by [`layered_choice_expr`] instead of `TryFromSexp`.
36    layered_choice_params: Vec<(String, ChoiceLeaf)>,
37    /// `no_na` parameters (Rust name) with the author's `no_na(message = ..)`,
38    /// if any: their converted value is checked right after the conversion
39    /// (see [`Self::with_no_na`]).
40    no_na_params: Vec<(String, Option<String>)>,
41    /// Parameters (Rust name) declared with parameter markers
42    /// (`Checked<T>` / `Unchecked<T>`, #1566), outermost first: the inner
43    /// type converts, then the value is wrapped (see
44    /// [`Self::with_param_markers`]).
45    param_markers: Vec<(String, Vec<crate::type_inspect::ParamMarker>)>,
46    /// The crate's `conversion_error_class` (`[package.metadata.miniextendr]`),
47    /// appended to every conversion condition's class vector.
48    conversion_error_class: Vec<String>,
49    /// Whether `Quoted` / `Quosure` parameters are bound (a standalone fn,
50    /// whose R wrapper passes them unevaluated, #1835). Elsewhere they are a
51    /// compile error.
52    unevaluated_args: bool,
53    /// The impl's type, for `Self` in a method's borrowed external argument
54    /// (`other: &Self`): the wrapper is a free function.
55    self_type: Option<syn::Type>,
56    /// The R formal of each parameter (#1842): what a conversion condition
57    /// names the argument (see [`Self::with_formals`]).
58    formals: crate::r_wrapper_builder::Formals,
59    /// Parameters (Rust name) whose alias check declared a prepared state
60    /// (#1504, see [`Self::preparation`]): their conversion reads it.
61    prepared_params: Vec<String>,
62}
63
64impl RustConversionBuilder {
65    /// Create a new conversion builder, carrying the crate-level
66    /// `conversion_error_class` from the manifest (empty when unset).
67    pub fn new() -> Self {
68        Self {
69            inferred_types: false,
70            coerce_all: false,
71            coerce_params: Vec::new(),
72            convert_params: Vec::new(),
73            strict: false,
74            match_arg_several_ok_params: Vec::new(),
75            layered_choice_params: Vec::new(),
76            no_na_params: Vec::new(),
77            param_markers: Vec::new(),
78            formals: crate::r_wrapper_builder::Formals::default(),
79            conversion_error_class: crate::crate_config::conversion_error_class(),
80            unevaluated_args: false,
81            self_type: None,
82            prepared_params: Vec::new(),
83        }
84    }
85
86    /// Convert `param_name` (its Rust name) from the prepared state its
87    /// alias check left (#1504): the check declared the binding
88    /// [`prepared_binding`] names, from [`Self::preparation`].
89    pub(crate) fn with_prepared_param(mut self, param_name: String) -> Self {
90        self.prepared_params.push(param_name);
91        self
92    }
93
94    /// Whether `pat_type` converts through the plain `TryFromSexp` arm (or a
95    /// copied trait signature's witness): the arm [`Self::conversion_stmts`]
96    /// falls back to, after every special conversion. Only that conversion
97    /// can be prepared. Erring towards `false` only loses the exact arm of an
98    /// `Either` (the check then takes both arms).
99    fn converts_plainly(&self, pat_type: &syn::PatType) -> bool {
100        let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() else {
101            return false;
102        };
103        let ty = pat_type.ty.as_ref();
104        let name = crate::naming::ident_name(&pat_ident.ident);
105        let special = #[allow(non_exhaustive_omitted_patterns)] match ty {
    syn::Type::Reference(_) | syn::Type::ImplTrait(_) => true,
    _ => false,
}matches!(ty, syn::Type::Reference(_) | syn::Type::ImplTrait(_))
106            || #[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())
107            || crate::type_inspect::call_marker(ty).is_some()
108            || crate::type_inspect::unevaluated_param(ty).is_some()
109            || crate::type_inspect::is_lazy_dots_marker(ty)
110            || self.external_arg(pat_type).is_some()
111            || self.explicit_conversion(pat_type)
112            || crate::type_inspect::is_rooted_view(ty)
113            || crate::type_inspect::is_rooted_reference(ty)
114            || (self.strict
115                && crate::return_type_analysis::strict_input_conversion_for_type(
116                    ty,
117                    &pat_ident.ident,
118                )
119                .is_some())
120            || self.layered_choice_params.iter().any(|(n, _)| *n == name)
121            || (self.match_arg_several_ok_params.contains(&name)
122                && crate::classify_several_ok_container(ty).is_some())
123            || (self.should_coerce(&name) && CoercionMapping::from_type(ty).is_some());
124        !special
125    }
126
127    /// The [`Preparation`] of an argument for the second pass of the alias
128    /// check (#1504), through `TryFromSexp::__mx_prepare`. `None` unless the
129    /// argument converts through the plain `TryFromSexp` arm.
130    ///
131    /// The check prepares an argument only when the first pass marks it: its
132    /// metadata is an `Either` at the top level (`NativeBorrow::selects`, a
133    /// constant, so every other argument's preparation optimises out), and
134    /// its arms meet another argument.
135    pub(crate) fn preparation(
136        &self,
137        pat_type: &syn::PatType,
138        sexp_ident: &syn::Ident,
139    ) -> Option<Preparation> {
140        if !self.converts_plainly(pat_type) {
141            return None;
142        }
143        let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() else {
144            return None;
145        };
146        let ty = pat_type.ty.as_ref();
147        let span = ty.span();
148        let prepare = if self.inferred_types {
149            let target = crate::trait_signature::argument_ident(&pat_ident.ident);
150            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "prepare");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=> #target.prepare(#sexp_ident) }
151        } else {
152            let ty = crate::type_inspect::erase_lifetimes(ty);
153            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "as");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "__mx_prepare");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
154                <#ty as ::miniextendr_api::TryFromSexp>::__mx_prepare(#sexp_ident)
155            }
156        };
157        Some(Preparation {
158            binding: prepared_binding(&pat_ident.ident),
159            prepare,
160        })
161    }
162
163    pub(crate) fn with_inferred_types(mut self) -> Self {
164        self.inferred_types = true;
165        self
166    }
167
168    /// Name the impl's type for `Self` in borrowed external arguments.
169    pub fn with_self_type(mut self, self_type: syn::Type) -> Self {
170        self.self_type = Some(self_type);
171        self
172    }
173
174    /// The borrowed external argument (`&T` / `&mut T` / a view, #2106)
175    /// `pat_type` declares. A parameter marker's parameter is none: the
176    /// marker rebinds the converted value, which a borrowed argument only
177    /// gets after every conversion.
178    fn external_arg(
179        &self,
180        pat_type: &syn::PatType,
181    ) -> Option<crate::externalptr_args::ExternalArg> {
182        let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() else {
183            return None;
184        };
185        let name = crate::naming::ident_name(&pat_ident.ident);
186        if self.convert_params.contains(&name) || self.param_markers.iter().any(|(n, _)| *n == name)
187        {
188            return None;
189        }
190        crate::externalptr_args::external_arg(&pat_type.ty)
191    }
192
193    /// Bind `Quoted` / `Quosure` parameters (#1835): set for standalone fns,
194    /// whose R wrapper passes those arguments unevaluated
195    /// (`r_wrapper_builder::RArgumentBuilder::build_call_args_vec`). Without
196    /// it such a parameter is a compile error.
197    pub fn with_unevaluated_args(mut self) -> Self {
198        self.unevaluated_args = true;
199        self
200    }
201
202    /// Override the crate-level conversion-error classes (the manifest's
203    /// `conversion_error_class` is read by [`Self::new`]).
204    #[cfg(test)]
205    pub fn with_conversion_error_class(mut self, classes: Vec<String>) -> Self {
206        self.conversion_error_class = classes;
207        self
208    }
209
210    /// Enable coercion for all parameters.
211    pub fn with_coerce_all(mut self) -> Self {
212        self.coerce_all = true;
213        self
214    }
215
216    /// Add a single parameter name that should use coercion.
217    ///
218    /// `param_name` is matched against the identifier in the function signature.
219    /// Can be called multiple times to add several parameters.
220    pub fn with_coerce_param(mut self, param_name: String) -> Self {
221        self.coerce_params.push(param_name);
222        self
223    }
224
225    /// Enable strict input conversion for lossy types (i64/u64/isize/usize + Vec variants).
226    pub fn with_strict(mut self) -> Self {
227        self.strict = true;
228        self
229    }
230
231    /// Mark a parameter as `match_arg + several_ok` — uses `match_arg_vec_from_sexp`
232    /// instead of `TryFromSexp` for converting STRSXP → `Vec<EnumType>`.
233    pub fn with_match_arg_several_ok(mut self, param_name: String) -> Self {
234        self.match_arg_several_ok_params.push(param_name);
235        self
236    }
237
238    /// Mark a choice parameter whose type wraps the choice in `Missing` /
239    /// `Option` layers (#1473, #1551): it is decoded layer by layer with the
240    /// `miniextendr_api::match_arg_*` helpers (see [`layered_choice_expr`])
241    /// instead of `TryFromSexp`. There is no `TryFromSexp for Option<T>` a
242    /// downstream crate could provide for its own enum (orphan rule), and a
243    /// `T: MatchArg` blanket would collide with the newtype blanket in
244    /// `miniextendr_api::newtype`, so the wrapper calls the helpers directly.
245    pub fn with_layered_choice(mut self, param_name: String, leaf: ChoiceLeaf) -> Self {
246        self.layered_choice_params.push((param_name, leaf));
247        self
248    }
249
250    /// Mark a `#[miniextendr(no_na)]` parameter (`param_name` is its Rust
251    /// name), with the author's `no_na(message = "...")` if given.
252    ///
253    /// The R guard `!anyNA(x)` runs first; a type can still read an input as
254    /// missing that `anyNA()` does not see (the reading markers `AsNumeric*` /
255    /// `AsCharacter*` read the text `"NA"` or a blank string as `NA`). So when
256    /// the parameter converts through plain `TryFromSexp`, the converted value
257    /// is asked `TryFromSexp::__mx_has_na` right after its binding, and a
258    /// refusal returns the R guard's own condition (see
259    /// [`no_na_value_stmt`]). No type is named: Rust resolves the call on the
260    /// value's real type, so aliases and derived newtypes of a marker are
261    /// checked too, and for any other type the default `false` optimises out.
262    /// The reference arms (`&T`, `&[T]`, `&str`) emit no check and keep only
263    /// the R guard: they convert through the reference type's own impl, and
264    /// no reading marker converts by reference. A parameter that `coerce`
265    /// converts through its mapping is checked on its argument SEXP before
266    /// the conversion instead (see `non_na_check`).
267    ///
268    /// An `Either` parameter (also under `Missing`) has no R guard
269    /// (`r_preconditions::no_na_checked_after_conversion`). Its value is asked
270    /// `TryFromSexp::__mx_input_has_na` with the input SEXP instead: the arm
271    /// the value converted to makes the guard's `anyNA()` check on the input
272    /// in Rust, then its own `__mx_has_na`, and a `DataFrame` arm refuses
273    /// nothing (also behind a derived newtype or `Result<_, ()>`, which
274    /// forward the call).
275    pub fn with_no_na(mut self, param_name: String, message: Option<String>) -> Self {
276        self.no_na_params.push((param_name, message));
277        self
278    }
279
280    /// Name each argument by its R formal (#1842) in its conversion
281    /// condition: the message's `'<p>'` and `e$param`. Without a declared
282    /// formal, the Rust name without leading underscores.
283    pub fn with_formals(mut self, formals: crate::r_wrapper_builder::Formals) -> Self {
284        self.formals = formals;
285        self
286    }
287
288    /// Mark a parameter (`param_name` is its Rust name) whose declared type
289    /// wraps the one it converts as in parameter markers (`Checked<T>` /
290    /// `Unchecked<T>`, #1566), outermost first. The `pat_type` this builder
291    /// sees holds the inner type, so the conversion and its failure context
292    /// (`e$rust_type`) are the inner type's; after the parameter's last
293    /// statement (the conversion or its `no_na` check) the value is rebound
294    /// through each marker's `from_inner`, innermost first, so the call
295    /// receives the declared type.
296    pub fn with_param_markers(
297        mut self,
298        param_name: String,
299        markers: Vec<crate::type_inspect::ParamMarker>,
300    ) -> Self {
301        self.param_markers.push((param_name, markers));
302        self
303    }
304
305    /// The rebinding of a marked parameter's converted value (see
306    /// [`Self::with_param_markers`]), or `None` for an unmarked parameter.
307    fn marker_rebind(&self, pat_type: &syn::PatType) -> Option<TokenStream> {
308        let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() else {
309            return None;
310        };
311        let ident = &pat_ident.ident;
312        let name = crate::naming::ident_name(ident);
313        let (_, markers) = self.param_markers.iter().find(|(n, _)| *n == name)?;
314        let span = pat_type.ty.span();
315        let rebinds = markers.iter().rev().map(|marker| {
316            let wrapped = marker.wrap(ident);
317            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&wrapped, &mut _s);
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=> let #ident = #wrapped; }
318        });
319        Some({
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut rebinds, i) = rebinds.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let rebinds =
                match rebinds.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&rebinds, &mut _s);
        }
    }
    _s
}quote! { #(#rebinds)* })
320    }
321
322    /// The check of the argument SEXP `sexp_ident` before its conversion: the
323    /// `no_na` R guard's `anyNA()` again, in Rust (`from_r::__mx_any_na`). It
324    /// raises the guard's condition, as the post-conversion `no_na` check
325    /// does ([`no_na_value_stmt`]), and covers a `.Call()` that skips the R
326    /// wrapper. Emitted for
327    ///
328    /// - a `NonNa<T>` parameter, so the marker's value holds no `NA` on every
329    ///   conversion arm (borrowed included);
330    /// - a `no_na` parameter that `coerce` converts through its mapping
331    ///   (#2274): that arm has no post-conversion check, and its `Option` /
332    ///   `Vec<Option<_>>` forms read an `NA` as `None` without an error.
333    ///
334    /// `None` for any other parameter.
335    fn non_na_check(
336        &self,
337        pat_type: &syn::PatType,
338        sexp_ident: &syn::Ident,
339    ) -> Option<TokenStream> {
340        let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() else {
341            return None;
342        };
343        let name = crate::naming::ident_name(&pat_ident.ident);
344        let no_na = self.no_na_params.iter().find(|(n, _)| *n == name);
345        let marked = self.param_markers.iter().any(|(n, markers)| {
346            *n == name && markers.contains(&crate::type_inspect::ParamMarker::NonNa)
347        });
348        let coerced = no_na.is_some()
349            && self.should_coerce(&name)
350            && CoercionMapping::from_type(&pat_type.ty).is_some();
351        if !marked && !coerced {
352            return None;
353        }
354        let custom = no_na.and_then(|(_, message)| message.as_deref());
355        let r_name = self.formals.of_ident(&pat_ident.ident);
356        let message = crate::r_preconditions::no_na_message(&r_name, &pat_type.ty, custom);
357        let span = pat_type.ty.span();
358        let has_na = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "from_r");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "__mx_any_na");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=> ::miniextendr_api::from_r::__mx_any_na(#sexp_ident) };
359        Some(na_refusal_stmt(
360            has_na,
361            &r_name,
362            &message,
363            &self.conversion_error_class,
364            span,
365        ))
366    }
367
368    /// Select the reference's conversion, including its native-borrow metadata.
369    pub fn with_convert_param(mut self, param_name: String) -> Self {
370        self.convert_params.push(param_name);
371        self
372    }
373
374    fn explicit_conversion(&self, pat_type: &syn::PatType) -> bool {
375        #[allow(non_exhaustive_omitted_patterns)] match pat_type.pat.as_ref() {
    syn::Pat::Ident(p) if
        self.convert_params.contains(&crate::naming::ident_name(&p.ident)) =>
        true,
    _ => false,
}matches!(pat_type.pat.as_ref(), syn::Pat::Ident(p)
376            if self.convert_params.contains(&crate::naming::ident_name(&p.ident)))
377    }
378
379    /// Returns `true` if `coerce_all` is set or `param_name` appears in the per-parameter list.
380    fn should_coerce(&self, param_name: &str) -> bool {
381        !self.convert_params.iter().any(|name| name == param_name)
382            && (self.coerce_all || self.coerce_params.iter().any(|name| name == param_name))
383    }
384
385    /// Describe only the conversion actually used for this argument.
386    ///
387    /// Special paths can have no TryFromSexp impl for the declared type. Omit
388    /// their metadata queries at codegen time; a runtime branch still typechecks.
389    pub(crate) fn native_borrow_metadata(
390        &self,
391        pat_type: &syn::PatType,
392        sexp_ident: &syn::Ident,
393    ) -> Option<TokenStream> {
394        let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() else {
395            return None;
396        };
397        let ty = pat_type.ty.as_ref();
398        if self.explicit_conversion(pat_type) {
399            let reference = crate::externalptr_args::conversion_reference(ty)
400                .expect("validated convert parameter");
401            let ty = crate::type_inspect::erase_lifetimes(ty);
402            return Some(if reference.mutability.is_none() {
403                {
    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, "TryFromRoot");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_lifetime(&mut _s, "\'_");
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "NATIVE_BORROW");
    _s
}quote! { <#ty as ::miniextendr_api::TryFromRoot<'_>>::NATIVE_BORROW }
404            } else {
405                {
    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, "NATIVE_BORROW");
    _s
}quote! { <#ty as ::miniextendr_api::TryFromSexp>::NATIVE_BORROW }
406            });
407        }
408        if crate::type_inspect::call_marker(ty).is_some()
409            || crate::type_inspect::unevaluated_param(ty).is_some()
410            || crate::type_inspect::is_lazy_dots_marker(ty)
411            || self.external_arg(pat_type).is_some()
412        {
413            return None;
414        }
415        // Character borrows never alias native numeric storage. In particular,
416        // do not instantiate Vec<&'a str>'s raw, static-only TryFromSexp impl
417        // merely to ask for its empty metadata.
418        if owned_string_storage(ty, sexp_ident).is_some() {
419            return None;
420        }
421        if crate::type_inspect::is_rooted_view(ty) {
422            return Some(self.borrow_metadata_for(ty, &pat_ident.ident, true));
423        }
424        let param_name = crate::naming::ident_name(&pat_ident.ident);
425        match ty {
426            syn::Type::ImplTrait(_) => return None,
427            syn::Type::Tuple(t) if t.elems.is_empty() => return None,
428            syn::Type::Reference(r) => {
429                if let syn::Type::Path(tp) = r.elem.as_ref()
430                    && (tp.path.is_ident("str")
431                        || tp
432                            .path
433                            .segments
434                            .last()
435                            .is_some_and(|seg| seg.ident == "Dots"))
436                {
437                    return None;
438                }
439                if self.match_arg_several_ok_params.contains(&param_name)
440                    && crate::classify_several_ok_container(ty).is_some()
441                {
442                    return None;
443                }
444            }
445            _ => {
446                if self.strict
447                    && crate::return_type_analysis::strict_input_conversion_for_type(ty, sexp_ident)
448                        .is_some()
449                {
450                    return None;
451                }
452                if self
453                    .layered_choice_params
454                    .iter()
455                    .any(|(name, _)| *name == param_name)
456                {
457                    return choice_native_borrow(ty);
458                }
459                if self.match_arg_several_ok_params.contains(&param_name)
460                    && crate::classify_several_ok_container(ty).is_some()
461                {
462                    return None;
463                }
464                // Numeric delegates to TryFromSexp, so retain that converter's metadata.
465                if self.should_coerce(&param_name)
466                    && let Some(mapping) = CoercionMapping::from_type(ty)
467                    && !#[allow(non_exhaustive_omitted_patterns)] match mapping {
    CoercionMapping::Numeric => true,
    _ => false,
}matches!(mapping, CoercionMapping::Numeric)
468                {
469                    return None;
470                }
471            }
472        }
473        Some(self.borrow_metadata_for(
474            ty,
475            &pat_ident.ident,
476            crate::type_inspect::is_rooted_reference(ty),
477        ))
478    }
479
480    fn borrow_metadata_for(&self, ty: &syn::Type, name: &syn::Ident, rooted: bool) -> TokenStream {
481        if self.inferred_types {
482            let target = crate::trait_signature::argument_ident(name);
483            if rooted {
484                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "rooted_native_borrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #target.rooted_native_borrow() }
485            } else {
486                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "native_borrow");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { #target.native_borrow() }
487            }
488        } else {
489            let ty = crate::type_inspect::erase_lifetimes(ty);
490            if rooted {
491                {
    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, "TryFromRoot");
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_lifetime(&mut _s, "\'_");
    ::quote::__private::push_shr(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "NATIVE_BORROW");
    _s
}quote! { <#ty as ::miniextendr_api::TryFromRoot<'_>>::NATIVE_BORROW }
492            } else {
493                {
    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, "NATIVE_BORROW");
    _s
}quote! { <#ty as ::miniextendr_api::TryFromSexp>::NATIVE_BORROW }
494            }
495        }
496    }
497
498    /// The binding of a `Quoted` / `Quosure` parameter (#1835) from the
499    /// argument its R wrapper passed: the capture, or the missing-argument
500    /// sentinel. `Missing<..>` reads the sentinel as `Missing::Absent`; a bare
501    /// marker returns R's own error for a missing argument as a conversion
502    /// condition naming the parameter (`e$param`). The marker borrows the
503    /// argument SEXP (rooted by `.Call()` for the call), so it cannot outlive
504    /// the call.
505    fn unevaluated_binding(
506        &self,
507        ident: &syn::Ident,
508        sexp_ident: &syn::Ident,
509        r_name: &str,
510        ty: &syn::Type,
511        param: crate::type_inspect::UnevaluatedParam,
512    ) -> TokenStream {
513        let span = ty.span();
514        let marker = param.kind.api_path();
515        let bound_ty = crate::type_inspect::erase_lifetimes(ty);
516        if !self.unevaluated_args {
517            let message = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("`{0}` parameters are supported on standalone `#[miniextendr]` functions only (standalone S3 methods included); a class or trait method\'s wrapper cannot pass an argument unevaluated",
                param.kind.name()))
    })format!(
518                "`{}` parameters are supported on standalone `#[miniextendr]` functions only \
519                 (standalone S3 methods included); a class or trait method's wrapper cannot \
520                 pass an argument unevaluated",
521                param.kind.name()
522            );
523            // The binding keeps the method's own use of the parameter from
524            // adding a follow-on "cannot find value" to the diagnostic.
525            let binding = if param.optional {
526                {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&marker, &mut _s);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "missing_from_wrapper_arg");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_and_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote_spanned! {span=> unsafe { #marker::missing_from_wrapper_arg(&#sexp_ident) } }
527            } else {
528                {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "match");
    ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&marker, &mut _s);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "from_wrapper_arg");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_and_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Some");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
                    _s
                });
            ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "None");
            ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "panic");
            ::quote::__private::push_bang_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let _: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::TokenStream::new()
                });
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            _s
        });
    _s
}quote_spanned! {span=>
529                    match unsafe { #marker::from_wrapper_arg(&#sexp_ident) } {
530                        ::core::option::Option::Some(v) => v,
531                        ::core::option::Option::None => ::core::panic!(),
532                    }
533                }
534            };
535            return {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "compile_error");
    ::quote::__private::push_bang_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&message, &mut _s);
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&bound_ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
536                ::core::compile_error!(#message);
537                let #ident: #bound_ty = #binding;
538            };
539        }
540        if param.optional {
541            // SAFETY (of the emitted `unsafe`): on the R main thread inside the
542            // wrapper's with_r_unwind_protect closure; `.Call()` roots the
543            // argument for the call.
544            return {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&bound_ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&marker, &mut _s);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "missing_from_wrapper_arg");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_and_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
545                let #ident: #bound_ty = unsafe { #marker::missing_from_wrapper_arg(&#sexp_ident) };
546            };
547        }
548        let message = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("argument \"{0}\" is missing, with no default",
                r_name))
    })format!("argument \"{r_name}\" is missing, with no default");
549        let crate_class = &self.conversion_error_class;
550        let call = crate::naming::call_slot_ident();
551        // SAFETY (of the emitted `unsafe`): as above; the `None` arm returns
552        // the tagged condition from inside the wrapper's closure, like a
553        // conversion `Err` arm.
554        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&bound_ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "match");
    ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&marker, &mut _s);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "from_wrapper_arg");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_and_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Some");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
                    _s
                });
            ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "None");
            ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "return");
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "unsafe");
                    ::quote::__private::push_group_spanned(&mut _s, _span,
                        ::quote::__private::Delimiter::Brace,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            let _span: ::quote::__private::Span =
                                ::quote::__private::get_span(_span).__into_span();
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "miniextendr_api");
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "error_value");
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "arg_check_condition_value");
                            ::quote::__private::push_group_spanned(&mut _s, _span,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    let _span: ::quote::__private::Span =
                                        ::quote::__private::get_span(_span).__into_span();
                                    ::quote::ToTokens::to_tokens(&message, &mut _s);
                                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                                    ::quote::ToTokens::to_tokens(&r_name, &mut _s);
                                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                                    ::quote::__private::push_and_spanned(&mut _s, _span);
                                    ::quote::__private::push_group_spanned(&mut _s, _span,
                                        ::quote::__private::Delimiter::Bracket,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            let _span: ::quote::__private::Span =
                                                ::quote::__private::get_span(_span).__into_span();
                                            {
                                                use ::quote::__private::ext::*;
                                                let mut _first = true;
                                                let has_iter = ::quote::__private::HasIterator::<false>;
                                                #[allow(unused_mut)]
                                                let (mut crate_class, i) = crate_class.quote_into_iter();
                                                let has_iter = has_iter | i;
                                                <_ as
                                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                                while true {
                                                    let crate_class =
                                                        match crate_class.next() {
                                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                                            None => break,
                                                        };
                                                    if !_first {
                                                        ::quote::__private::push_comma_spanned(&mut _s, _span);
                                                    }
                                                    _first = false;
                                                    ::quote::ToTokens::to_tokens(&crate_class, &mut _s);
                                                }
                                            }
                                            _s
                                        });
                                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                                        "core");
                                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                                        "option");
                                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                                        "Option");
                                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                                        "Some");
                                    ::quote::__private::push_group_spanned(&mut _s, _span,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            let _: ::quote::__private::Span =
                                                ::quote::__private::get_span(_span).__into_span();
                                            ::quote::ToTokens::to_tokens(&call, &mut _s);
                                            _s
                                        });
                                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_semi_spanned(&mut _s, _span);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
555            let #ident: #bound_ty = match unsafe { #marker::from_wrapper_arg(&#sexp_ident) } {
556                ::core::option::Option::Some(v) => v,
557                ::core::option::Option::None => {
558                    return unsafe {
559                        ::miniextendr_api::error_value::arg_check_condition_value(
560                            #message,
561                            #r_name,
562                            &[#(#crate_class),*],
563                            ::core::option::Option::Some(#call),
564                        )
565                    };
566                }
567            };
568        }
569    }
570
571    /// Generate a conversion expression that returns a tagged condition SEXP on failure.
572    ///
573    /// The R wrapper inspects `.val` and raises a structured `rust_*` condition; the
574    /// `return` happens from inside the C wrapper body before any further conversion.
575    ///
576    /// - `try_expr`: The `Result<T, E>`-producing expression
577    /// - `ctx`: The argument's R-facing failure context ([`ArgContext`]): the
578    ///   message prefix, `e$param` and `e$rust_type`
579    /// - `ident`: The binding name for the converted value
580    /// - `ty`: The target Rust type (for the `let` binding). The annotation is
581    ///   load-bearing: the `Err` arm probes the error type by method call
582    ///   ([`conversion_err_arm`]), which needs that type known at that point.
583    /// - `span`: Source span for error reporting
584    fn conversion_stmt(
585        &self,
586        try_expr: TokenStream,
587        ctx: &ArgContext,
588        ident: &syn::Ident,
589        ty: &syn::Type,
590        span: proc_macro2::Span,
591    ) -> TokenStream {
592        let err_arm = conversion_err_arm(ctx, &self.conversion_error_class, span);
593        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "match");
    ::quote::ToTokens::to_tokens(&try_expr, &mut _s);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "result");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Result");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Ok");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
                    _s
                });
            ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&err_arm, &mut _s);
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
594            let #ident: #ty = match #try_expr {
595                ::core::result::Result::Ok(v) => v,
596                #err_arm
597            };
598        }
599    }
600
601    /// Generate conversion statements for a single parameter.
602    ///
603    /// - `pat_type`: the typed pattern from the function signature (e.g., `x: i32`).
604    /// - `sexp_ident`: the identifier of the raw SEXP variable holding the R argument.
605    ///
606    /// Returns a flat list of `let` binding statements that convert `sexp_ident` into
607    /// the Rust type declared in `pat_type`. Every statement runs inside the
608    /// wrapper's `with_r_unwind_protect` closure, where the argument SEXPs are
609    /// live for the whole call, so `&str` and the shared native references
610    /// borrow R's storage directly (`TryFromRoot`).
611    pub fn build_conversion(
612        &self,
613        pat_type: &syn::PatType,
614        sexp_ident: &syn::Ident,
615    ) -> Vec<TokenStream> {
616        self.non_na_check(pat_type, sexp_ident)
617            .into_iter()
618            .chain(self.conversion_stmts(pat_type, sexp_ident))
619            .chain(self.marker_rebind(pat_type))
620            .collect()
621    }
622
623    /// The conversion of one parameter, without the `NonNa` check before it
624    /// or the marker rebinding after it (see [`Self::build_conversion`]).
625    fn conversion_stmts(
626        &self,
627        pat_type: &syn::PatType,
628        sexp_ident: &syn::Ident,
629    ) -> Vec<TokenStream> {
630        let syn::Pat::Ident(pat_ident) = pat_type.pat.as_ref() else {
631            return ::alloc::vec::Vec::new()vec![];
632        };
633        let ident = &pat_ident.ident;
634        // `r#`-free spelling for synthesized bindings (`__storage_where`).
635        let plain = crate::naming::unraw(ident);
636        // These temporaries survive other argument conversions. Source
637        // parameters may use the same spelling, so keep every temporary
638        // hygienic.
639        let binding_span = proc_macro2::Span::mixed_site();
640        let ty = pat_type.ty.as_ref();
641        // The R formal's name (`_x` → `x`, `r#type` → `type`, a declared
642        // `formal`, #1842): what a conversion condition names in its message
643        // and in `e$param`.
644        let r_name = self.formals.of_ident(ident);
645        // What a conversion failure of this argument says (#1591): the R-facing
646        // expectation (coerce-widened like the R-side check), `e$param` and
647        // `e$rust_type`.
648        let ctx = ArgContext::new(
649            &r_name,
650            ty,
651            self.should_coerce(&crate::naming::ident_name(ident)),
652        );
653
654        // A `Call` / `CallerCall` marker (#1566) never reaches this builder from
655        // a standalone fn: `lib.rs` removes it from the inputs and binds it from
656        // the call slot at the call site. Seeing one here means a class or trait
657        // method took it, where the wrapper's own call is the only attribution.
658        if crate::type_inspect::call_marker(ty).is_some() {
659            let span = ty.span();
660            let call = crate::naming::call_slot_ident();
661            // The binding keeps the method's own use of the parameter from adding
662            // a follow-on "cannot find value" to the diagnostic; the wrapper's call
663            // slot is in scope in every C wrapper, so it also type-checks.
664            let stmt = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "compile_error");
    ::quote::__private::push_bang_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::parse_spanned(&mut _s, _span,
                "\"`Call` / `CallerCall` parameters are supported on standalone `#[miniextendr]` \\\n                     functions only; class and trait methods attribute conditions to the wrapper\'s own call\"");
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "from_sexp");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&call, &mut _s);
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
665                ::core::compile_error!(
666                    "`Call` / `CallerCall` parameters are supported on standalone `#[miniextendr]` \
667                     functions only; class and trait methods attribute conditions to the wrapper's own call"
668                );
669                let #ident: #ty = <#ty>::from_sexp(#call);
670            };
671            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
672        }
673
674        // A borrowed external argument (#2106) converts to its handle here;
675        // the C wrapper borrows it after every conversion
676        // (`externalptr_args::arg_borrows`).
677        if let Some(external) = self.external_arg(pat_type) {
678            let err_arm = conversion_err_arm(&ctx, &self.conversion_error_class, ty.span());
679            let stmt = crate::externalptr_args::handle_conversion(
680                ident,
681                sexp_ident,
682                ty,
683                &external,
684                self.self_type.as_ref(),
685                err_arm,
686            );
687            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
688        }
689
690        // A copied trait signature (#2123) may name a type that resolves only
691        // in the declaration's module: its plain conversions take their type
692        // from the witness inferred from the concrete method instead.
693        let target = self
694            .inferred_types
695            .then(|| crate::trait_signature::argument_ident(ident));
696
697        let param_name = crate::naming::ident_name(ident);
698        let layered_choice = self
699            .layered_choice_params
700            .iter()
701            .find(|(name, _)| *name == param_name)
702            .map(|(_, leaf)| leaf);
703        let explicit_conversion = self.explicit_conversion(pat_type);
704        let converted_shared = explicit_conversion
705            && crate::externalptr_args::conversion_reference(ty)
706                .is_some_and(|r| r.mutability.is_none());
707        let rooted_reference = (converted_shared || crate::type_inspect::is_rooted_reference(ty))
708            && !self.match_arg_several_ok_params.contains(&param_name)
709            && layered_choice.is_none();
710        if crate::type_inspect::is_rooted_view(ty) || rooted_reference {
711            if let Some(stmt) = crate::type_inspect::static_rooted_view_binding(ident, ty) {
712                return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
713            }
714            let span = ty.span();
715            let roots = match ::quote::__private::IdentFragmentAdapter(&plain) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mx_roots_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(binding_span)),
}quote::format_ident!("__mx_roots_{}", plain, span = binding_span);
716            // The call roots its argument. The scope also retains any transient
717            // children returned by an ALTREP accessor during conversion.
718            let root = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&roots, &mut _s);
            ::quote::__private::push_dot_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "rooted");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
                    _s
                });
            _s
        });
    _s
}quote_spanned! {span=> unsafe { #roots.rooted(#sexp_ident) } };
719            let (try_expr, bound_ty): (_, syn::Type) = match &target {
720                Some(target) => (
721                    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "rooted");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&root, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=> #target.rooted(#root) },
722                    ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_underscore(&mut _s);
        _s
    })syn::parse_quote!(_),
723                ),
724                None => {
725                    let bound_ty = crate::type_inspect::erase_lifetimes(ty);
726                    (
727                        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&bound_ty, &mut _s);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "as");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromRoot");
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::__private::push_lifetime_spanned(&mut _s, _span, "\'_");
    ::quote::__private::push_shr_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "try_from_root");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&root, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
728                            <#bound_ty as ::miniextendr_api::TryFromRoot<'_>>::try_from_root(#root)
729                        },
730                        bound_ty,
731                    )
732                }
733            };
734            let stmt = self.conversion_stmt(try_expr, &ctx, ident, &bound_ty, span);
735            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::ToTokens::to_tokens(&roots, &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_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());
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::ToTokens::to_tokens(&stmt, &mut _s);
                    _s
                }]))vec![quote! {
736                let #roots = unsafe { ::miniextendr_api::gc_protect::ProtectScope::new() };
737                #stmt
738            }];
739        }
740
741        if explicit_conversion {
742            // Mutable references still use the raw conversion: a
743            // copyable Root proves liveness, not exclusive access. The wrapper
744            // preflights this converter's metadata before any reference exists.
745            let binding_ty = crate::type_inspect::erase_lifetimes(ty);
746            let span = ty.span();
747            // `NATIVE_BORROW` defaults to `None`, which the preflight skips: a
748            // `&mut` converter that doesn't declare it could alias another
749            // argument unchecked, so its absence is a compile error.
750            let declared = crate::externalptr_args::conversion_reference(ty)
751                .is_some_and(|r| r.mutability.is_some())
752                .then(|| {
753                    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "const");
    ::quote::__private::push_underscore_spanned(&mut _s, _span);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::TokenStream::new()
        });
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "assert");
    ::quote::__private::push_bang_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_lt_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&binding_ty, &mut _s);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "as");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "miniextendr_api");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "TryFromSexp");
            ::quote::__private::push_gt_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "NATIVE_BORROW");
            ::quote::__private::push_dot_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "is_some");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let _: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::TokenStream::new()
                });
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::__private::parse_spanned(&mut _s, _span,
                "\"`convert` on a `&mut` parameter needs its `TryFromSexp` impl to \\\n                             declare `NATIVE_BORROW`: the wrapper\'s alias check reads it \\\n                             before any reference exists\"");
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
754                        const _: () = ::core::assert!(
755                            <#binding_ty as ::miniextendr_api::TryFromSexp>::NATIVE_BORROW
756                                .is_some(),
757                            "`convert` on a `&mut` parameter needs its `TryFromSexp` impl to \
758                             declare `NATIVE_BORROW`: the wrapper's alias check reads it \
759                             before any reference exists"
760                        );
761                    }
762                });
763            let try_expr = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&binding_ty, &mut _s);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "as");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "try_from_sexp");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
764                <#binding_ty as ::miniextendr_api::TryFromSexp>::try_from_sexp(#sexp_ident)
765            };
766            let stmt = self.conversion_stmt(try_expr, &ctx, ident, &binding_ty, span);
767            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [{
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&declared, &mut _s);
                    ::quote::ToTokens::to_tokens(&stmt, &mut _s);
                    _s
                }]))vec![quote! { #declared #stmt }];
768        }
769
770        // `&str` normally returned above, borrowed in place. A `&str` with
771        // choices decodes into owned storage and borrows that.
772        let owned_ident = match ::quote::__private::IdentFragmentAdapter(&plain) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__owned_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(binding_span)),
}quote::format_ident!("__owned_{}", plain, span = binding_span);
773        if #[allow(non_exhaustive_omitted_patterns)] match ty {
    syn::Type::Reference(_) => true,
    _ => false,
}matches!(ty, syn::Type::Reference(_))
774            && !self.match_arg_several_ok_params.contains(&param_name)
775            && let Some((owned_ty, borrow_expr)) = owned_string_storage(ty, &owned_ident)
776        {
777            // The borrow is of a local copy, so it can't be `'static` either.
778            if let Some(stmt) = crate::type_inspect::static_rooted_view_binding(ident, ty) {
779                return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
780            }
781            let span = ty.span();
782            // Preserve the existing decoder for a string with choices, but
783            // decode into owned storage. Diagnostics keep the author's type.
784            let try_expr = if let Some(leaf) = layered_choice {
785                layered_choice_expr(&owned_ty, leaf.clone(), sexp_ident, span)
786            } else {
787                {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "try_from_sexp");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
788                    ::miniextendr_api::TryFromSexp::try_from_sexp(#sexp_ident)
789                }
790            };
791            let owned_stmt = self.conversion_stmt(try_expr, &ctx, &owned_ident, &owned_ty, span);
792            let bound_ty = crate::type_inspect::erase_lifetimes(ty);
793            let borrow_stmt = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&bound_ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&borrow_expr, &mut _s);
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
794                let #ident: #bound_ty = #borrow_expr;
795            };
796            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [owned_stmt, borrow_stmt]))vec![owned_stmt, borrow_stmt];
797        }
798
799        // `LazyDots` (#1892): the R wrapper passes its own frame,
800        // `environment()`, at the position of `...`; the marker reads the
801        // dots from it and never goes through `TryFromSexp`. Bound in every
802        // context: each promise carries its own environment, so the frame of
803        // a class method's wrapper serves as well as a standalone function's.
804        if crate::type_inspect::is_lazy_dots_marker(ty) {
805            let span = ty.span();
806            let bound_ty = crate::type_inspect::erase_lifetimes(ty);
807            // SAFETY (of the emitted `unsafe`): on the R main thread inside the
808            // wrapper's with_r_unwind_protect closure; `.Call()` roots the
809            // frame for the call, and the marker borrows the argument.
810            let stmt = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&bound_ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "miniextendr_api");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "LazyDots");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "from_wrapper_arg");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_and_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
                    _s
                });
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
811                let #ident: #bound_ty =
812                    unsafe { ::miniextendr_api::LazyDots::from_wrapper_arg(&#sexp_ident) };
813            };
814            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
815        }
816
817        // `Quoted` / `Quosure` (#1835): the R wrapper passes the argument
818        // unevaluated, behind the missing-argument sentinel; it never goes
819        // through `TryFromSexp`.
820        if let Some(param) = crate::type_inspect::unevaluated_param(ty) {
821            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [self.unevaluated_binding(ident, sexp_ident, &r_name, ty, param)]))vec![self.unevaluated_binding(ident, sexp_ident, &r_name, ty, param)];
822        }
823
824        match ty {
825            // Unit type: ()
826            // Note: We never generate `mut` on conversion bindings - the user's function
827            // has its own parameter binding that will be `mut` if they specified it.
828            syn::Type::Tuple(t) if t.elems.is_empty() => {
829                let stmt = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! { let #ident = (); };
830                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt]
831            }
832
833            // Reference types: &T, &mut T
834            syn::Type::Reference(r) => {
835                let param_name = crate::naming::ident_name(ident);
836                let is_dots = #[allow(non_exhaustive_omitted_patterns)] match r.elem.as_ref() {
    syn::Type::Path(tp) if
        tp.path.segments.last().map(|s| s.ident == "Dots").unwrap_or(false) =>
        true,
    _ => false,
}matches!(
837                    r.elem.as_ref(),
838                    syn::Type::Path(tp)
839                        if tp.path.segments.last()
840                            .map(|s| s.ident == "Dots")
841                            .unwrap_or(false)
842                );
843                let is_slice = #[allow(non_exhaustive_omitted_patterns)] match r.elem.as_ref() {
    syn::Type::Slice(_) => true,
    _ => false,
}matches!(r.elem.as_ref(), syn::Type::Slice(_));
844
845                // &[T] / &mut [T] with match_arg + several_ok:
846                // two-phase: pre-call Vec<T>, in-call borrow
847                if is_slice
848                    && self
849                        .match_arg_several_ok_params
850                        .contains(&param_name.to_string())
851                    && let Some((crate::SeveralOkContainer::BorrowedSlice, inner_ty)) =
852                        crate::classify_several_ok_container(ty)
853                {
854                    let is_mut = r.mutability.is_some();
855                    let storage_ident =
856                        match ::quote::__private::IdentFragmentAdapter(&plain) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__storage_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(binding_span)),
}quote::format_ident!("__storage_{}", plain, span = binding_span);
857                    let vec_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::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, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<#inner_ty>);
858                    let span = ty.span();
859                    let try_expr = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "match_arg_vec_from_sexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
860                        ::miniextendr_api::match_arg_vec_from_sexp::<#inner_ty>(#sexp_ident)
861                    };
862                    // Emit owned Vec<T> binding.
863                    // For &mut [T] the storage binding needs `mut`.
864                    let owned_stmt = if is_mut {
865                        // Need `let mut storage_ident: vec_ty = ...`; inline the mut variant.
866                        let err_arm = conversion_err_arm(&ctx, &self.conversion_error_class, span);
867                        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::__private::push_ident_spanned(&mut _s, _span, "mut");
    ::quote::ToTokens::to_tokens(&storage_ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&vec_ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "match");
    ::quote::ToTokens::to_tokens(&try_expr, &mut _s);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "result");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Result");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Ok");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
                    _s
                });
            ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&err_arm, &mut _s);
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
868                            let mut #storage_ident: #vec_ty = match #try_expr {
869                                ::core::result::Result::Ok(v) => v,
870                                #err_arm
871                            };
872                        }
873                    } else {
874                        self.conversion_stmt(try_expr, &ctx, &storage_ident, &vec_ty, span)
875                    };
876                    let borrow_stmt = if is_mut {
877                        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_and_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "mut");
    ::quote::ToTokens::to_tokens(&storage_ident, &mut _s);
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
878                            let #ident: #ty = &mut #storage_ident;
879                        }
880                    } else {
881                        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_and_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&storage_ident, &mut _s);
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
882                            let #ident: #ty = &#storage_ident;
883                        }
884                    };
885                    return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [owned_stmt, borrow_stmt]))vec![owned_stmt, borrow_stmt];
886                }
887
888                if is_dots {
889                    // &Dots: create wrapper with storage (main thread only - requires SEXP)
890                    let storage_ident =
891                        match ::quote::__private::IdentFragmentAdapter(&plain) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("{0}_storage", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(binding_span)),
}quote::format_ident!("{}_storage", plain, span = binding_span);
892                    let stmt = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&storage_ident, &mut _s);
    ::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, "dots");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Dots");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "inner");
            ::quote::__private::push_colon(&mut _s);
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    ::quote::__private::push_semi(&mut _s);
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_eq(&mut _s);
    ::quote::__private::push_and(&mut _s);
    ::quote::ToTokens::to_tokens(&storage_ident, &mut _s);
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
893                        let #storage_ident = ::miniextendr_api::dots::Dots { inner: #sexp_ident };
894                        let #ident = &#storage_ident;
895                    };
896                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt]
897                } else if is_slice {
898                    // Mutable slices (and shared ones with choices) use TryFromSexp.
899                    // Annotate the binding with the lifetime-erased type
900                    // (`&'a [T]` → `&'_ [T]`):
901                    // the user's lifetime need not be in scope, and the `Err` arm's
902                    // probe needs the error type named.
903                    let span = ty.span();
904                    let (try_expr, binding_ty) = try_from_sexp(
905                        target.as_ref(),
906                        sexp_ident,
907                        crate::type_inspect::erase_lifetimes(ty),
908                        span,
909                    );
910                    let stmt = self.conversion_stmt(try_expr, &ctx, ident, &binding_ty, span);
911                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt]
912                } else {
913                    // &T for other types: use TryFromSexp for the reference type.
914                    let span = ty.span();
915                    let (try_expr, binding_ty) =
916                        try_from_sexp(target.as_ref(), sexp_ident, ty.clone(), span);
917                    let stmt = self.conversion_stmt(try_expr, &ctx, ident, &binding_ty, span);
918                    ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt]
919                }
920            }
921
922            // All other types
923            _ => {
924                let param_name = crate::naming::ident_name(ident);
925
926                // Strict mode: use checked input helpers for lossy types. A
927                // rejected input is the same argument error as any other
928                // conversion failure (#1594), worded against what strict
929                // accepts (`a single whole number`).
930                if self.strict
931                    && let Some(strict_expr) =
932                        crate::return_type_analysis::strict_input_conversion_for_type(
933                            ty, sexp_ident,
934                        )
935                {
936                    let span = ty.span();
937                    let strict_ctx = ArgContext::strict(&r_name, ty);
938                    let stmt = self.conversion_stmt(strict_expr, &strict_ctx, ident, ty, span);
939                    return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
940                }
941
942                // A choice under `Missing` / `Option` / `Either` layers (#1473,
943                // #1551): decoded layer by layer, outermost first. Under an
944                // `Either<.., R>` layer, a value `R` refuses is reported against
945                // the whole parameter, in the words of its `@param` line, and an
946                // `R` that reads only character input is a compile error.
947                if let Some((_, leaf)) = self
948                    .layered_choice_params
949                    .iter()
950                    .find(|(name, _)| *name == param_name)
951                {
952                    let span = ty.span();
953                    let try_expr = layered_choice_expr(ty, leaf.clone(), sexp_ident, span);
954                    let choice_ctx = ArgContext::either_choice(&r_name, ty, leaf);
955                    let stmt = self.conversion_stmt(
956                        try_expr,
957                        choice_ctx.as_ref().unwrap_or(&ctx),
958                        ident,
959                        ty,
960                        span,
961                    );
962                    let mut stmts = either_arm_guards(&param_name, ty);
963                    stmts.push(stmt);
964                    return stmts;
965                }
966
967                // match_arg + several_ok: use match_arg_vec_from_sexp for container types
968                if self
969                    .match_arg_several_ok_params
970                    .contains(&param_name.to_string())
971                    && let Some((container, inner_ty)) = crate::classify_several_ok_container(ty)
972                {
973                    let span = ty.span();
974                    match container {
975                        crate::SeveralOkContainer::Vec => {
976                            let try_expr = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "match_arg_vec_from_sexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
977                                ::miniextendr_api::match_arg_vec_from_sexp::<#inner_ty>(#sexp_ident)
978                            };
979                            let stmt = self.conversion_stmt(try_expr, &ctx, ident, ty, span);
980                            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
981                        }
982                        crate::SeveralOkContainer::BoxedSlice => {
983                            let try_expr = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "match_arg_vec_from_sexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    ::quote::__private::push_dot_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "map");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_or_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_or_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_dot_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "into_boxed_slice");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let _: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::TokenStream::new()
                });
            _s
        });
    _s
}quote_spanned! {span=>
984                                ::miniextendr_api::match_arg_vec_from_sexp::<#inner_ty>(#sexp_ident)
985                                    .map(|v| v.into_boxed_slice())
986                            };
987                            let stmt = self.conversion_stmt(try_expr, &ctx, ident, ty, span);
988                            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt];
989                        }
990                        crate::SeveralOkContainer::Array(n) => {
991                            let span = ty.span();
992                            // First extract the Vec via match_arg_vec_from_sexp (handles
993                            // match_arg validation + error reporting), then the array
994                            // conversion, whose only failure is the selection length:
995                            // an argument error like any other (#1591).
996                            let vec_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::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, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<#inner_ty>);
997                            let vec_ident =
998                                match ::quote::__private::IdentFragmentAdapter(&plain) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__vec_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(binding_span)),
}quote::format_ident!("__vec_{}", plain, span = binding_span);
999                            let try_expr = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "match_arg_vec_from_sexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
1000                                ::miniextendr_api::match_arg_vec_from_sexp::<#inner_ty>(#sexp_ident)
1001                            };
1002                            let vec_stmt =
1003                                self.conversion_stmt(try_expr, &ctx, &vec_ident, &vec_ty, span);
1004                            let len_ctx = ArgContext {
1005                                prefix: ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("\'{0}\' must be of length {1}",
                r_name, n))
    })format!("'{r_name}' must be of length {n}"),
1006                                expected_known: true,
1007                                ..ctx.clone()
1008                            };
1009                            let len_arm =
1010                                conversion_err_arm(&len_ctx, &self.conversion_error_class, span);
1011                            let arr_stmt = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "match");
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
            ::quote::__private::push_semi_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&n, &mut _s);
            _s
        });
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "try_from");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&vec_ident, &mut _s);
            _s
        });
    ::quote::__private::push_dot_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "map_err");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_or_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_or_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "std");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "format");
            ::quote::__private::push_bang_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::parse_spanned(&mut _s, _span,
                        "\"got length {}\"");
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
                    ::quote::__private::push_dot_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "len");
                    ::quote::__private::push_group_spanned(&mut _s, _span,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let _: ::quote::__private::Span =
                                ::quote::__private::get_span(_span).__into_span();
                            ::quote::__private::TokenStream::new()
                        });
                    _s
                });
            _s
        });
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "result");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Result");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Ok");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
                    _s
                });
            ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "v");
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&len_arm, &mut _s);
            _s
        });
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
1012                                let #ident: #ty = match <[#inner_ty; #n]>::try_from(#vec_ident)
1013                                    .map_err(|v| ::std::format!("got length {}", v.len()))
1014                                {
1015                                    ::core::result::Result::Ok(v) => v,
1016                                    #len_arm
1017                                };
1018                            };
1019                            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [vec_stmt, arr_stmt]))vec![vec_stmt, arr_stmt];
1020                        }
1021                        crate::SeveralOkContainer::BorrowedSlice => {
1022                            let storage_ident =
1023                                match ::quote::__private::IdentFragmentAdapter(&plain) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__storage_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(binding_span)),
}quote::format_ident!("__storage_{}", plain, span = binding_span);
1024                            let vec_ty: syn::Type = ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::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, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&mut _s);
        ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<#inner_ty>);
1025                            let try_expr = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "match_arg_vec_from_sexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&inner_ty, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
1026                                ::miniextendr_api::match_arg_vec_from_sexp::<#inner_ty>(#sexp_ident)
1027                            };
1028                            let owned_stmt =
1029                                self.conversion_stmt(try_expr, &ctx, &storage_ident, &vec_ty, span);
1030                            let borrow_stmt = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&ident, &mut _s);
    ::quote::__private::push_colon_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::__private::push_and_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&storage_ident, &mut _s);
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
1031                                let #ident: #ty = &#storage_ident;
1032                            };
1033                            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [owned_stmt, borrow_stmt]))vec![owned_stmt, borrow_stmt];
1034                        }
1035                    }
1036                }
1037
1038                let should_coerce = self.should_coerce(&param_name);
1039                let coercion_mapping = if should_coerce {
1040                    CoercionMapping::from_type(ty)
1041                } else {
1042                    None
1043                };
1044
1045                let span = ty.span();
1046                let stmt = match coercion_mapping {
1047                    Some(mapping) => {
1048                        let try_expr = match mapping.converter() {
1049                            // `Missing<T>` included: its own impl reads the sentinel.
1050                            None => {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "try_from_sexp");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
1051                                ::miniextendr_api::TryFromSexp::try_from_sexp(#sexp_ident)
1052                            },
1053                            Some(converter) => {
1054                                let converter = syn::Ident::new(converter, span);
1055                                let read = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "from_r");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&converter, &mut _s);
    _s
}quote_spanned! {span=>
1056                                    ::miniextendr_api::from_r::#converter
1057                                };
1058                                let present = crate::miniextendr_fn::get_missing_inner_type(ty);
1059                                // A `Nullable<T>` reads through the `Option<T>`
1060                                // helper, then wraps its value (#2294).
1061                                let nullable =
1062                                    crate::type_inspect::nullable_inner_type(present.unwrap_or(ty))
1063                                        .is_some();
1064                                let call = |sexp: &dyn quote::ToTokens| {
1065                                    let call = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::ToTokens::to_tokens(&read, &mut _s);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=> #read(#sexp) };
1066                                    if nullable {
1067                                        crate::type_inspect::OptionalSpelling::Nullable
1068                                            .wrap_ok(call)
1069                                    } else {
1070                                        call
1071                                    }
1072                                };
1073                                if present.is_none() {
1074                                    call(sexp_ident)
1075                                } else {
1076                                    let read = if nullable {
1077                                        let arg = syn::Ident::new(
1078                                            "__mx_sexp",
1079                                            proc_macro2::Span::mixed_site(),
1080                                        );
1081                                        let value = call(&arg);
1082                                        {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_or_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&arg, &mut _s);
    ::quote::__private::push_or_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&value, &mut _s);
    _s
}quote_spanned! {span=> |#arg| #value }
1083                                    } else {
1084                                        read
1085                                    };
1086                                    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "missing");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "__mx_missing_or");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&read, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            _s
        });
    _s
}quote_spanned! {span=>
1087                                        ::miniextendr_api::missing::__mx_missing_or(
1088                                            #sexp_ident,
1089                                            #read,
1090                                        )
1091                                    }
1092                                }
1093                            }
1094                        };
1095                        self.conversion_stmt(try_expr, &ctx, ident, ty, span)
1096                    }
1097                    None => {
1098                        let (try_expr, binding_ty) = if self.prepared_params.contains(&param_name) {
1099                            if true {
    if !self.converts_plainly(pat_type) {
        ::core::panicking::panic("assertion failed: self.converts_plainly(pat_type)")
    };
};debug_assert!(self.converts_plainly(pat_type));
1100                            prepared_conversion(
1101                                target.as_ref(),
1102                                ident,
1103                                sexp_ident,
1104                                ty.clone(),
1105                                span,
1106                            )
1107                        } else {
1108                            try_from_sexp(target.as_ref(), sexp_ident, ty.clone(), span)
1109                        };
1110                        // `ty: TryFromSexp` here, so a failure can ask the
1111                        // type what it declares.
1112                        let declared = match &target {
1113                            Some(target) => ctx.with_inferred(target),
1114                            None => ctx.with_declared(ty),
1115                        };
1116                        let stmt =
1117                            self.conversion_stmt(try_expr, &declared, ident, &binding_ty, span);
1118                        // `ty: TryFromSexp` is proven here, so a `no_na`
1119                        // parameter's value can be asked after the binding.
1120                        if let Some((_, message)) = self
1121                            .no_na_params
1122                            .iter()
1123                            .find(|(name, _)| *name == param_name)
1124                        {
1125                            let message = crate::r_preconditions::no_na_message(
1126                                &r_name,
1127                                ty,
1128                                message.as_deref(),
1129                            );
1130                            // An `Either` has no R guard: the arm it converted
1131                            // to reads the input instead. The input is bound
1132                            // first, since the conversion binding may shadow
1133                            // it (a C wrapper can keep the parameter's name).
1134                            if crate::r_preconditions::no_na_checked_after_conversion(ty) {
1135                                let input = match ::quote::__private::IdentFragmentAdapter(&plain) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__no_na_input_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(binding_span)),
}quote::format_ident!(
1136                                    "__no_na_input_{}",
1137                                    plain,
1138                                    span = binding_span
1139                                );
1140                                let bind = {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
    ::quote::ToTokens::to_tokens(&input, &mut _s);
    ::quote::__private::push_eq_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
    ::quote::__private::push_semi_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
1141                                    let #input = #sexp_ident;
1142                                };
1143                                let check = no_na_value_stmt(
1144                                    ident,
1145                                    Some(&input),
1146                                    &r_name,
1147                                    &message,
1148                                    &self.conversion_error_class,
1149                                    span,
1150                                );
1151                                return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [bind, stmt, check]))vec![bind, stmt, check];
1152                            }
1153                            let check = no_na_value_stmt(
1154                                ident,
1155                                None,
1156                                &r_name,
1157                                &message,
1158                                &self.conversion_error_class,
1159                                span,
1160                            );
1161                            return ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt, check]))vec![stmt, check];
1162                        }
1163                        stmt
1164                    }
1165                };
1166                ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [stmt]))vec![stmt]
1167            }
1168        }
1169    }
1170
1171    /// Generate conversion statements for all parameters in a function signature.
1172    ///
1173    /// Iterates over `inputs` (the function's parameter list) paired with `sexp_idents`
1174    /// (the corresponding SEXP variable names), calling [`build_conversion`](Self::build_conversion)
1175    /// for each typed parameter. Receiver parameters (`self`) are silently skipped.
1176    ///
1177    /// Returns a flat list of all conversion statements, in parameter order.
1178    pub fn build_conversions(
1179        &self,
1180        inputs: &syn::punctuated::Punctuated<syn::FnArg, syn::token::Comma>,
1181        sexp_idents: &[syn::Ident],
1182    ) -> Vec<TokenStream> {
1183        let mut all_statements = Vec::new();
1184
1185        for (arg, sexp_ident) in inputs.iter().zip(sexp_idents.iter()) {
1186            if let syn::FnArg::Typed(pat_type) = arg {
1187                let statements = self.build_conversion(pat_type, sexp_ident);
1188                all_statements.extend(statements);
1189            }
1190        }
1191
1192        all_statements
1193    }
1194}
1195
1196impl Default for RustConversionBuilder {
1197    fn default() -> Self {
1198        Self::new()
1199    }
1200}
1201
1202/// `TryFromSexp` on `sexp_ident`, and the type its binding names: `ty`, or
1203/// for a copied trait signature (#2123) `_`, with the conversion through the
1204/// witness `target` inferred from the concrete method, so a declaration-local
1205/// type is never spelled in the impl's module.
1206fn try_from_sexp(
1207    target: Option<&syn::Ident>,
1208    sexp_ident: &syn::Ident,
1209    ty: syn::Type,
1210    span: proc_macro2::Span,
1211) -> (TokenStream, syn::Type) {
1212    match target {
1213        Some(target) => (
1214            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "convert");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=> #target.convert(#sexp_ident) },
1215            ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_underscore(&mut _s);
        _s
    })syn::parse_quote!(_),
1216        ),
1217        None => (
1218            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "try_from_sexp");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=> ::miniextendr_api::TryFromSexp::try_from_sexp(#sexp_ident) },
1219            ty,
1220        ),
1221    }
1222}
1223
1224/// The binding of a parameter's prepared state between its alias check and
1225/// its conversion (#1504). Mixed-site, like every conversion temporary.
1226pub(crate) fn prepared_binding(ident: &syn::Ident) -> syn::Ident {
1227    match ::quote::__private::IdentFragmentAdapter(&crate::naming::unraw(ident)) {
    arg =>
        ::quote::__private::mk_ident(&::alloc::__export::must_use({
                        ::alloc::fmt::format(format_args!("__mx_prepared_{0}", arg))
                    }),
            ::quote::__private::Option::Some::<::quote::__private::Span>(proc_macro2::Span::mixed_site())),
}quote::format_ident!(
1228        "__mx_prepared_{}",
1229        crate::naming::unraw(ident),
1230        span = proc_macro2::Span::mixed_site()
1231    )
1232}
1233
1234/// How the alias check prepares one argument (#1504).
1235pub(crate) struct Preparation {
1236    /// The binding of its prepared state ([`prepared_binding`]), which its
1237    /// conversion reads.
1238    pub(crate) binding: syn::Ident,
1239    /// The expression that prepares it.
1240    pub(crate) prepare: TokenStream,
1241}
1242
1243/// The alias check of a wrapper or trait shim with preparable arguments
1244/// (#1504), in two passes:
1245///
1246/// 1. `assert_or_select` checks `metadata` (every `Either` taken with both
1247///    arms). A conflict that involves no top-level `Either` raises; one that
1248///    does marks the `Either` argument instead.
1249/// 2. Each marked argument is prepared (its `(index, preparation)` in
1250///    `preparations`): the conversion runs up to the point where it would
1251///    build a native reference, which tells its arm. Its metadata becomes
1252///    what that arm borrows, and `assert_no_aliases` checks again.
1253///
1254/// The bindings are declared before the check, `Unprepared`, for the
1255/// arguments' conversions to read. `NativeBorrow::selects` on each
1256/// argument's metadata, a constant except for a copied trait signature,
1257/// gates its preparation; when no argument selects, the check is the
1258/// one-pass `assert_no_aliases` of a wrapper without preparations, so a call
1259/// that holds no top-level `Either` runs the same check as before after
1260/// optimisation. Without a mark, the second pass doesn't run.
1261pub(crate) fn two_pass_alias_guard(
1262    metadata: &[TokenStream],
1263    args: &[TokenStream],
1264    preparations: &[(usize, Preparation)],
1265) -> TokenStream {
1266    let span = proc_macro2::Span::mixed_site();
1267    let borrows = syn::Ident::new("__miniextendr_native_borrows", span);
1268    let native_args = syn::Ident::new("__miniextendr_native_args", span);
1269    let select = syn::Ident::new("__miniextendr_select", span);
1270    // `Prepared` has no `TryFromSexp` bound: a type without one is reported
1271    // once, at the type, by its preparation, metadata and conversion.
1272    let declarations = preparations.iter().map(|(_, Preparation { binding, .. })| {
1273        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "let");
    ::quote::__private::push_ident(&mut _s, "mut");
    ::quote::ToTokens::to_tokens(&binding, &mut _s);
    ::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, "from_r");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "prepared");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Prepared");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Unprepared");
    ::quote::__private::push_semi(&mut _s);
    _s
}quote! {
1274            let mut #binding = ::miniextendr_api::from_r::prepared::Prepared::Unprepared;
1275        }
1276    });
1277    let selects = preparations.iter().map(|(index, _)| {
1278        let declared = &metadata[*index];
1279        {
    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, "from_r");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "NativeBorrow");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "selects");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&declared, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::from_r::NativeBorrow::selects(#declared) }
1280    });
1281    let prepares = preparations
1282        .iter()
1283        .map(|(index, Preparation { binding, prepare })| {
1284            let declared = &metadata[*index];
1285            {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "if");
    ::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, "from_r");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "NativeBorrow");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "selects");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&declared, &mut _s);
            _s
        });
    ::quote::__private::push_and_and(&mut _s);
    ::quote::ToTokens::to_tokens(&select, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&index, &mut _s);
            _s
        });
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&binding, &mut _s);
            ::quote::__private::push_eq(&mut _s);
            ::quote::ToTokens::to_tokens(&prepare, &mut _s);
            ::quote::__private::push_semi(&mut _s);
            ::quote::ToTokens::to_tokens(&borrows, &mut _s);
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::ToTokens::to_tokens(&index, &mut _s);
                    _s
                });
            ::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, "from_r");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "prepared");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Prepared");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "borrow");
            ::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(&binding, &mut _s);
                    ::quote::__private::push_comma(&mut _s);
                    ::quote::ToTokens::to_tokens(&borrows, &mut _s);
                    ::quote::__private::push_group(&mut _s,
                        ::quote::__private::Delimiter::Bracket,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            ::quote::ToTokens::to_tokens(&index, &mut _s);
                            _s
                        });
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            _s
        });
    _s
}quote! {
1286                if ::miniextendr_api::from_r::NativeBorrow::selects(#declared) && #select[#index] {
1287                    #binding = #prepare;
1288                    #borrows[#index] = ::miniextendr_api::from_r::prepared::Prepared::borrow(
1289                        &#binding,
1290                        #borrows[#index],
1291                    );
1292                }
1293            }
1294        });
1295    {
    let mut _s = ::quote::__private::TokenStream::new();
    {
        use ::quote::__private::ext::*;
        let has_iter = ::quote::__private::HasIterator::<false>;
        #[allow(unused_mut)]
        let (mut declarations, i) = declarations.quote_into_iter();
        let has_iter = has_iter | i;
        <_ as ::quote::__private::CheckHasIterator<true>>::check(has_iter);
        while true {
            let declarations =
                match declarations.next() {
                    Some(_x) => ::quote::__private::RepInterp(_x),
                    None => break,
                };
            ::quote::ToTokens::to_tokens(&declarations, &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, "let");
            ::quote::__private::push_ident(&mut _s, "mut");
            ::quote::ToTokens::to_tokens(&borrows, &mut _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 metadata, i) = metadata.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let metadata =
                                match metadata.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_comma(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&metadata, &mut _s);
                        }
                    }
                    _s
                });
            ::quote::__private::push_semi(&mut _s);
            ::quote::__private::push_ident(&mut _s, "if");
            ::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, "from_r");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "borrow");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "needs_check");
            ::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(&borrows, &mut _s);
                    _s
                });
            ::quote::__private::push_group(&mut _s,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    ::quote::__private::push_ident(&mut _s, "let");
                    ::quote::ToTokens::to_tokens(&native_args, &mut _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 args, i) = args.quote_into_iter();
                                let has_iter = has_iter | i;
                                <_ as
                                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                while true {
                                    let args =
                                        match args.next() {
                                            Some(_x) => ::quote::__private::RepInterp(_x),
                                            None => break,
                                        };
                                    if !_first { ::quote::__private::push_comma(&mut _s); }
                                    _first = false;
                                    ::quote::ToTokens::to_tokens(&args, &mut _s);
                                }
                            }
                            _s
                        });
                    ::quote::__private::push_semi(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "if");
                    {
                        use ::quote::__private::ext::*;
                        let mut _first = true;
                        let has_iter = ::quote::__private::HasIterator::<false>;
                        #[allow(unused_mut)]
                        let (mut selects, i) = selects.quote_into_iter();
                        let has_iter = has_iter | i;
                        <_ as
                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                        while true {
                            let selects =
                                match selects.next() {
                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                    None => break,
                                };
                            if !_first { ::quote::__private::push_or_or(&mut _s); }
                            _first = false;
                            ::quote::ToTokens::to_tokens(&selects, &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, "let");
                            ::quote::ToTokens::to_tokens(&select, &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_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "from_r");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "borrow");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "assert_or_select");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&native_args, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&borrows, &mut _s);
                                            _s
                                        });
                                    _s
                                });
                            ::quote::__private::push_semi(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "if");
                            ::quote::__private::push_lt(&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, "bool");
                                    _s
                                });
                            ::quote::__private::push_gt(&mut _s);
                            ::quote::__private::push_colon2(&mut _s);
                            ::quote::__private::push_ident(&mut _s, "contains");
                            ::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(&select, &mut _s);
                                    ::quote::__private::push_comma(&mut _s);
                                    ::quote::__private::push_and(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "true");
                                    _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 prepares, i) = prepares.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let prepares =
                                                match prepares.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            ::quote::ToTokens::to_tokens(&prepares, &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, "from_r");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s, "borrow");
                                            ::quote::__private::push_colon2(&mut _s);
                                            ::quote::__private::push_ident(&mut _s,
                                                "assert_no_aliases");
                                            ::quote::__private::push_group(&mut _s,
                                                ::quote::__private::Delimiter::Parenthesis,
                                                {
                                                    let mut _s = ::quote::__private::TokenStream::new();
                                                    ::quote::ToTokens::to_tokens(&native_args, &mut _s);
                                                    ::quote::__private::push_comma(&mut _s);
                                                    ::quote::ToTokens::to_tokens(&borrows, &mut _s);
                                                    ::quote::__private::push_comma(&mut _s);
                                                    _s
                                                });
                                            ::quote::__private::push_semi(&mut _s);
                                            _s
                                        });
                                    _s
                                });
                            _s
                        });
                    ::quote::__private::push_ident(&mut _s, "else");
                    ::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_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "miniextendr_api");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "from_r");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s, "borrow");
                                    ::quote::__private::push_colon2(&mut _s);
                                    ::quote::__private::push_ident(&mut _s,
                                        "assert_no_aliases");
                                    ::quote::__private::push_group(&mut _s,
                                        ::quote::__private::Delimiter::Parenthesis,
                                        {
                                            let mut _s = ::quote::__private::TokenStream::new();
                                            ::quote::ToTokens::to_tokens(&native_args, &mut _s);
                                            ::quote::__private::push_comma(&mut _s);
                                            ::quote::ToTokens::to_tokens(&borrows, &mut _s);
                                            _s
                                        });
                                    ::quote::__private::push_semi(&mut _s);
                                    _s
                                });
                            _s
                        });
                    _s
                });
            _s
        });
    _s
}quote! {
1296        #(#declarations)*
1297        {
1298            let mut #borrows = [#(#metadata),*];
1299            if ::miniextendr_api::from_r::borrow::needs_check(&#borrows) {
1300                let #native_args = [#(#args),*];
1301                if #(#selects)||* {
1302                    // SAFETY: the arguments are rooted on R's main thread for
1303                    // the call, and every allocating traversal (and each
1304                    // preparation) runs inside R unwind protection.
1305                    let #select = unsafe {
1306                        ::miniextendr_api::from_r::borrow::assert_or_select(#native_args, #borrows)
1307                    };
1308                    if <[bool]>::contains(&#select, &true) {
1309                        #(#prepares)*
1310                        // SAFETY: as above.
1311                        unsafe {
1312                            ::miniextendr_api::from_r::borrow::assert_no_aliases(
1313                                #native_args,
1314                                #borrows,
1315                            );
1316                        }
1317                    }
1318                } else {
1319                    // SAFETY: as above.
1320                    unsafe {
1321                        ::miniextendr_api::from_r::borrow::assert_no_aliases(#native_args, #borrows);
1322                    }
1323                }
1324            }
1325        }
1326    }
1327}
1328
1329/// [`try_from_sexp`] of an argument whose alias check may have prepared it
1330/// (#1504): the conversion reads the [`prepared_binding`] the check left.
1331fn prepared_conversion(
1332    target: Option<&syn::Ident>,
1333    ident: &syn::Ident,
1334    sexp_ident: &syn::Ident,
1335    ty: syn::Type,
1336    span: proc_macro2::Span,
1337) -> (TokenStream, syn::Type) {
1338    let prepared = prepared_binding(ident);
1339    match target {
1340        Some(target) => (
1341            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "convert_prepared");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&prepared, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=> #target.convert_prepared(#prepared, #sexp_ident) },
1342            ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::quote::__private::push_underscore(&mut _s);
        _s
    })syn::parse_quote!(_),
1343        ),
1344        None => {
1345            // The type is spelled, so a type without `TryFromSexp` is
1346            // reported at it, once, not again at the prepared binding.
1347            let erased = crate::type_inspect::erase_lifetimes(&ty);
1348            (
1349                {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "from_r");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "prepared");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "convert");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_lt_spanned(&mut _s, _span);
    ::quote::ToTokens::to_tokens(&erased, &mut _s);
    ::quote::__private::push_gt_spanned(&mut _s, _span);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&prepared, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&sexp_ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
1350                    ::miniextendr_api::from_r::prepared::convert::<#erased>(#prepared, #sexp_ident)
1351                },
1352                ty,
1353            )
1354        }
1355    }
1356}
1357
1358/// The native borrow of a choice parameter (#1504): an `Either<T, R>` choice
1359/// (under `Missing` / `Option` layers too) borrows what `R` borrows, for
1360/// input other than character or factor. Read through `EitherArmProbe`, so
1361/// an `R` without `TryFromSexp` adds no error of its own. `None` without an
1362/// `Either` layer: a choice is owned.
1363fn choice_native_borrow(ty: &syn::Type) -> Option<TokenStream> {
1364    let right = crate::type_inspect::choice_layers(ty).either_right?;
1365    let right = crate::type_inspect::erase_lifetimes(right);
1366    Some({
    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::__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::__private::push_ident(&mut _s, "use");
            ::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, "match_arg");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "EitherArmProbeFallback");
            ::quote::__private::push_ident(&mut _s, "as");
            ::quote::__private::push_underscore(&mut _s);
            ::quote::__private::push_semi(&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, "match_arg");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "EitherArmProbe");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_lt(&mut _s);
            ::quote::ToTokens::to_tokens(&right, &mut _s);
            ::quote::__private::push_gt(&mut _s);
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "CHOICE_NATIVE_BORROW");
            _s
        });
    _s
}quote! {{
1367        #[allow(unused_imports)]
1368        use ::miniextendr_api::match_arg::EitherArmProbeFallback as _;
1369        ::miniextendr_api::match_arg::EitherArmProbe::<#right>::CHOICE_NATIVE_BORROW
1370    }})
1371}
1372
1373// region: layered choice parameters
1374
1375/// Where the innermost value of a layered choice parameter comes from.
1376#[derive(#[automatically_derived]impl ::core::fmt::Debug for ChoiceLeaf {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::MatchArg =>
                ::core::fmt::Formatter::write_str(f, "MatchArg"),
            Self::MatchArgSeveral =>
                ::core::fmt::Formatter::write_str(f, "MatchArgSeveral"),
            Self::Literal { choices: __self_0, several: __self_1 } =>
                ::core::fmt::Formatter::debug_struct_field2_finish(f,
                    "Literal choices several", __self_0, &__self_1),
        }
    }
}Debug, #[automatically_derived]impl ::core::clone::Clone for ChoiceLeaf {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::MatchArg => ChoiceLeaf::MatchArg,
            Self::MatchArgSeveral => ChoiceLeaf::MatchArgSeveral,
            Self::Literal { choices: __self_0, several: __self_1 } =>
                ChoiceLeaf::Literal {
                    choices: ::core::clone::Clone::clone(__self_0),
                    several: ::core::clone::Clone::clone(__self_1),
                },
        }
    }
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    ChoiceLeaf {
}
#[automatically_derived]impl ::core::cmp::PartialEq for ChoiceLeaf {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Literal { choices: __self_0, several: __self_1 },
                    Self::Literal { choices: __arg1_0, several: __arg1_1 }) =>
                    __self_1 == __arg1_1 && __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for ChoiceLeaf {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<Vec<String>>;
        let _: ::core::cmp::AssertParamIsEq<bool>;
    }
}Eq)]
1377pub enum ChoiceLeaf {
1378    /// A scalar `match_arg` type (`T: MatchArg`), decoded with
1379    /// `match_arg_from_sexp::<T>`.
1380    MatchArg,
1381    /// A `match_arg` + `several_ok` container (`Vec<T>` / `Box<[T]>`),
1382    /// decoded with `match_arg_vec_from_sexp::<T>`: under `Missing<..>`, or
1383    /// on the left of an `Either<.., R>` (#1612).
1384    MatchArgSeveral,
1385    /// The string type of a `choices(...)` parameter, decoded with its own
1386    /// `TryFromSexp` (the R prelude already matched it against the list).
1387    Literal {
1388        /// The choice list, which the argument error of an `Either<.., R>`
1389        /// parameter names.
1390        choices: Vec<String>,
1391        /// `several_ok`: one or more of the choices.
1392        several: bool,
1393    },
1394}
1395
1396/// A layer around a choice parameter's value, outermost first.
1397enum ChoiceLayer<'a> {
1398    /// `Missing<..>`: the missing-argument sentinel is `Missing::Absent`.
1399    Missing,
1400    /// `Option<..>` (or `Nullable<..>`, spelled as this says, #2294): `NULL`
1401    /// is `None`.
1402    Null(crate::type_inspect::OptionalSpelling),
1403    /// `Either<.., R>`: character or factor input is the choice (`Left`),
1404    /// anything else converts to `R` (`Right`).
1405    Either(&'a syn::Type),
1406}
1407
1408/// The decoding expression for a choice parameter of type `ty` whose value
1409/// sits under `Missing` / `Option` / `Either` layers (#1473, #1551), applied
1410/// to the `SEXP` binding `sexp`. Each layer is one `miniextendr_api::match_arg_*`
1411/// helper that takes the decoder of the layers below it, so
1412/// `Missing<Option<Mode>>` becomes
1413///
1414/// ```ignore
1415/// ::miniextendr_api::match_arg_missing_or(sexp, ::miniextendr_api::match_arg_option_from_sexp::<Mode>)
1416/// ```
1417///
1418/// `Either<Route, DataFrame>` becomes
1419///
1420/// ```ignore
1421/// ::miniextendr_api::match_arg_either_or::<_, DataFrame, _>(sexp, ::miniextendr_api::match_arg_from_sexp::<Route>)
1422/// ```
1423///
1424/// and a `several_ok` list with another kind of value (#1612),
1425/// `Either<Vec<Fill>, DataFrame>`, becomes
1426///
1427/// ```ignore
1428/// ::miniextendr_api::match_arg_either_or::<_, DataFrame, _>(sexp, ::miniextendr_api::match_arg_vec_from_sexp::<Fill>)
1429/// ```
1430fn layered_choice_expr(
1431    ty: &syn::Type,
1432    leaf: ChoiceLeaf,
1433    sexp: &syn::Ident,
1434    span: proc_macro2::Span,
1435) -> TokenStream {
1436    let layers = crate::type_inspect::choice_layers(ty);
1437    let mut wraps = Vec::new();
1438    if layers.missing {
1439        wraps.push(ChoiceLayer::Missing);
1440    }
1441    if let Some(spelling) = layers.nullable {
1442        wraps.push(ChoiceLayer::Null(spelling));
1443    }
1444    if let Some(right) = layers.either_right {
1445        wraps.push(ChoiceLayer::Either(right));
1446    }
1447    let value = LayeredValue::new(layers.value, leaf);
1448    let expr = value.apply(&wraps, &{
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&sexp, &mut _s);
    _s
}quote! { #sexp });
1449    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::ToTokens::to_tokens(&expr, &mut _s);
    _s
}quote_spanned! {span=> #expr }
1450}
1451
1452/// The four borrowed character shapes supported by the raw converters, with
1453/// the owned type each decodes into and the borrow of that storage. Do not
1454/// generalize this to arbitrary list nesting, which has different conversion
1455/// and rooting requirements (#1427).
1456fn owned_string_storage(ty: &syn::Type, storage: &syn::Ident) -> Option<(syn::Type, TokenStream)> {
1457    let vector_element = match ty {
1458        syn::Type::Path(path) if path.qself.is_none() => path
1459            .path
1460            .segments
1461            .last()
1462            .filter(|seg| seg.ident == "Vec")
1463            .and_then(crate::type_inspect::first_type_argument),
1464        _ => None,
1465    };
1466    let element = vector_element.unwrap_or(ty);
1467    let optional_element = crate::type_inspect::option_inner_type(element);
1468    let syn::Type::Reference(reference) = optional_element.unwrap_or(element) else {
1469        return None;
1470    };
1471    if reference.mutability.is_some()
1472        || !#[allow(non_exhaustive_omitted_patterns)] match reference.elem.as_ref() {
    syn::Type::Path(path) if path.path.is_ident("str") => true,
    _ => false,
}matches!(reference.elem.as_ref(), syn::Type::Path(path) if path.path.is_ident("str"))
1473    {
1474        return None;
1475    }
1476    Some(
1477        match (vector_element.is_some(), optional_element.is_some()) {
1478            (false, false) => (
1479                ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::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, "string");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "String");
        _s
    })syn::parse_quote!(::std::string::String),
1480                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::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, "string");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "String");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "as_str");
    ::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(&storage, &mut _s);
            _s
        });
    _s
}quote!(::std::string::String::as_str(&#storage)),
1481            ),
1482            (false, true) => (
1483                ::syn::__private::parse_quote({
        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_lt(&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, "string");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "String");
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::core::option::Option<::std::string::String>),
1484                {
    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, "as_deref");
    ::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(&storage, &mut _s);
            _s
        });
    _s
}quote!(::core::option::Option::as_deref(&#storage)),
1485            ),
1486            (true, false) => (
1487                ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::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, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::quote::__private::push_lt(&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, "string");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "String");
        ::quote::__private::push_gt(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<::std::string::String>),
1488                {
    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, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::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, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Iterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::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, "iter");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoIterator");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_iter");
                    ::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(&storage, &mut _s);
                            _s
                        });
                    ::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, "string");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "String");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "as_str");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    _s
}quote!(::core::iter::Iterator::collect(::core::iter::Iterator::map(
1489                    ::core::iter::IntoIterator::into_iter(&#storage),
1490                    ::std::string::String::as_str,
1491                ))),
1492            ),
1493            (true, true) => (
1494                ::syn::__private::parse_quote({
        let mut _s = ::quote::__private::TokenStream::new();
        ::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, "vec");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "Vec");
        ::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, "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, "std");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "string");
        ::quote::__private::push_colon2(&mut _s);
        ::quote::__private::push_ident(&mut _s, "String");
        ::quote::__private::push_shr(&mut _s);
        _s
    })syn::parse_quote!(::std::vec::Vec<::core::option::Option<::std::string::String>>),
1495                {
    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, "iter");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Iterator");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "collect");
    ::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, "iter");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Iterator");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "map");
            ::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, "iter");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "IntoIterator");
                    ::quote::__private::push_colon2(&mut _s);
                    ::quote::__private::push_ident(&mut _s, "into_iter");
                    ::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(&storage, &mut _s);
                            _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, "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, "as_deref");
                    ::quote::__private::push_comma(&mut _s);
                    _s
                });
            _s
        });
    _s
}quote!(::core::iter::Iterator::collect(::core::iter::Iterator::map(
1496                    ::core::iter::IntoIterator::into_iter(&#storage),
1497                    ::core::option::Option::as_deref,
1498                ))),
1499            ),
1500        },
1501    )
1502}
1503
1504/// One compile-time assertion per leaf of the `R` arm of an `Either` choice
1505/// parameter `param` of type `ty` (nested `Either`s on the `R` side peeled):
1506/// compilation fails when the leaf's `TryFromSexp` is `CHARACTER_ONLY`, since
1507/// the choice check never sends character or factor input there. Read
1508/// through `EitherArmProbe`, so a leaf without `TryFromSexp` adds no error of
1509/// its own. Empty without an `Either` layer.
1510///
1511/// Each guard is a block holding only items (the fallback trait import and a
1512/// `const _` assertion), spanned on the leaf: the assertion is evaluated by
1513/// `cargo check` too, and the error points at the arm.
1514fn either_arm_guards(param: &str, ty: &syn::Type) -> Vec<TokenStream> {
1515    fn leaves<'a>(ty: &'a syn::Type, out: &mut Vec<&'a syn::Type>) {
1516        match crate::type_inspect::either_arms(ty) {
1517            Some((left, right)) => {
1518                leaves(left, out);
1519                leaves(right, out);
1520            }
1521            None => out.push(ty),
1522        }
1523    }
1524
1525    let Some(right) = crate::type_inspect::choice_layers(ty).either_right else {
1526        return Vec::new();
1527    };
1528    let nested = crate::type_inspect::either_arms(right).is_some();
1529    let mut arms = Vec::new();
1530    leaves(right, &mut arms);
1531    arms.into_iter()
1532        .map(|leaf| {
1533            let shown = crate::type_inspect::type_display(leaf);
1534            let arm = if nested {
1535                ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("the other arm\'s `{1}` (in `{0}`)",
                crate::type_inspect::type_display(right), shown))
    })format!(
1536                    "the other arm's `{shown}` (in `{}`)",
1537                    crate::type_inspect::type_display(right)
1538                )
1539            } else {
1540                ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("the other arm `{0}`", shown))
    })format!("the other arm `{shown}`")
1541            };
1542            let message = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("`Either` choice parameter `{0}`: {1} reads only character or factor input, and the choice check sends every character or factor argument to the choice arm, so at most NULL can reach `{2}`. Give that arm a type that reads other input (a data frame, a number, a list); for a NULL alternative, declare the parameter as `Option<Either<..>>`.",
                param, arm, shown))
    })format!(
1543                "`Either` choice parameter `{param}`: {arm} reads only character or factor \
1544                 input, and the choice check sends every character or factor argument to the \
1545                 choice arm, so at most NULL can reach `{shown}`. Give that arm a type that \
1546                 reads other input (a data frame, a number, a list); for a NULL alternative, \
1547                 declare the parameter as `Option<Either<..>>`."
1548            );
1549            // `assert!` reads a lone literal as a format string.
1550            let message = message.replace('{', "{{").replace('}', "}}");
1551            let probe = crate::type_inspect::erase_lifetimes(leaf);
1552            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(leaf.span()).__into_span();
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_pound_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "allow");
                    ::quote::__private::push_group_spanned(&mut _s, _span,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            let _span: ::quote::__private::Span =
                                ::quote::__private::get_span(_span).__into_span();
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "unused_imports");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident_spanned(&mut _s, _span, "use");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "miniextendr_api");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "match_arg");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "EitherArmProbeFallback");
            ::quote::__private::push_ident_spanned(&mut _s, _span, "as");
            ::quote::__private::push_underscore_spanned(&mut _s, _span);
            ::quote::__private::push_semi_spanned(&mut _s, _span);
            ::quote::__private::push_pound_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Bracket,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "allow");
                    ::quote::__private::push_group_spanned(&mut _s, _span,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            let _span: ::quote::__private::Span =
                                ::quote::__private::get_span(_span).__into_span();
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "clippy");
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "assertions_on_constants");
                            _s
                        });
                    _s
                });
            ::quote::__private::push_ident_spanned(&mut _s, _span, "const");
            ::quote::__private::push_underscore_spanned(&mut _s, _span);
            ::quote::__private::push_colon_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let _: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::TokenStream::new()
                });
            ::quote::__private::push_eq_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "assert");
            ::quote::__private::push_bang_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_bang_spanned(&mut _s, _span);
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "miniextendr_api");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "match_arg");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "EitherArmProbe");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_lt_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&probe, &mut _s);
                    ::quote::__private::push_gt_spanned(&mut _s, _span);
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "CHARACTER_ONLY");
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&message, &mut _s);
                    _s
                });
            ::quote::__private::push_semi_spanned(&mut _s, _span);
            _s
        });
    _s
}quote_spanned! {leaf.span()=>
1553                {
1554                    #[allow(unused_imports)]
1555                    use ::miniextendr_api::match_arg::EitherArmProbeFallback as _;
1556                    #[allow(clippy::assertions_on_constants)]
1557                    const _: () = ::core::assert!(
1558                        !::miniextendr_api::match_arg::EitherArmProbe::<#probe>::CHARACTER_ONLY,
1559                        #message
1560                    );
1561                }
1562            }
1563        })
1564        .collect()
1565}
1566
1567/// The innermost value of a layered choice parameter.
1568struct LayeredValue {
1569    leaf: ChoiceLeaf,
1570    /// The decoded type: the `MatchArg` type of a scalar, the element type
1571    /// of a `several_ok` container, the string type of a `choices` value
1572    /// (lifetimes erased).
1573    choice_ty: syn::Type,
1574    /// A `Box<[T]>` container, converted from the decoded `Vec<T>`.
1575    boxed: bool,
1576}
1577
1578impl LayeredValue {
1579    fn new(value: &syn::Type, leaf: ChoiceLeaf) -> Self {
1580        let (choice_ty, boxed) = match (&leaf, crate::classify_several_ok_container(value)) {
1581            (ChoiceLeaf::MatchArgSeveral, Some((container, inner))) => (
1582                inner.clone(),
1583                #[allow(non_exhaustive_omitted_patterns)] match container {
    crate::SeveralOkContainer::BoxedSlice => true,
    _ => false,
}matches!(container, crate::SeveralOkContainer::BoxedSlice),
1584            ),
1585            _ => (crate::type_inspect::erase_lifetimes(value), false),
1586        };
1587        Self {
1588            leaf,
1589            choice_ty,
1590            boxed,
1591        }
1592    }
1593
1594    /// `layers` over this value, decoding the argument `sexp`: the outermost
1595    /// layer's helper called on `sexp` with the decoder of the rest.
1596    fn apply(&self, layers: &[ChoiceLayer], sexp: &TokenStream) -> TokenStream {
1597        let t = &self.choice_ty;
1598        match layers {
1599            [] if self.boxed => {
    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, "match_arg_vec_from_sexp");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&t, &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(&sexp, &mut _s);
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map");
    ::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, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "Vec");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "into_boxed_slice");
            _s
        });
    _s
}quote! {
1600                ::miniextendr_api::match_arg_vec_from_sexp::<#t>(#sexp)
1601                    .map(::std::vec::Vec::into_boxed_slice)
1602            },
1603            [] => {
1604                let decoder = self.decoder(&[]);
1605                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&decoder, &mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&sexp, &mut _s);
            _s
        });
    _s
}quote! { #decoder(#sexp) }
1606            }
1607            // `Option<T>` over a scalar choice (#1473) keeps its dedicated helper.
1608            [ChoiceLayer::Null(spelling)] if self.leaf == ChoiceLeaf::MatchArg => spelling
1609                .wrap_ok({
    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, "match_arg_option_from_sexp");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&t, &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(&sexp, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::match_arg_option_from_sexp::<#t>(#sexp) }),
1610            [first, rest @ ..] => {
1611                let inner = self.decoder(rest);
1612                match first {
1613                    ChoiceLayer::Missing => {
1614                        {
    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, "match_arg_missing_or");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&sexp, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&inner, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::match_arg_missing_or(#sexp, #inner) }
1615                    }
1616                    ChoiceLayer::Null(spelling) => spelling
1617                        .wrap_ok({
    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, "match_arg_null_or");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&sexp, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&inner, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::match_arg_null_or(#sexp, #inner) }),
1618                    ChoiceLayer::Either(right) => {
1619                        let right = crate::type_inspect::erase_lifetimes(right);
1620                        {
    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, "match_arg_either_or");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::__private::push_underscore(&mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::ToTokens::to_tokens(&right, &mut _s);
    ::quote::__private::push_comma(&mut _s);
    ::quote::__private::push_underscore(&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(&sexp, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&inner, &mut _s);
            _s
        });
    _s
}quote! {
1621                            ::miniextendr_api::match_arg_either_or::<_, #right, _>(#sexp, #inner)
1622                        }
1623                    }
1624                }
1625            }
1626        }
1627    }
1628
1629    /// `layers` over this value as a decoder (`FnOnce(SEXP) -> Result<_, _>`):
1630    /// a function path where one exists, a closure otherwise.
1631    fn decoder(&self, layers: &[ChoiceLayer]) -> TokenStream {
1632        let t = &self.choice_ty;
1633        match (layers, &self.leaf) {
1634            ([], ChoiceLeaf::MatchArg) => {
1635                {
    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, "match_arg_from_sexp");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&t, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::miniextendr_api::match_arg_from_sexp::<#t> }
1636            }
1637            ([], ChoiceLeaf::MatchArgSeveral) if !self.boxed => {
1638                {
    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, "match_arg_vec_from_sexp");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&t, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::miniextendr_api::match_arg_vec_from_sexp::<#t> }
1639            }
1640            ([], ChoiceLeaf::Literal { .. }) => {
1641                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&t, &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, "try_from_sexp");
    _s
}quote! { <#t as ::miniextendr_api::TryFromSexp>::try_from_sexp }
1642            }
1643            (
1644                [ChoiceLayer::Null(crate::type_inspect::OptionalSpelling::Option)],
1645                ChoiceLeaf::MatchArg,
1646            ) => {
1647                {
    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, "match_arg_option_from_sexp");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&t, &mut _s);
    ::quote::__private::push_gt(&mut _s);
    _s
}quote! { ::miniextendr_api::match_arg_option_from_sexp::<#t> }
1648            }
1649            _ => {
1650                let arg = {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_ident(&mut _s, "__mx_sexp");
    _s
}quote! { __mx_sexp };
1651                let body = self.apply(layers, &arg);
1652                {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_or(&mut _s);
    ::quote::ToTokens::to_tokens(&arg, &mut _s);
    ::quote::__private::push_or(&mut _s);
    ::quote::ToTokens::to_tokens(&body, &mut _s);
    _s
}quote! { |#arg| #body }
1653            }
1654        }
1655    }
1656}
1657
1658// endregion
1659
1660// region: conversion-failure conditions
1661
1662/// The R-facing context of one argument's conversion failure (#1591).
1663#[derive(#[automatically_derived]impl ::core::clone::Clone for ArgContext {
    #[inline]
    fn clone(&self) -> Self {
        ArgContext {
            prefix: ::core::clone::Clone::clone(&self.prefix),
            expected_known: ::core::clone::Clone::clone(&self.expected_known),
            expected_at_run_time: ::core::clone::Clone::clone(&self.expected_at_run_time),
            declared: ::core::clone::Clone::clone(&self.declared),
            r_name: ::core::clone::Clone::clone(&self.r_name),
            rust_type: ::core::clone::Clone::clone(&self.rust_type),
            nullable: ::core::clone::Clone::clone(&self.nullable),
        }
    }
}Clone)]
1664struct ArgContext {
1665    /// The message prefix: `'<p>' must be <expected>` when the type has an
1666    /// R-facing expectation ([`crate::r_preconditions::conversion_expectation`]),
1667    /// `invalid '<p>' argument` otherwise. The error's reason follows it.
1668    prefix: String,
1669    /// Whether `prefix` states the expectation. Passed to the probe
1670    /// (`__mx_conversion_err_parts!(e, expected_known)`), so a built-in error's
1671    /// reason does not repeat it (`got character` rather than
1672    /// `expected integer, got character`).
1673    expected_known: bool,
1674    /// An expression yielding the expectation (a `String`) on the failure
1675    /// path, when the macro knows it but not its text: the choices of a
1676    /// `match_arg` type under an `Either<.., R>` layer come from
1677    /// `MatchArg::CHOICES`. Takes the place of `prefix`.
1678    expected_at_run_time: Option<TokenStream>,
1679    /// An expression yielding what the argument's type declares (an
1680    /// `Option<String>`) on the failure path, when the macro has no wording
1681    /// for it: set by [`ArgContext::with_declared`] where the binding
1682    /// converts with `TryFromSexp`, and tried before the error's own
1683    /// expectation ([`declared_expectation`]).
1684    declared: Option<TokenStream>,
1685    /// The R formal's name, `e$param`.
1686    r_name: String,
1687    /// The Rust type as written in the signature, `e$rust_type`: kept for the
1688    /// package author, out of the user-facing message.
1689    rust_type: String,
1690    /// Whether the value may be `NULL` (an `Option<_>`, under any `Missing`):
1691    /// an expectation the error supplies at run time then reads
1692    /// `NULL or <expected>`. Only used when `expected_known` is `false`.
1693    nullable: bool,
1694}
1695
1696impl ArgContext {
1697    /// The context of parameter `r_name` of type `ty`; `coerced` when the
1698    /// `coerce` knob applies to it (the expectation widens with the gate).
1699    fn new(r_name: &str, ty: &syn::Type, coerced: bool) -> Self {
1700        Self::with_expectation(
1701            r_name,
1702            ty,
1703            crate::r_preconditions::conversion_expectation(ty, coerced),
1704        )
1705    }
1706
1707    /// The context of a `strict` lossy-integer parameter (#1594): the
1708    /// expectation names what strict accepts, a whole number, since a
1709    /// logical, raw or fractional input is refused.
1710    fn strict(r_name: &str, ty: &syn::Type) -> Self {
1711        Self::with_expectation(
1712            r_name,
1713            ty,
1714            crate::r_preconditions::strict_conversion_expectation(ty),
1715        )
1716    }
1717
1718    fn with_expectation(r_name: &str, ty: &syn::Type, expected: Option<String>) -> Self {
1719        let prefix = match &expected {
1720            Some(expected) => ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("\'{0}\' must be {1}", r_name,
                expected))
    })format!("'{r_name}' must be {expected}"),
1721            None => ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("invalid \'{0}\' argument", r_name))
    })format!("invalid '{r_name}' argument"),
1722        };
1723        let value_ty = crate::miniextendr_fn::get_missing_inner_type(ty).unwrap_or(ty);
1724        Self {
1725            prefix,
1726            expected_known: expected.is_some(),
1727            expected_at_run_time: None,
1728            declared: None,
1729            r_name: r_name.to_string(),
1730            rust_type: crate::type_inspect::type_display(ty),
1731            nullable: crate::type_inspect::is_optional_type(value_ty),
1732        }
1733    }
1734
1735    /// This context for a binding that converts `ty` with `TryFromSexp`: when
1736    /// the macro has no wording for the type, the failure path asks the type
1737    /// what it declares ([`declared_expectation`]). Only there is
1738    /// `ty: TryFromSexp` known; the other conversion paths (a `several_ok`
1739    /// `Vec<Mode>`, a coercion helper) may name a type that has no impl. An
1740    /// `impl Trait` type gets no lookup: it cannot name a path, and its
1741    /// binding is already the compile error.
1742    fn with_declared(&self, ty: &syn::Type) -> Self {
1743        let mut ctx = self.clone();
1744        if !ctx.expected_known && ctx.expected_at_run_time.is_none() && !names_impl_trait(ty) {
1745            ctx.declared = Some(declared_expectation(ty));
1746        }
1747        ctx
1748    }
1749
1750    /// [`ArgContext::with_declared`] for a copied trait signature (#2123):
1751    /// the witness `target` names the type the method takes.
1752    fn with_inferred(&self, target: &syn::Ident) -> Self {
1753        let mut ctx = self.clone();
1754        if !ctx.expected_known && ctx.expected_at_run_time.is_none() {
1755            ctx.declared =
1756                Some({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&target, &mut _s);
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "expectation");
    ::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, "map");
    ::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, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ToString");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            _s
        });
    _s
}quote! { #target.expectation().map(::std::string::ToString::to_string) });
1757        }
1758        ctx
1759    }
1760
1761    /// The context of a choice parameter of type `ty` decoded as `leaf`, when
1762    /// the type has an `Either<.., R>` layer; `None` otherwise. A value `R`
1763    /// refuses is reported against the whole parameter, in the words of its
1764    /// `@param` line: `'route' must be one of "oral", "bolus", or a data
1765    /// frame` (`one or more of` for `several_ok`, `, a data frame, or NULL`
1766    /// under `Option`). The choices are `MatchArg::CHOICES` for a `match_arg`
1767    /// type, followed by its listed `MatchArg::ALIASES` (`(or "po" for
1768    /// "oral")`, #2148), and the literal list for `choices(...)`, which has
1769    /// no aliases; the `R` arm is named by its `@param` noun
1770    /// ([`crate::type_inspect::r_value_noun`]). The error then supplies only
1771    /// the reason (`got integer`).
1772    fn either_choice(r_name: &str, ty: &syn::Type, leaf: &ChoiceLeaf) -> Option<Self> {
1773        let layers = crate::type_inspect::choice_layers(ty);
1774        let right = layers.either_right?;
1775        let suffix = crate::miniextendr_fn::choice_alternatives_suffix(
1776            Some(&crate::type_inspect::r_value_noun(right)),
1777            layers.nullable.is_some(),
1778            "NULL",
1779        );
1780        let (choices, aliases, several) = match leaf {
1781            ChoiceLeaf::Literal { choices, several } => {
1782                ({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&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 choices, i) = choices.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let choices =
                        match choices.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&choices, &mut _s);
                }
            }
            _s
        });
    _s
}quote! { &[#(#choices),*] }, {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&mut _s);
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Bracket,
        ::quote::__private::TokenStream::new());
    _s
}quote! { &[] }, *several)
1783            }
1784            ChoiceLeaf::MatchArg | ChoiceLeaf::MatchArgSeveral => {
1785                let choice_ty = LayeredValue::new(layers.value, leaf.clone()).choice_ty;
1786                (
1787                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&choice_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, "MatchArg");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "CHOICES");
    _s
}quote! { <#choice_ty as ::miniextendr_api::MatchArg>::CHOICES },
1788                    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&choice_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, "MatchArg");
    ::quote::__private::push_gt(&mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ALIASES");
    _s
}quote! { <#choice_ty as ::miniextendr_api::MatchArg>::ALIASES },
1789                    *leaf == ChoiceLeaf::MatchArgSeveral,
1790                )
1791            }
1792        };
1793        Some(Self {
1794            expected_at_run_time: Some({
    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, "match_arg");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "choice_expectation");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&choices, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&aliases, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&several, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&suffix, &mut _s);
            _s
        });
    _s
}quote! {
1795                ::miniextendr_api::match_arg::choice_expectation(#choices, #aliases, #several, #suffix)
1796            }),
1797            ..Self::with_expectation(r_name, ty, None)
1798        })
1799    }
1800}
1801
1802/// The `Err(e)` arm of a conversion binding: return the tagged
1803/// `kind = "conversion"` value. `__mx_conversion_err_parts!` takes the class
1804/// vector, message and data from an `RConditionData` error type, the
1805/// R-worded reason from a built-in conversion error and the `Display` text
1806/// otherwise; `conversion_condition_value` puts the context's prefix before
1807/// it, appends the crate's `conversion_error_class` and adds `e$param` and
1808/// `e$rust_type`.
1809fn conversion_err_arm(
1810    ctx: &ArgContext,
1811    crate_class: &[String],
1812    span: proc_macro2::Span,
1813) -> TokenStream {
1814    let call = crate::naming::call_slot_ident();
1815    conversion_err_arm_with_call(
1816        ctx,
1817        &class_slice(crate_class),
1818        &{
    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, "Some");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&call, &mut _s);
            _s
        });
    _s
}quote! { ::core::option::Option::Some(#call) },
1819        span,
1820    )
1821}
1822
1823/// The `&[&str]` expression for classes the macro knows: the crate's
1824/// `conversion_error_class`, read where it expands.
1825pub(crate) fn class_slice(classes: &[String]) -> TokenStream {
1826    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_and(&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 classes, i) = classes.quote_into_iter();
                let has_iter = has_iter | i;
                <_ as
                        ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                while true {
                    let classes =
                        match classes.next() {
                            Some(_x) => ::quote::__private::RepInterp(_x),
                            None => break,
                        };
                    if !_first { ::quote::__private::push_comma(&mut _s); }
                    _first = false;
                    ::quote::ToTokens::to_tokens(&classes, &mut _s);
                }
            }
            _s
        });
    _s
}quote! { &[#(#classes),*] }
1827}
1828
1829/// Trait shims have no R call slot. They return the same structured argument
1830/// error as C wrappers; a View re-panic attributes it to the consumer's call.
1831/// `read_ty` supplies TryFromSexp expectations when the conversion uses that
1832/// trait; rooted views instead derive their expectation from the error.
1833///
1834/// The class is the implementing package's, read when the conversion fails
1835/// (`trait_abi::conversion_error_class`): a declaration's shims expand in the
1836/// declaring crate, but run in the package that implements the trait, and
1837/// raise what that package's own wrapper for the method raises.
1838pub(crate) fn shim_conversion_err_arm(
1839    name: &str,
1840    ty: &syn::Type,
1841    read_ty: Option<&syn::Type>,
1842    target: Option<&syn::Ident>,
1843) -> TokenStream {
1844    let mut ctx = ArgContext::new(name, ty, false);
1845    if let Some(target) = target {
1846        ctx = ctx.with_inferred(target);
1847    } else if let Some(read_ty) = read_ty {
1848        ctx = ctx.with_declared(read_ty);
1849    }
1850    conversion_err_arm_with_call(
1851        &ctx,
1852        &{
    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, "conversion_error_class");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        ::quote::__private::TokenStream::new());
    _s
}quote! { ::miniextendr_api::trait_abi::conversion_error_class() },
1853        &{
    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! { ::core::option::Option::None },
1854        ty.span(),
1855    )
1856}
1857
1858/// `crate_class` is an `&[&str]` expression ([`conversion_value_tokens`]).
1859fn conversion_err_arm_with_call(
1860    ctx: &ArgContext,
1861    crate_class: &TokenStream,
1862    call: &TokenStream,
1863    span: proc_macro2::Span,
1864) -> TokenStream {
1865    let ArgContext {
1866        prefix,
1867        expected_known,
1868        expected_at_run_time,
1869        declared,
1870        r_name,
1871        rust_type,
1872        nullable,
1873    } = ctx;
1874    let expected = match expected_at_run_time {
1875        Some(expr) => Expected::RunTime(expr),
1876        None if *expected_known => Expected::Literal(prefix),
1877        None => Expected::FromError(declared.as_ref()),
1878    };
1879    let value = conversion_value_tokens(
1880        &ConversionSubject {
1881            expected,
1882            quoted: r_name,
1883            param: r_name,
1884            nullable: *nullable,
1885            rust_type,
1886        },
1887        crate_class,
1888        call,
1889        span,
1890    );
1891    let err = crate::naming::conversion_error_ident();
1892    // SAFETY (of the emitted `unsafe`): the arm runs inside the wrapper's
1893    // with_r_unwind_protect closure, on the R main thread.
1894    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "result");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "Result");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "Err");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&err, &mut _s);
            _s
        });
    ::quote::__private::push_fat_arrow_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "return");
    ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&value, &mut _s);
            _s
        });
    ::quote::__private::push_comma_spanned(&mut _s, _span);
    _s
}quote_spanned! {span=>
1895        ::core::result::Result::Err(#err) => return unsafe { #value },
1896    }
1897}
1898
1899/// The post-conversion `no_na` check of the binding `ident` (R name
1900/// `r_name`): when the value holds what its type reads as `NA`
1901/// (`TryFromSexp::__mx_has_na`), return the tagged `kind = "conversion"`
1902/// value `no_na`'s R guard would raise, with `message` verbatim, the crate's
1903/// `conversion_error_class` and `e$param` (`arg_check_condition_value`). The
1904/// call is the wrapper's call slot, as for a conversion failure.
1905///
1906/// `input` is the argument's SEXP when no R guard ran (an `Either`, see
1907/// `r_preconditions::no_na_checked_after_conversion`): the value is then
1908/// asked `TryFromSexp::__mx_input_has_na`, which also makes the guard's
1909/// `anyNA()` check on the input, by the arm the value converted to.
1910fn no_na_value_stmt(
1911    ident: &syn::Ident,
1912    input: Option<&syn::Ident>,
1913    r_name: &str,
1914    message: &str,
1915    crate_class: &[String],
1916    span: proc_macro2::Span,
1917) -> TokenStream {
1918    let has_na = match input {
1919        Some(sexp) => {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "__mx_input_has_na");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_and_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&ident, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&sexp, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
1920            ::miniextendr_api::TryFromSexp::__mx_input_has_na(&#ident, #sexp)
1921        },
1922        None => {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "TryFromSexp");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "__mx_has_na");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_and_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&ident, &mut _s);
            _s
        });
    _s
}quote_spanned! {span=>
1923            ::miniextendr_api::TryFromSexp::__mx_has_na(&#ident)
1924        },
1925    };
1926    na_refusal_stmt(has_na, r_name, message, crate_class, span)
1927}
1928
1929/// `if <has_na> { return <the no_na argument error>; }`: the tagged
1930/// `kind = "conversion"` value `no_na`'s R guard would raise (see
1931/// [`no_na_value_stmt`]), for the post-conversion `no_na` check and the
1932/// `NonNa<T>` check before the conversion alike.
1933fn na_refusal_stmt(
1934    has_na: TokenStream,
1935    r_name: &str,
1936    message: &str,
1937    crate_class: &[String],
1938    span: proc_macro2::Span,
1939) -> TokenStream {
1940    let call = crate::naming::call_slot_ident();
1941    // SAFETY (of the emitted `unsafe`): the check runs with the argument's
1942    // conversion, where the conversion `Err` arm runs: on the R main thread,
1943    // inside the wrapper's with_r_unwind_protect closure.
1944    {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_ident_spanned(&mut _s, _span, "if");
    ::quote::ToTokens::to_tokens(&has_na, &mut _s);
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_ident_spanned(&mut _s, _span, "return");
            ::quote::__private::push_ident_spanned(&mut _s, _span, "unsafe");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Brace,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "miniextendr_api");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "error_value");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "arg_check_condition_value");
                    ::quote::__private::push_group_spanned(&mut _s, _span,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            let _span: ::quote::__private::Span =
                                ::quote::__private::get_span(_span).__into_span();
                            ::quote::ToTokens::to_tokens(&message, &mut _s);
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            ::quote::ToTokens::to_tokens(&r_name, &mut _s);
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            ::quote::__private::push_and_spanned(&mut _s, _span);
                            ::quote::__private::push_group_spanned(&mut _s, _span,
                                ::quote::__private::Delimiter::Bracket,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    let _span: ::quote::__private::Span =
                                        ::quote::__private::get_span(_span).__into_span();
                                    {
                                        use ::quote::__private::ext::*;
                                        let mut _first = true;
                                        let has_iter = ::quote::__private::HasIterator::<false>;
                                        #[allow(unused_mut)]
                                        let (mut crate_class, i) = crate_class.quote_into_iter();
                                        let has_iter = has_iter | i;
                                        <_ as
                                                ::quote::__private::CheckHasIterator<true>>::check(has_iter);
                                        while true {
                                            let crate_class =
                                                match crate_class.next() {
                                                    Some(_x) => ::quote::__private::RepInterp(_x),
                                                    None => break,
                                                };
                                            if !_first {
                                                ::quote::__private::push_comma_spanned(&mut _s, _span);
                                            }
                                            _first = false;
                                            ::quote::ToTokens::to_tokens(&crate_class, &mut _s);
                                        }
                                    }
                                    _s
                                });
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "core");
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "option");
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "Option");
                            ::quote::__private::push_colon2_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "Some");
                            ::quote::__private::push_group_spanned(&mut _s, _span,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let mut _s = ::quote::__private::TokenStream::new();
                                    let _: ::quote::__private::Span =
                                        ::quote::__private::get_span(_span).__into_span();
                                    ::quote::ToTokens::to_tokens(&call, &mut _s);
                                    _s
                                });
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            _s
                        });
                    _s
                });
            ::quote::__private::push_semi_spanned(&mut _s, _span);
            _s
        });
    _s
}quote_spanned! {span=>
1945        if #has_na {
1946            return unsafe {
1947                ::miniextendr_api::error_value::arg_check_condition_value(
1948                    #message,
1949                    #r_name,
1950                    &[#(#crate_class),*],
1951                    ::core::option::Option::Some(#call),
1952                )
1953            };
1954        }
1955    }
1956}
1957
1958/// Where the `<expected>` of a conversion failure's `'<p>' must be <expected>`
1959/// comes from.
1960pub(crate) enum Expected<'a> {
1961    /// The macro knows it: the whole prefix, `'<p>' must be <expected>`.
1962    Literal(&'a str),
1963    /// An expression the macro wrote yields it on the failure path (the
1964    /// choices of a `match_arg` type): the prefix is `'<p>' must be <it>`.
1965    RunTime(&'a TokenStream),
1966    /// What the type declares, when an expression for it is given
1967    /// ([`declared_expectation`]), else what the error may know
1968    /// (`__mx_conversion_expectation!`), else the prefix is
1969    /// `invalid '<p>' argument`.
1970    FromError(Option<&'a TokenStream>),
1971}
1972
1973/// What a conversion failure is about: the value it names and how.
1974pub(crate) struct ConversionSubject<'a> {
1975    /// Where the expectation in the message prefix comes from.
1976    pub(crate) expected: Expected<'a>,
1977    /// The name quoted in the message: the parameter, or a sidecar's field.
1978    pub(crate) quoted: &'a str,
1979    /// `e$param`: the R formal that failed.
1980    pub(crate) param: &'a str,
1981    /// The value may be `NULL` (`Option<_>`): an expectation the error
1982    /// supplies reads `NULL or <expected>` ([`Expected::FromError`] only).
1983    pub(crate) nullable: bool,
1984    /// `e$rust_type`: the Rust type as written.
1985    pub(crate) rust_type: &'a str,
1986}
1987
1988/// The `conversion_condition_value(...)` expression for the error bound as
1989/// `e` on `subject`, with the crate class and `call`. `crate_class` is an
1990/// expression of type `&[&str]`, evaluated only on the failure path: the
1991/// literal classes ([`class_slice`]), or a shim's run-time read.
1992///
1993/// With [`Expected::Literal`] (the macro knows the R-facing expectation,
1994/// `'<p>' must be <expected>`) the prefix is that literal; with
1995/// [`Expected::RunTime`] it is `'<p>' must be ` and the expression's value.
1996/// With [`Expected::FromError`] the prefix is built on the failure path by
1997/// `condition::conversion_prefix` (`NULL or ...` when `nullable`) from what
1998/// the type declares (a `#[derive(TryFromSexp)]` newtype, the sides of an
1999/// `Either`), else what the error may know (`__mx_conversion_expectation!(e)`,
2000/// #1594), falling back to `invalid '<p>' argument`.
2001///
2002/// With [`Expected::RunTime`] and [`Expected::FromError`] the error may also
2003/// word the whole message (`__mx_conversion_arg_message!(e, quoted)`): a
2004/// `match_arg` choice error reads as the R-side `match_arg` check
2005/// (`'mode' should be one of "fast", "slow"`, #1767), whatever the prefix.
2006/// Shared by the argument conversions and the sidecar setters.
2007pub(crate) fn conversion_value_tokens(
2008    subject: &ConversionSubject,
2009    crate_class: &TokenStream,
2010    call: &TokenStream,
2011    span: proc_macro2::Span,
2012) -> TokenStream {
2013    let ConversionSubject {
2014        expected,
2015        quoted,
2016        param,
2017        nullable,
2018        rust_type,
2019    } = subject;
2020    let rust_type = {
    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, "Some");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&rust_type, &mut _s);
            _s
        });
    _s
}quote! { ::core::option::Option::Some(#rust_type) };
2021    let e = crate::naming::conversion_error_ident();
2022    // A `match_arg` choice error words the whole message as the R-side
2023    // `match_arg` check does (#1767). A type with a literal expectation is
2024    // never a `match_arg` type, so only the other two arms ask.
2025    let arg_message = {
    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_conversion_arg_message");
    ::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(&e, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::ToTokens::to_tokens(&quoted, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::__mx_conversion_arg_message!(#e, #quoted) };
2026    match expected {
2027        Expected::Literal(prefix) => {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "error_value");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "conversion_condition_value");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::ToTokens::to_tokens(&prefix, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&param, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&rust_type, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&crate_class, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "miniextendr_api");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "__mx_conversion_err_parts");
            ::quote::__private::push_bang_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::ToTokens::to_tokens(&e, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "true");
                    _s
                });
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "None");
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&call, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            _s
        });
    _s
}quote_spanned! {span=>
2028            ::miniextendr_api::error_value::conversion_condition_value(
2029                #prefix,
2030                #param,
2031                #rust_type,
2032                #crate_class,
2033                ::miniextendr_api::__mx_conversion_err_parts!(#e, true),
2034                ::core::option::Option::None,
2035                #call,
2036            )
2037        },
2038        Expected::RunTime(expr) => {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "miniextendr_api");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span, "error_value");
    ::quote::__private::push_colon2_spanned(&mut _s, _span);
    ::quote::__private::push_ident_spanned(&mut _s, _span,
        "conversion_condition_value");
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_and_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "std");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "format");
            ::quote::__private::push_bang_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::parse_spanned(&mut _s, _span,
                        "\"\'{}\' must be {}\"");
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&quoted, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&expr, &mut _s);
                    _s
                });
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&param, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&rust_type, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&crate_class, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "miniextendr_api");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "__mx_conversion_err_parts");
            ::quote::__private::push_bang_spanned(&mut _s, _span);
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::ToTokens::to_tokens(&e, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "true");
                    _s
                });
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&arg_message, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&call, &mut _s);
            ::quote::__private::push_comma_spanned(&mut _s, _span);
            _s
        });
    _s
}quote_spanned! {span=>
2039            ::miniextendr_api::error_value::conversion_condition_value(
2040                &::std::format!("'{}' must be {}", #quoted, #expr),
2041                #param,
2042                #rust_type,
2043                #crate_class,
2044                ::miniextendr_api::__mx_conversion_err_parts!(#e, true),
2045                #arg_message,
2046                #call,
2047            )
2048        },
2049        Expected::FromError(declared) => {
2050            let from_error = {
    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_conversion_expectation");
    ::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(&e, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::__mx_conversion_expectation!(#e) };
2051            let expected = match declared {
2052                Some(declared) => {
    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::ToTokens::to_tokens(&declared, &mut _s);
            _s
        });
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "or_else");
    ::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::ToTokens::to_tokens(&from_error, &mut _s);
            _s
        });
    _s
}quote! { (#declared).or_else(|| #from_error) },
2053                None => from_error,
2054            };
2055            {
    let mut _s = ::quote::__private::TokenStream::new();
    let _span: ::quote::__private::Span =
        ::quote::__private::get_span(span).__into_span();
    ::quote::__private::push_group_spanned(&mut _s, _span,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            let _span: ::quote::__private::Span =
                ::quote::__private::get_span(_span).__into_span();
            ::quote::__private::push_ident_spanned(&mut _s, _span, "let");
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "__mx_expected");
            ::quote::__private::push_colon_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "core");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "option");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "Option");
            ::quote::__private::push_lt_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "std");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "string");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span, "String");
            ::quote::__private::push_gt_spanned(&mut _s, _span);
            ::quote::__private::push_eq_spanned(&mut _s, _span);
            ::quote::ToTokens::to_tokens(&expected, &mut _s);
            ::quote::__private::push_semi_spanned(&mut _s, _span);
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "miniextendr_api");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "error_value");
            ::quote::__private::push_colon2_spanned(&mut _s, _span);
            ::quote::__private::push_ident_spanned(&mut _s, _span,
                "conversion_condition_value");
            ::quote::__private::push_group_spanned(&mut _s, _span,
                ::quote::__private::Delimiter::Parenthesis,
                {
                    let mut _s = ::quote::__private::TokenStream::new();
                    let _span: ::quote::__private::Span =
                        ::quote::__private::get_span(_span).__into_span();
                    ::quote::__private::push_and_spanned(&mut _s, _span);
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "miniextendr_api");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "condition");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "conversion_prefix");
                    ::quote::__private::push_group_spanned(&mut _s, _span,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            let _span: ::quote::__private::Span =
                                ::quote::__private::get_span(_span).__into_span();
                            ::quote::ToTokens::to_tokens(&quoted, &mut _s);
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            ::quote::ToTokens::to_tokens(&nullable, &mut _s);
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "__mx_expected");
                            ::quote::__private::push_dot_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "as_deref");
                            ::quote::__private::push_group_spanned(&mut _s, _span,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let _: ::quote::__private::Span =
                                        ::quote::__private::get_span(_span).__into_span();
                                    ::quote::__private::TokenStream::new()
                                });
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            _s
                        });
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&param, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&rust_type, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&crate_class, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "miniextendr_api");
                    ::quote::__private::push_colon2_spanned(&mut _s, _span);
                    ::quote::__private::push_ident_spanned(&mut _s, _span,
                        "__mx_conversion_err_parts");
                    ::quote::__private::push_bang_spanned(&mut _s, _span);
                    ::quote::__private::push_group_spanned(&mut _s, _span,
                        ::quote::__private::Delimiter::Parenthesis,
                        {
                            let mut _s = ::quote::__private::TokenStream::new();
                            let _span: ::quote::__private::Span =
                                ::quote::__private::get_span(_span).__into_span();
                            ::quote::ToTokens::to_tokens(&e, &mut _s);
                            ::quote::__private::push_comma_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "__mx_expected");
                            ::quote::__private::push_dot_spanned(&mut _s, _span);
                            ::quote::__private::push_ident_spanned(&mut _s, _span,
                                "is_some");
                            ::quote::__private::push_group_spanned(&mut _s, _span,
                                ::quote::__private::Delimiter::Parenthesis,
                                {
                                    let _: ::quote::__private::Span =
                                        ::quote::__private::get_span(_span).__into_span();
                                    ::quote::__private::TokenStream::new()
                                });
                            _s
                        });
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&arg_message, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    ::quote::ToTokens::to_tokens(&call, &mut _s);
                    ::quote::__private::push_comma_spanned(&mut _s, _span);
                    _s
                });
            _s
        });
    _s
}quote_spanned! {span=> {
2056                let __mx_expected: ::core::option::Option<::std::string::String> = #expected;
2057                ::miniextendr_api::error_value::conversion_condition_value(
2058                    &::miniextendr_api::condition::conversion_prefix(
2059                        #quoted,
2060                        #nullable,
2061                        __mx_expected.as_deref(),
2062                    ),
2063                    #param,
2064                    #rust_type,
2065                    #crate_class,
2066                    ::miniextendr_api::__mx_conversion_err_parts!(#e, __mx_expected.is_some()),
2067                    #arg_message,
2068                    #call,
2069                )
2070            } }
2071        }
2072    }
2073}
2074
2075/// The expression, on a conversion failure's path, for what a parameter of
2076/// type `ty` declares when the macro has no wording for it: an
2077/// `Option<String>`, with the error bound as `e`. Only for a type the binding
2078/// converts with `TryFromSexp`, whose `__MX_EXPECTATION` it reads.
2079///
2080/// An `Either` (also under `Missing`) is worded side by side
2081/// (`from_r::either_expectation`, [`expected_arm`]), so one side the macro
2082/// does not know no longer leaves the whole parameter without an
2083/// expectation; any other type is asked for its `__MX_EXPECTATION` (a
2084/// `#[derive(TryFromSexp)]` newtype says what its inner type does). The
2085/// `NULL or` of an `Option<_>` (or `Nullable<_>`) parameter is the prefix's
2086/// (`nullable`).
2087pub(crate) fn declared_expectation(ty: &syn::Type) -> TokenStream {
2088    let value = crate::miniextendr_fn::get_missing_inner_type(ty).unwrap_or(ty);
2089    let value = crate::type_inspect::optional_inner_type(value).unwrap_or(value);
2090    if crate::type_inspect::either_arms(value).is_some() {
2091        let arms = expected_arm(value);
2092        let e = crate::naming::conversion_error_ident();
2093        {
    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, "from_r");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "either_expectation");
    ::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(&e, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&arms, &mut _s);
            _s
        });
    _s
}quote! { ::miniextendr_api::from_r::either_expectation(&#e, &#arms) }
2094    } else {
2095        let value = crate::type_inspect::erase_lifetimes(value);
2096        {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::__private::push_lt(&mut _s);
    ::quote::ToTokens::to_tokens(&value, &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, "__MX_EXPECTATION");
    ::quote::__private::push_dot(&mut _s);
    ::quote::__private::push_ident(&mut _s, "map");
    ::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, "std");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "string");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "ToString");
            ::quote::__private::push_colon2(&mut _s);
            ::quote::__private::push_ident(&mut _s, "to_string");
            _s
        });
    _s
}quote! {
2097            <#value as ::miniextendr_api::TryFromSexp>::__MX_EXPECTATION
2098                .map(::std::string::ToString::to_string)
2099        }
2100    }
2101}
2102
2103/// The `from_r::ExpectedArm` of one side of an `Either`, of type `ty`: the
2104/// macro's wording when it has one
2105/// ([`crate::r_preconditions::conversion_expectation`]), a nested `Either`
2106/// side by side, `NULL or <T>` for an `Option<T>` (or `Nullable<T>`) or
2107/// `Result<T, ()>` side, else the type's `__MX_EXPECTATION`, with its
2108/// `@param` noun ([`crate::type_inspect::r_value_noun`]) for when neither the
2109/// type nor its error names it. Every side is a `TryFromSexp` type, as
2110/// `Either`'s own impl requires (and the `Option` / `Nullable` / `Result`
2111/// impls of their `T`).
2112fn expected_arm(ty: &syn::Type) -> TokenStream {
2113    let arm = {
    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, "from_r");
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "ExpectedArm");
    _s
}quote! { ::miniextendr_api::from_r::ExpectedArm };
2114    if let Some(text) = crate::r_preconditions::conversion_expectation(ty, false) {
2115        return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&arm, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Known");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Parenthesis,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::ToTokens::to_tokens(&text, &mut _s);
            _s
        });
    _s
}quote! { #arm::Known(#text) };
2116    }
2117    if let Some((left, right)) = crate::type_inspect::either_arms(ty) {
2118        let (left, right) = (expected_arm(left), expected_arm(right));
2119        return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&arm, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Either");
    ::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(&left, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_and(&mut _s);
            ::quote::ToTokens::to_tokens(&right, &mut _s);
            _s
        });
    _s
}quote! { #arm::Either(&#left, &#right) };
2120    }
2121    if let Some(inner) =
2122        crate::type_inspect::optional_inner_type(ty).or_else(|| unit_result_ok_type(ty))
2123    {
2124        let inner = expected_arm(inner);
2125        return {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&arm, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Nullable");
    ::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(&inner, &mut _s);
            _s
        });
    _s
}quote! { #arm::Nullable(&#inner) };
2126    }
2127    let noun = crate::type_inspect::r_value_noun(ty);
2128    let ty = crate::type_inspect::erase_lifetimes(ty);
2129    {
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&arm, &mut _s);
    ::quote::__private::push_colon2(&mut _s);
    ::quote::__private::push_ident(&mut _s, "Opaque");
    ::quote::__private::push_group(&mut _s,
        ::quote::__private::Delimiter::Brace,
        {
            let mut _s = ::quote::__private::TokenStream::new();
            ::quote::__private::push_ident(&mut _s, "declared");
            ::quote::__private::push_colon(&mut _s);
            ::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, "__MX_EXPECTATION");
            ::quote::__private::push_comma(&mut _s);
            ::quote::__private::push_ident(&mut _s, "noun");
            ::quote::__private::push_colon(&mut _s);
            ::quote::ToTokens::to_tokens(&noun, &mut _s);
            ::quote::__private::push_comma(&mut _s);
            _s
        });
    _s
}quote! {
2130        #arm::Opaque {
2131            declared: <#ty as ::miniextendr_api::TryFromSexp>::__MX_EXPECTATION,
2132            noun: #noun,
2133        }
2134    }
2135}
2136
2137/// Whether `ty` spells an `impl Trait` anywhere (`impl AsRef<str>`,
2138/// `Vec<impl Display>`).
2139fn names_impl_trait(ty: &syn::Type) -> bool {
2140    fn scan(tokens: TokenStream) -> bool {
2141        tokens.into_iter().any(|tt| match tt {
2142            proc_macro2::TokenTree::Ident(ident) => ident == "impl",
2143            proc_macro2::TokenTree::Group(group) => scan(group.stream()),
2144            _ => false,
2145        })
2146    }
2147    scan({
    let mut _s = ::quote::__private::TokenStream::new();
    ::quote::ToTokens::to_tokens(&ty, &mut _s);
    _s
}quote! { #ty })
2148}
2149
2150/// `T` for a `Result<T, ()>` type, which reads `NULL` as `Err(())`.
2151fn unit_result_ok_type(ty: &syn::Type) -> Option<&syn::Type> {
2152    let syn::Type::Path(tp) = ty else {
2153        return None;
2154    };
2155    let seg = tp.path.segments.last()?;
2156    if seg.ident != "Result" {
2157        return None;
2158    }
2159    let ok = crate::type_inspect::first_type_argument(seg)?;
2160    match crate::type_inspect::second_type_argument(seg)? {
2161        syn::Type::Tuple(unit) if unit.elems.is_empty() => Some(ok),
2162        _ => None,
2163    }
2164}
2165
2166// endregion
2167
2168#[cfg(test)]
2169mod tests;