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 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_result_self(&self) -> bool

Returns true if this method returns Result<Self, E> — a fallible constructor-shaped method (e.g. from_r, try_new). On the R side this is treated exactly like a bare Self return (wrapped class object via crate::ReturnStrategy::for_method); the C wrapper still raises on Err via the normal Result error path (see crate::c_wrapper_builder::ReturnHandling::ResultExternalPtr).

pub fn returns_option_self(&self) -> bool

Returns true if this method returns Option<Self> — a lookup-shaped fallible constructor (e.g. try_find). On the R side this is treated exactly like a bare Self return (wrapped class object via crate::ReturnStrategy::for_method); the C wrapper still raises on None via the normal Option error path (see crate::c_wrapper_builder::ReturnHandling::OptionExternalPtr). Symmetric with Self::returns_result_self.

pub fn returns_self_ref(&self) -> bool

Returns true if this method returns a reference to Self (&Self or &mut Self) — the idiomatic Rust in-place builder signature.

These methods mutate (&mut self) or read (&self) the receiver and return a borrow of the same value so calls can be chained in Rust (b.set_a(1).set_b(2)). On the R side this maps to a pipe-friendly free function (S3) / chainable instance method that returns the same ExternalPtr handle, so the R idiom obj |> set_a(1) |> set_b(2) works with in-place value semantics (no clone). See crate::c_wrapper_builder::ReturnHandling::SelfHandle.

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