Struct StateMachineMethodBuilder 

pub struct StateMachineMethodBuilder { /* private fields */ }

Builder for constructing StateMachineMethod table entries

Provides a fluent interface for building StateMachineMethod metadata table entries. These entries map compiler-generated state machine methods back to their original user-written methods, enabling proper debugging of async/await and iterator methods.

Required Fields

• move_next_method: MethodDef RID for the compiler-generated MoveNext method
• kickoff_method: MethodDef RID for the original user-written method

State Machine Context

When compilers generate state machines for async/await or yield return patterns:

1. The original method becomes the “kickoff” method that initializes the state machine
2. A new MoveNext method contains the actual implementation logic
3. This table provides the bidirectional mapping between these methods

Examples

use dotscope::prelude::*;

// Map async method to its state machine
let async_mapping = StateMachineMethodBuilder::new()
    .move_next_method(123)  // Compiler-generated MoveNext method
    .kickoff_method(45)     // Original async method
    .build(&mut assembly)?;

// Map iterator method to its state machine
let iterator_mapping = StateMachineMethodBuilder::new()
    .move_next_method(200)  // Compiler-generated MoveNext method
    .kickoff_method(78)     // Original iterator method
    .build(&mut assembly)?;

Implementations

impl StateMachineMethodBuilder

pub fn new() -> Self

Creates a new StateMachineMethodBuilder with default values

Initializes a new builder instance with all fields unset. The caller must provide both required fields before calling build().

Returns

A new StateMachineMethodBuilder instance ready for configuration

Examples

use dotscope::prelude::*;

let builder = StateMachineMethodBuilder::new();

pub fn move_next_method(self, move_next_method: u32) -> Self

Sets the MoveNext method RID

Specifies the MethodDef RID for the compiler-generated MoveNext method that contains the actual state machine implementation logic.

Parameters

• move_next_method: MethodDef RID for the MoveNext method

Returns

Self for method chaining

Examples

use dotscope::prelude::*;

let builder = StateMachineMethodBuilder::new()
    .move_next_method(123);  // RID of compiler-generated method

pub fn kickoff_method(self, kickoff_method: u32) -> Self

Sets the kickoff method RID

Specifies the MethodDef RID for the original user-written method that was transformed into a state machine by the compiler.

Parameters

• kickoff_method: MethodDef RID for the original method

Returns

Self for method chaining

Examples

use dotscope::prelude::*;

let builder = StateMachineMethodBuilder::new()
    .kickoff_method(45);  // RID of original user method

pub fn build(self, assembly: &mut CilAssembly) -> Result<ChangeRefRc>

Builds and adds the StateMachineMethod entry to the metadata

Validates all required fields, creates the StateMachineMethod table entry, and adds it to the assembly. Returns a token that can be used to reference this state machine method mapping.

Parameters

• assembly: Mutable reference to the CilAssembly

Returns

• Ok(Token): Token referencing the created state machine method mapping
• Err(Error): If validation fails or table operations fail

Errors

• Missing required field (move_next_method or kickoff_method)
• Table operations fail due to metadata constraints
• State machine method validation failed

Examples

use dotscope::prelude::*;

let mut assembly = CilAssembly::new(view);
let token = StateMachineMethodBuilder::new()
    .move_next_method(123)
    .kickoff_method(45)
    .build(&mut assembly)?;

Trait Implementations

impl Clone for StateMachineMethodBuilder

fn clone(&self) -> StateMachineMethodBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StateMachineMethodBuilder

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

Formats the value using the given formatter.

impl Default for StateMachineMethodBuilder

fn default() -> Self

Creates a default StateMachineMethodBuilder

Equivalent to calling StateMachineMethodBuilder::new().