Struct LocalVariableRaw 

pub struct LocalVariableRaw {
    pub rid: u32,
    pub token: Token,
    pub offset: usize,
    pub attributes: u16,
    pub index: u16,
    pub name: u32,
}

Raw binary representation of a LocalVariable table entry

This structure matches the exact binary layout of LocalVariable table entries in the metadata tables stream. The Name field contains an unresolved index into the #Strings heap that must be resolved during conversion to the owned LocalVariable variant.

Binary Format

Each LocalVariable table entry consists of:

• Attributes: 2-byte unsigned integer with variable flags
• Index: 2-byte unsigned integer (variable index within method)
• Name: Index into #Strings heap for the variable name

Fields

rid: u32

Row identifier (1-based index in the table)

token: Token

Metadata token for this LocalVariable entry

offset: usize

Byte offset of this row in the original metadata stream

attributes: u16

Variable attribute flags

A bitfield containing flags that describe characteristics of the local variable. Common flags include whether the variable is a compiler-generated temporary, whether it’s a pinned variable, etc.

index: u16

Variable index within the method

Zero-based index that identifies this variable within the containing method. This index corresponds to the variable’s position in the method’s local variable signature and IL instructions.

name: u32

Index into #Strings heap for variable name

Points to the variable’s name string in the metadata #Strings heap. This index must be resolved to get the actual variable name string. May be 0 for anonymous or compiler-generated variables.

Implementations

impl LocalVariableRaw

pub fn to_owned(&self, strings: &Strings<'_>) -> Result<LocalVariableRc>

Converts this raw LocalVariable entry to an owned LocalVariable instance

This method resolves the raw LocalVariable entry to create a complete LocalVariable object by resolving the name string from the #Strings heap.

Parameters

• strings: Reference to the #Strings heap for resolving the name index

Returns

Returns Ok(LocalVariableRc) with the resolved variable data, or an error if the name index is invalid or points to malformed string data.

Errors

Returns an error if the name index is invalid or points to malformed string data.

Example

let variable_raw = LocalVariableRaw {
    rid: 1,
    token: Token::new(0x33000001),
    offset: 0,
    attributes: 0,      // No special attributes
    index: 0,           // First local variable
    name: 42,           // Index into #Strings heap
};

let variable = variable_raw.to_owned(strings)?;

Trait Implementations

impl Clone for LocalVariableRaw

fn clone(&self) -> LocalVariableRaw

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LocalVariableRaw

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

Formats the value using the given formatter.

impl RowReadable for LocalVariableRaw

const TABLE_ID: TableId = TableId::LocalVariable

The table ID for this row type.

fn row_read( data: &[u8], offset: &mut usize, rid: u32, sizes: &TableInfoRef, ) -> Result<Self>

Reads and parses a single row from the provided byte buffer.

impl RowWritable for LocalVariableRaw

fn row_write( &self, data: &mut [u8], offset: &mut usize, _rid: u32, sizes: &TableInfoRef, ) -> Result<()>

Write a LocalVariable table row to binary data

Serializes one LocalVariable table entry to the metadata tables stream format, handling variable-width string heap indexes based on the heap size information.

Arguments

• data - Target binary buffer for metadata tables stream
• offset - Current write position (updated after writing)
• _rid - Row identifier for this local variable entry (unused for LocalVariable)
• sizes - Table sizing information for writing heap indexes

Returns

• Ok(()) - Successfully serialized local variable row
• Err(crate::Error) - If buffer is too small or write fails

Binary Format

Fields are written in the exact order specified by the Portable PDB specification:

1. Attributes (2 bytes, little-endian)
2. Index (2 bytes, little-endian)
3. Name string index (2/4 bytes, little-endian, 0 = anonymous)

impl TableRow for LocalVariableRaw

fn row_size(sizes: &TableInfoRef) -> u32

Calculate the row size for LocalVariable table entries

Returns the total byte size of a single LocalVariable table row based on the table configuration. The size varies depending on the size of heap indexes in the metadata.

Size Breakdown

• attributes: 2 bytes (variable attribute flags)
• index: 2 bytes (variable index within method)
• name: 2 or 4 bytes (string heap index for variable name)

Total: 6-8 bytes depending on heap size configuration