Struct MiniextendrFunctionParsed 

pub(crate) struct MiniextendrFunctionParsed {
    item: ItemFn,
    inputs: Punctuated<FnArg, Comma>,
    param_markers: Vec<(String, Vec<ParamMarker>)>,
    dots: Option<Ident>,
    per_param: HashMap<String, ParamAttrs>,
}

Parsed + normalized Rust function item for #[miniextendr].

This performs signature normalization that the wrapper generator depends on:

• ... → a final &miniextendr_api::dots::Dots argument
• _ wildcard patterns → synthetic identifiers (__unused0, __unused1, …)
• Destructuring patterns (tuple, struct) → synthetic identifiers with let-binding in body
• consumes #[miniextendr(coerce)] parameter attributes and records which params had it

Fields

item: ItemFn

The normalized function item (with dots transformed, wildcards renamed). Re-emitted for the user, so it keeps the parameter markers.

inputs: Punctuated<FnArg, Comma>

item’s parameters with the parameter markers (Checked<T> / Unchecked<T>, #1566) peeled: what the R wrapper, the preconditions and the C wrapper’s conversions see.

param_markers: Vec<(String, Vec<ParamMarker>)>

The markers peeled off each marked parameter (Rust name), in signature order: the C wrapper wraps the converted value in them.

dots: Option<Ident>

Rust binding of the &Dots parameter (R’s ...), from Rust ... or an explicit &Dots parameter at any position (see find_dots_param).

per_param: HashMap<String, ParamAttrs>

All per-parameter #[miniextendr(...)] options (coerce, match_arg, default, choices, several_ok), keyed by the (possibly synthesized) Rust parameter name. Replaces five parallel HashSet / HashMap fields.

Implementations

impl MiniextendrFunctionParsed

Accessors and codegen helpers for MiniextendrFunctionParsed.

Accessors are split into two groups:

• Parsed metadata: dots, coerce, match_arg, choices, and defaults from per-parameter #[miniextendr(...)] attributes.
• Signature components: attrs, vis, abi, ident, generics, inputs, output from the normalized syn::ItemFn.

Codegen helpers produce identifiers and perform mutations needed by the #[miniextendr] expansion pipeline.

pub(crate) fn has_dots(&self) -> bool

Whether the function takes ...: Rust ... or an explicit &Dots parameter, at any position.

pub(crate) fn dots_ident(&self) -> Option<&Ident>

The Rust binding of the dots: the user’s name (args: ..., rest: &Dots), or __miniextendr_dots for _: ....

pub(crate) fn is_dots_param(&self, ident: &Ident) -> bool

Check if a parameter is the dots (...) param, whose R formal is ....

pub(crate) fn has_param_attrs(&self, param_name: &str) -> bool

Whether a parameter carried any per-parameter #[miniextendr(...)] option. A Call / CallerCall marker (#1566) is bound from the call slot, not from an R argument, so none of them apply to it.

pub(crate) fn has_coerce_attr(&self, param_name: &str) -> bool

Check if a parameter name had #[miniextendr(coerce)] attribute.

pub(crate) fn has_match_arg_attr(&self, param_name: &str) -> bool

Check if a parameter name had #[miniextendr(match_arg)] attribute.

pub(crate) fn match_arg_params(&self) -> impl Iterator<Item = &String>

Iterator over parameter names annotated with #[miniextendr(match_arg)], in signature order.

pub(crate) fn choices_params( &self, ) -> impl Iterator<Item = (&String, &Vec<String>)>

Iterator over parameter names annotated with #[miniextendr(choices(…))], together with their choice lists, in signature order.

pub(crate) fn has_several_ok(&self, param_name: &str) -> bool

Check if a parameter has several_ok (multi-value match.arg).

pub(crate) fn param_attrs(&self, param_name: &str) -> Option<&ParamAttrs>

The per-parameter attribute state of param_name, if it carried any #[miniextendr(...)] option. Choice parameters read their layers (Option / Missing, #1473 / #1551) from here.

pub(crate) fn formals(&self) -> Formals

The R formal of each parameter (#1842), from the declared formal = ".." options.

pub(crate) fn absent_formals(&self, c_ident: &str) -> HashMap<String, String>

The parameters that read a value identical() to their formal as omitted, keyed by R formal (see absent_formals_by_r_name).

pub(crate) fn missing_default_param_docs(&self) -> HashMap<String, String>

The generated @param text of each Missing<..> parameter with a default, keyed by R formal (see missing_default_param_docs).

pub(crate) fn explicit_checks(&self) -> HashMap<String, ExplicitChecks>

The inherits / not_inherits / no_na checks of every parameter, keyed by R name (see explicit_checks_by_r_name).

pub(crate) fn precondition_skip_params(&self) -> HashSet<String>

R names of the match_arg and choices(...) parameters, whose type-derived preconditions are skipped because match.arg() already validates them. The method paths build the same set.

pub(crate) fn param_defaults(&self) -> HashMap<String, String>

Returns all parameter defaults as an owned map from Rust parameter name to default value string (the raw R expression used in the wrapper formals, e.g. "NULL", "TRUE", "\"Safe\""). The R wrapper keys them by formal (crate::r_wrapper_builder::Formals::rekey), so a default on _seed is the formal seed’s.

pub(crate) fn attrs(&self) -> &[Attribute]

Original attributes on the function item (doc comments, cfgs, etc.).

pub(crate) fn vis(&self) -> &Visibility

Visibility of the function (pub, pub(crate), or private).

pub(crate) fn abi(&self) -> Option<&Abi>

Explicit ABI, if the function was declared extern "C-unwind".

pub(crate) fn ident(&self) -> &Ident

Function identifier after normalization.

pub(crate) fn generics(&self) -> &Generics

Generic parameters on the function signature.

pub(crate) fn inputs(&self) -> &Punctuated<FnArg, Comma>

Function inputs after normalization (dots rewritten, wildcards renamed), with the parameter markers peeled (see Self::param_markers).

pub(crate) fn param_markers(&self) -> &[(String, Vec<ParamMarker>)]

The Checked<T> / Unchecked<T> markers peeled off the parameters (Rust name → markers, outermost first), in signature order.

pub(crate) fn output(&self) -> &ReturnType

Function return type.

pub(crate) fn item(&self) -> &ItemFn

The normalized function item (with original doc comments).

pub(crate) fn item_without_roxygen(&self) -> ItemFn

The normalized function item with roxygen tags stripped from doc comments.

This is used for emitting the Rust function without R-specific documentation tags (e.g., @param, @examples) that don’t belong in rustdoc.

pub(crate) fn uses_internal_c_wrapper(&self) -> bool

Returns true if this function needs an internal C wrapper (C_<crate>_<name> function).

Rust-ABI functions (no explicit extern) need a generated extern "C-unwind" wrapper that handles SEXP conversion and error propagation. Functions already declared as extern "C-unwind" are passed through directly without wrapping.

pub(crate) fn r_wrapper_const_ident(&self) -> Ident

Returns the identifier for the generated const &str holding the R wrapper code.

The R wrapper is a string constant containing the R function definition that calls .Call(C_<crate>_<name>, ...). It is collected via linkme distributed slices to produce the R/miniextendr-wrappers.R file.

pub(crate) fn c_wrapper_ident(&self) -> Ident

Returns the identifier for the C-callable entry point.

• Rust ABI functions: Returns C_<crate>_<name> (the generated wrapper function, crate-prefixed for webR cross-package symbol uniqueness — #1273).
• extern "C-unwind" functions: Returns the function’s own name, or the value from #[export_name = "..."] if present. The user owns these symbols, including their cross-package uniqueness under webR.

pub(crate) fn export_name_ident(&self) -> Option<Ident>

Extracts the custom symbol name from #[export_name = "..."], if present.

Only meaningful for extern "C-unwind" functions, where #[export_name] is allowed as an alternative to #[no_mangle]. Returns None if no such attribute exists.

pub(crate) fn add_inline_never_if_needed(&mut self)

Add #[inline(never)] if no #[inline(...)] attribute is present. Only for Rust ABI functions - extern “C-unwind” functions are passed through as-is.

Preventing inlining ensures:

• Worker-dispatched functions retain a distinct call frame
• Panic handling and unwinding retain the intended boundary
• Stack traces show the actual function name

Trait Implementations

impl Parse for MiniextendrFunctionParsed

Parses a Rust fn item from a token stream, performing all normalizations required by the #[miniextendr] codegen pipeline.

Normalizations performed

1. Variadic (...) rewriting: Replaces Rust variadic syntax with a typed &miniextendr_api::dots::Dots parameter. Named dots (my_dots: ...) preserve the user’s identifier; _: ... becomes __miniextendr_dots.
2. Wildcard pattern renaming: _ parameter patterns become __unused0, __unused1, etc., so they can be passed by name to the C wrapper.
3. Destructuring expansion: Tuple/struct destructuring patterns are replaced with synthetic identifiers (__param_0, …) and a let binding is prepended to the function body.
4. Per-parameter attribute consumption: #[miniextendr(coerce)], #[miniextendr(match_arg)], #[miniextendr(default = "...")], and #[miniextendr(choices(...))] are consumed from parameters and recorded in the corresponding per_param_* fields.
5. Validation: Rejects #[export_name] on non-extern functions, rejects unsupported parameter patterns, and validates that defaults reference existing parameter names.

fn parse(input: ParseStream<'_>) -> Result<Self>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 600 bytes