Struct SignatureLocalVariables 

pub struct SignatureLocalVariables {
    pub locals: Vec<SignatureLocalVariable>,
}

Local variable signature collection for method bodies.

Represents the complete local variable signature according to ECMA-335 Section II.23.2.6. This contains all local variables declared within a method body, including their types, modifiers, and special attributes like pinning and reference semantics.

Local Variable Characteristics

Scope and Lifetime

Local variables are scoped to the method in which they are declared:

• Created when the method is entered
• Destroyed when the method exits
• Accessible only within the declaring method
• Zero-initialized by default unless explicitly assigned

Memory Management

Local variables use stack-based allocation by default:

• Value types: Stored directly on the stack
• Reference types: References stored on stack, objects on heap
• Pinned variables: Prevent garbage collection movement
• Large objects: May be allocated on the large object heap

Binary Format (ECMA-335)

Local variable signatures are encoded as:

LocalVarSig ::= LOCAL_SIG Count (TYPEDBYREF | ([CustomMod]* [Constraint])* [BYREF] Type)*

Examples

Simple Local Variables

use dotscope::metadata::signatures::{SignatureLocalVariables, SignatureLocalVariable, TypeSignature};

let locals = SignatureLocalVariables {
    locals: vec![
        SignatureLocalVariable {
            modifiers: vec![],
            is_byref: false,
            is_pinned: false,
            base: TypeSignature::I4,           // int local
        },
        SignatureLocalVariable {
            modifiers: vec![],
            is_byref: false,
            is_pinned: false,
            base: TypeSignature::String,       // string local
        },
    ],
};

Complex Local Variables

use dotscope::metadata::signatures::{SignatureLocalVariables, SignatureLocalVariable, TypeSignature};

let complex_locals = SignatureLocalVariables {
    locals: vec![
        SignatureLocalVariable {
            modifiers: vec![],
            is_byref: true,                    // ref variable
            is_pinned: false,
            base: TypeSignature::I4,
        },
        SignatureLocalVariable {
            modifiers: vec![],
            is_byref: false,
            is_pinned: true,                   // pinned variable
            base: TypeSignature::String,
        },
    ],
};

Thread Safety

SignatureLocalVariables is immutable after construction and safe to share between threads. The actual local variable storage is thread-local per method execution.

ECMA-335 Compliance

This structure implements ECMA-335 Partition II, Section 23.2.6 (LocalVarSig) and supports all standard local variable signature scenarios.

See Also

• SignatureLocalVariable: For individual local variable definitions
• crate::metadata::signatures::TypeSignature: For supported local variable types
• crate::metadata::method::MethodBody: For method body context

Fields

locals: Vec<SignatureLocalVariable>

The collection of local variables declared in this method.

Each SignatureLocalVariable represents a single local variable with its type, modifiers, and special attributes. The order matches the declaration order in the method body.

Variable Access

Local variables are accessed by index in IL instructions:

• ldloc.0, ldloc.1, etc. for loading local variables
• stloc.0, stloc.1, etc. for storing to local variables
• Index corresponds to position in this vector

Empty Collections

Methods without local variables have an empty vector. This is common for simple methods that only use parameters.

Trait Implementations

impl Clone for SignatureLocalVariables

fn clone(&self) -> SignatureLocalVariables

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignatureLocalVariables

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

Formats the value using the given formatter.

impl Default for SignatureLocalVariables

fn default() -> SignatureLocalVariables

Returns the “default value” for a type.

impl PartialEq for SignatureLocalVariables

fn eq(&self, other: &SignatureLocalVariables) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SignatureLocalVariables