Struct tvix_eval::compiler::scope::Scope

pub struct Scope {
    locals: Vec<Local>,
    pub upvalues: Vec<Upvalue>,
    by_name: FxHashMap<String, ByName>,
    scope_depth: usize,
    with_stack_size: usize,
}

Represents a scope known during compilation, which can be resolved directly to stack indices.

Fields

locals: Vec<Local>

upvalues: Vec<Upvalue>

by_name: FxHashMap<String, ByName>

Secondary by-name index over locals.

scope_depth: usize

How many scopes “deep” are these locals?

with_stack_size: usize

Current size of the with-stack at runtime.

Implementations

impl Scope

pub fn inherit(&self) -> Self

Inherit scope details from a parent scope (required for correctly nesting scopes in lambdas and thunks when special scope features like dynamic resolution are present).

pub fn push_with(&mut self)

Increase the with-stack size of this scope.

pub fn pop_with(&mut self)

Decrease the with-stack size of this scope.

pub fn has_with(&self) -> bool

Does this scope currently require dynamic runtime resolution of identifiers that could not be found?

pub fn resolve_local(&mut self, name: &str) -> LocalPosition

Resolve the stack index of a statically known local.

pub fn declare_phantom(&mut self, span: Span, initialised: bool) -> LocalIdx

Declare a local variable that occupies a stack slot and should be accounted for, but is not directly accessible by users (e.g. attribute sets used for with).

pub fn declare_local( &mut self, name: String, span: Span, ) -> (LocalIdx, Option<LocalIdx>)

Declare an uninitialised, named local variable.

Returns the LocalIdx of the new local, and optionally the index of a previous local shadowed by this one.

pub fn declare_constant(&mut self, name: String) -> LocalIdx

pub fn mark_initialised(&mut self, idx: LocalIdx)

Mark local as initialised after compiling its expression.

pub fn mark_needs_finaliser(&mut self, idx: LocalIdx)

Mark local as needing a finaliser.

pub fn mark_must_thunk(&mut self, idx: LocalIdx)

Mark local as must be wrapped in a thunk. This happens if the local has a reference to itself in its upvalues.

pub fn stack_index(&self, idx: LocalIdx) -> StackIdx

Compute the runtime stack index for a given local by accounting for uninitialised variables at scopes below this one.

pub fn begin_scope(&mut self)

Increase the current scope depth (e.g. within a new bindings block, or with-scope).

pub fn end_scope(&mut self) -> (usize, Vec<Span>)

Decrease the scope depth and remove all locals still tracked for the current scope.

Returns the count of locals that were dropped while marked as initialised (used by the compiler to determine whether to emit scope cleanup operations), as well as the spans of the definitions of unused locals (used by the compiler to emit unused binding warnings).

pub fn scope_depth(&self) -> usize

Access the current scope depth.

Trait Implementations

impl Debug for Scope

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

Formats the value using the given formatter.

impl Default for Scope

fn default() -> Scope

Returns the “default value” for a type.

impl Index<LocalIdx> for Scope

type Output = Local

The returned type after indexing.

fn index(&self, index: LocalIdx) -> &Self::Output

Performs the indexing (container[index]) operation.