Struct DebugVariableInfo 

pub struct DebugVariableInfo {
    pub name_idx: u32,
    pub type_idx: DebugTypeIdx,
    pub arg_index: u32,
    pub line: LineNumber,
    pub column: ColumnNumber,
    pub scope_depth: u32,
}

Debug information for a local variable or parameter.

This struct captures the source-level information about a variable, enabling debuggers to display variable names, types, and locations to users.

Fields

name_idx: u32

Name of the variable (index into string table)

type_idx: DebugTypeIdx

Type of the variable (index into type table)

arg_index: u32

If this is a parameter, its 1-based index (0 = not a parameter)

line: LineNumber

Line where the variable is declared (1-indexed)

column: ColumnNumber

Column where the variable is declared (1-indexed)

scope_depth: u32

Scope depth indicating the lexical nesting level of this variable.

• 0 = function-level scope (parameters and variables at function body level)
• 1 = first nested block (e.g., inside an if or loop)
• 2 = second nested block, and so on

This is used by debuggers to:

1. Determine variable visibility at a given execution point
2. Handle variable shadowing (a variable with the same name but higher depth shadows one with lower depth when both are in scope)
3. Display variables grouped by their scope level

For example, in:

fn foo(x: i32) {           // x has scope_depth 0
    let y = 1;             // y has scope_depth 0
    if condition {
        let z = 2;         // z has scope_depth 1
        let x = 3;         // this x has scope_depth 1, shadows parameter x
    }
}

Implementations

impl DebugVariableInfo

pub fn new( name_idx: u32, type_idx: DebugTypeIdx, line: LineNumber, column: ColumnNumber, ) -> Self

Creates a new variable info.

pub fn with_arg_index(self, arg_index: u32) -> Self

Sets this variable as a parameter with the given 1-based index.

pub fn with_scope_depth(self, scope_depth: u32) -> Self

Sets the scope depth.

pub fn is_parameter(&self) -> bool

Returns true if this variable is a function parameter.

Trait Implementations

impl Clone for DebugVariableInfo

fn clone(&self) -> DebugVariableInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DebugVariableInfo

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

Formats the value using the given formatter.

impl Deserializable for DebugVariableInfo

fn read_from<R: ByteReader>( source: &mut R, ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl<'de> Deserialize<'de> for DebugVariableInfo

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DebugVariableInfo

fn eq(&self, other: &DebugVariableInfo) -> 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 Serializable for DebugVariableInfo

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Serialize for DebugVariableInfo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DebugVariableInfo

impl StructuralPartialEq for DebugVariableInfo