Struct TraitMethodContext 

pub(super) struct TraitMethodContext<'a> {
    pub(super) method: &'a TraitMethod,
    pub(super) c_ident: String,
    pub(super) params: String,
    pub(super) args: String,
}

Pre-computed context for a trait method, mirroring MethodContext (r_class_formatter.rs) for inherent-impl methods. Holds the C wrapper name, R formals (with defaults), and .Call() argument string so all 5 trait generators build calls identically.

Fields

method: &'a TraitMethod

Reference to the parsed trait method metadata.

c_ident: String

The C wrapper identifier string (e.g., "C_Foo__Bar__value"), used in .Call().

params: String

R formals string with defaults, used in function(...) signatures.

args: String

R call arguments string (without defaults), used inside .Call() expressions. Missing<T> parameters are forwarded as if (missing(p)) quote(expr=) else p — see r_wrapper_builder::RArgumentBuilder::build_call_args_vec. Before this context existed, trait methods built call args via collect_param_idents instead, which skipped that forwarding entirely.

Implementations

impl<'a> TraitMethodContext<'a>

pub(super) fn new( method: &'a TraitMethod, type_ident: &Ident, trait_name: &Ident, ) -> Self

Build a context for method, which implements trait_name for type_ident.

pub(super) fn static_call(&self) -> String

Build the .Call() expression for a static (non-receiver) trait method.

pub(super) fn instance_call(&self, self_expr: &str) -> String

Build the .Call() expression for an instance trait method, with self_expr passed directly as the receiver argument (e.g. ".ptr", "x", "self@.ptr").

This is the structured equivalent of MethodContext::instance_call — no string surgery. It fixes the substring-corruption bug where S4/S7/R6 built the call with self = "x" and then ran call.replace(", x", ", .ptr"): str::replace rewrites every match of the substring ", x", so a parameter whose R name started with x (e.g. x_factor) was corrupted into .ptr_factor, producing a runtime “object ‘.ptr_factor’ not found” error. Passing the receiver expression directly to with_self never touches the other arguments.

pub(super) fn match_arg_prelude(&self) -> Vec<String>

Build R prelude lines validating match_arg/choices params. See r_class_formatter::build_match_arg_prelude.

pub(super) fn precondition_checks(&self) -> Vec<String>

R-side stopifnot() precondition checks for this method’s parameters. See MethodContext::precondition_checks for the inherent-impl twin.

pub(super) fn emit_method_prelude( &self, lines: &mut Vec<String>, indent: &str, what: &str, )

Emit the shared method prelude into lines, each line prefixed with indent — the trait-impl twin of MethodContext::emit_method_prelude. In order: r_entry, r_on_exit, lifecycle_prelude, precondition_checks, match_arg_prelude, r_post_checks.

Missing<T> forwarding is not a prelude step here either — it’s inline in self.args (built in new), matching the inherent path.

what is the human-readable label passed to the lifecycle prelude. This mirrors the pre-refactor trait_method_preamble_lines, which always used the R-facing method name as what regardless of class system (inherent methods instead use a class-qualified label like "Type.method" — trait methods keep the simpler unqualified label to avoid changing existing lifecycle-warning wording).

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