Struct ParsedMethod 

pub struct ParsedMethod {
    pub ident: Ident,
    pub env: ReceiverKind,
    pub sig: Signature,
    pub vis: Visibility,
    pub doc_tags: Vec<String>,
    pub method_attrs: MethodAttrs,
    pub param_defaults: HashMap<String, String>,
}

Parsed method from an impl block.

Default Parameters

Default parameters are specified using method-level syntax:

• #[miniextendr(defaults(param = "value", ...))] on the method

Note: Parameter-level #[miniextendr(default = "...")] syntax is only supported for standalone functions, not impl methods (Rust language limitation).

Defaults cannot be specified for self parameters (compile error).

Fields

ident: Ident

The method’s name (e.g., new, get, set_value).

env: ReceiverKind

How this method receives self: &self, &mut self, by value, or not at all (static).

sig: Signature

Method signature with the self receiver stripped. Used for C wrapper generation where self is handled separately as a SEXP parameter.

vis: Visibility

Rust visibility of the method. Non-pub methods become private in R6; only pub methods get @export in R wrappers.

doc_tags: Vec<String>

Roxygen tag lines extracted from Rust doc comments

method_attrs: MethodAttrs

Per-method attributes for class system overrides. Also carries the match_arg(...) / choices(...) / several_ok parameter annotations via its per_param_match_arg / per_param_choices / per_param_several_ok fields — see MethodAttrs for the parsing surface.

param_defaults: HashMap<String, String>

Parameter default values from #[miniextendr(default = "...")]

Implementations

impl ParsedMethod

fn validate_method_attrs( attrs: &MethodAttrs, class_system: ClassSystem, span: Span, ) -> Result<()>

Validate method attributes for the given class system. Returns an error if unsupported attributes are used.

fn split_choice_list(raw: &str) -> Vec<String>

Split a comma-separated choices list (as given to choices(param = "a, b, c")) into individual trimmed entries. Surrounding double-quotes are tolerated so users can spell the list either way: "a, b" or "\"a\", \"b\"".

fn parse_method_attrs(attrs: &[Attribute]) -> Result<MethodAttrs>

Parse method attributes in #[miniextendr(class_system(…))] format.

Supported formats:

• #[miniextendr(r6(ignore, constructor, finalize, private, generic = "...")]
• #[miniextendr(s3(ignore, constructor, generic = "..."))]
• #[miniextendr(s7(ignore, constructor, generic = "..."))]
• etc.

fn detect_env(sig: &Signature) -> ReceiverKind

Detect the ReceiverKind from a method’s function signature.

Inspects the first parameter to determine whether this is a static function (None), immutable borrow (Ref), mutable borrow (RefMut), consuming method (Value), or ExternalPtr receiver (ExternalPtrRef, ExternalPtrRefMut, ExternalPtrValue). Handles both standard receivers (&self, &mut self) and typed receivers (self: &Self, self: ExternalPtr<Self>, etc.).

fn sig_without_env(sig: &Signature) -> Signature

Create a copy of the method signature with the self receiver removed.

The C wrapper receives self as a separate SEXP argument and extracts it from an ErasedExternalPtr, so the receiver must not appear in the parameter list used for SEXP-to-Rust conversion codegen.

pub fn from_impl_item( item: ImplItemFn, _class_system: ClassSystem, ) -> Result<Self>

Parse a method from an impl item.

Regular doc comments are auto-converted to @description for all class systems.

pub fn should_include(&self) -> bool

Returns true if this method should be included in the class.

pub fn is_private(&self) -> bool

Returns true if this method should be private in R6. Inferred from Rust visibility: anything not pub is private.

pub fn is_constructor(&self) -> bool

Returns true if this is likely a constructor. Inferred from: no env + named “new” + returns Self.

pub fn is_finalizer(&self) -> bool

Returns true if this is likely a finalizer. Inferred from: consumes self (by value) + doesn’t return Self.

pub fn is_active(&self) -> bool

Returns true if this method should be an R6 active binding. Active bindings provide property-like access (obj$name instead of obj$name()).

pub fn r_method_name(&self) -> String

R-facing method name.

Returns r_name if set, otherwise the Rust ident as a string.

pub fn c_wrapper_ident(&self, type_ident: &Ident, label: Option<&str>) -> Ident

C wrapper identifier for this method.

Format: C_{Type}__{method} or C_{Type}_{label}__{method} if labeled.

pub fn lifecycle_prelude(&self, what: &str) -> Option<String>

Generate lifecycle prelude R code for this method, if lifecycle is specified.

The what parameter describes the method in the format appropriate for the class system:

• Env/R6: "Type$method()"
• S3: "method.Type()"
• S7: "method()“ (dispatched generics)

pub fn returns_self(&self) -> bool

Returns true if this method returns Self.

pub fn returns_unit(&self) -> bool

Returns true if this method has no return type (returns unit ()).

Trait Implementations

impl Debug for ParsedMethod

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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: 1248 bytes