Struct MethodReturnBuilder 

pub struct MethodReturnBuilder {
    call_expr: String,
    strategy: ReturnStrategy,
    class_name: Option<String>,
    chain_var: Option<String>,
    indent: usize,
}

Builder for generating R method body lines with appropriate return handling.

Produces lines of R code for a method body, combining the .Call() expression with the return strategy and the tagged-condition error guard. Each class system has specialized builder methods (build_r6_body, build_s3_body, etc.) that produce idiomatic R code for that system.

Fields

call_expr: String

The .Call() expression string (e.g., ".Call(C_Counter__inc, .call = match.call(), self)").

strategy: ReturnStrategy

How to handle the return value (direct, chaining, or Self wrapping).

class_name: Option<String>

R class name, required when strategy is ReturnSelf to construct the class wrapper (e.g., "Counter" for Counter$new(.ptr = result)).

chain_var: Option<String>

Variable name to return for ChainableMutation strategy (e.g., "self" for R6, "x" for S3). Defaults to "self" if not set.

indent: usize

Number of leading spaces for each generated line.

Implementations

impl MethodReturnBuilder

pub fn new(call_expr: String) -> Self

Create a new builder with the given .Call expression.

pub fn with_strategy(self, strategy: ReturnStrategy) -> Self

Set the return strategy.

pub fn with_class_name(self, class_name: String) -> Self

Set the class name (for Self returns).

pub fn with_chain_var(self, var: String) -> Self

Set the variable name to return for chaining (default: “self”).

pub fn with_indent(self, indent: usize) -> Self

Set indentation level (number of spaces).

fn build_with_tails(&self, tails: ReturnTails<'_>) -> Vec<String>

Emit:

<indent>.val <- <call_expr>
<indent>if (inherits(.val, ...) ...) return(...)
<tail lines — .val is live>

All paths capture the .Call() result, dispatch on the tagged condition value if present, and then run the class-specific tail.

pub fn build(&self) -> Vec<String>

Build R code lines for the method body.

Returns a vector of strings, one per line (without trailing newlines).

impl MethodReturnBuilder

Specialized builders for different class systems.

pub fn build_r6_body(&self) -> Vec<String>

Build R6-style return (uses invisible(self) for chaining).

pub fn build_s3_body(&self) -> Vec<String>

Build S3-style return (uses structure() for Self returns).

pub fn build_s7_body(&self) -> Vec<String>

Build S7-style method body lines (creates new S7 object with .ptr).

Returns lines suitable for embedding inside an outer function(...) { ... } block — unlike build_s7_inline which wraps the body in its own { } and is intended for callers that emit function(...) <expr> directly (e.g., S7 convert definitions).

pub fn build_s4_body(&self) -> Vec<String>

Build S4-style method body lines (uses methods::new() to wrap Self returns).

Returns lines suitable for embedding inside an outer function(...) { ... } block, mirroring build_s7_body.

pub fn build_s7_inline(&self) -> String

Build S7-style return (creates new S7 object with .ptr).

Returns a multi-line block expression that performs the condition check inline (suitable for S7 property definitions / convert methods that require a single expression).

pub fn build_s4_inline(&self) -> String

Build S4-style return (uses methods::new()).

Returns a multi-line block expression that performs the condition check inline.

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