Struct IdGenerator 

pub struct IdGenerator { /* private fields */ }

Generates scope-aware vertex IDs for AST nodes.

Implementations

impl IdGenerator

pub fn new(file_path: &str) -> Self

Create a new generator rooted at the given file path.

pub fn record_name(&mut self, name: &str) -> String

Record an occurrence of name in the current frame and return the disambiguated form: name for the first occurrence, then name#1, name#2, ….

The current frame is the parent of any vertex about to be emitted under name, so disambiguation is one-per-parent.

Callers that want a vertex ID and a matching scope push (the walker’s case when a named-scope node is also scope-introducing) use this once and then Self::push_recorded_scope with the returned leaf, so the scope-stack frame and the vertex ID agree on the suffix.

pub fn push_named_scope(&mut self, name: &str) -> String

Push a named scope (function, class, method, module, etc.).

Named scopes appear in the ID as their (disambiguated) name: file.rs::function_name::…. Returns the disambiguated leaf so the caller can use it as the vertex ID for the scope-introducing node itself.

pub fn push_recorded_scope(&mut self, leaf: String)

Push a scope using a name that was already disambiguated by Self::record_name. The frame’s name field becomes leaf verbatim — no further suffixing.

Walker pattern:

let leaf = id_gen.record_name("foo");
let vertex_id = format!("{}::{leaf}", id_gen.current_prefix());
// … emit vertex, edges, constraints …
id_gen.push_recorded_scope(leaf);   // frame = "foo" / "foo#1" / …

pub fn push_anonymous_scope(&mut self) -> u32

Push an anonymous scope (block, statement body, etc.) and return its positional index.

pub fn pop_scope(&mut self)

Pop the current scope, returning to the parent.

Debug builds assert that the root frame is not popped. Walker bugs that mis-pair push and pop surface here rather than as mis-shaped IDs down the road.

pub fn named_id(&mut self, name: &str) -> String

Generate an ID for a named node at the current scope level.

Returns the full scope-qualified ID. The second call with the same name at the same scope returns name#1, the third name#2, and so on. Disambiguation is recorded so a matching Self::push_named_scope call returns the same suffix.

pub fn anonymous_id(&mut self) -> String

Generate an ID for an anonymous (positional) node at the current scope level.

The index is auto-incremented within the current scope and is independent of the named-id occurrence counters, so anonymous and named children can interleave at one scope without collision.

pub fn field_id(&mut self, base_id: &str, field_name: &str) -> String

Generate an ID with a field path suffix for expression sub-nodes.

Used for expression tree paths like $3::$0.left where .left is the field name within the parent expression.

Repeated calls with the same base_id and field_name are disambiguated by a #N suffix, mirroring the named-id scheme. Tree-sitter field('xs', repeat($.X)) shapes produce many args children under one parent; without disambiguation the resulting IDs would collide.

pub fn current_prefix(&self) -> String

Get the current scope prefix (all scope components joined by ::).

pub fn depth(&self) -> usize

Get the current scope depth.

pub fn reset_counter(&mut self)

Reset the anonymous-child counter for the current scope.

Useful when entering a new block within the same scope level. The seen table for named-id disambiguation is not reset; resetting it would re-introduce duplicate-vertex bugs when a caller intentionally interleaves blocks under one scope.

Trait Implementations

impl Debug for IdGenerator

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

Formats the value using the given formatter.