Struct ASTRegistry 

pub struct ASTRegistry { /* private fields */ }

Complete AST storage for symbols

Stores the full PureItem AST for each symbol, enabling:

• Direct AST mutation without file I/O
• Complete AST reconstruction at dump time
• Simplified mutation logic (no type-specific storage)

SSOT Design

• All items stored in unified items map via SymbolId
• Module content stored in PureMod.items (Use statements, Impl blocks, etc.)
• Module children tracked in module_children for O(1) access
• Binary entries: individual symbols registered in items (no separate storage)
• Inline modules tracked separately in inline_modules for generation

Implementations

impl ASTRegistry

pub fn new() -> Self

Create a new empty registry

pub fn get(&self, id: SymbolId) -> Option<&PureItem>

Get AST for a symbol (immutable)

pub fn get_mut(&mut self, id: SymbolId) -> Option<&mut PureItem>

Get AST for a symbol (mutable)

pub fn set(&mut self, id: SymbolId, item: PureItem)

Set AST for a symbol

Overwrites existing AST if present.

pub fn remove(&mut self, id: SymbolId) -> Option<PureItem>

Remove AST for a symbol

Returns the removed AST if it existed.

pub fn contains(&self, id: SymbolId) -> bool

Check if symbol has AST

pub fn len(&self) -> usize

Get number of stored ASTs

pub fn is_empty(&self) -> bool

Check if registry is empty

pub fn iter(&self) -> impl Iterator<Item = (SymbolId, &PureItem)>

Iterate all (SymbolId, &PureItem) pairs

pub fn iter_mut(&mut self) -> impl Iterator<Item = (SymbolId, &mut PureItem)>

Iterate all (SymbolId, &mut PureItem) pairs

pub fn clear(&mut self)

Clear all stored ASTs

pub fn mark_inline_module(&mut self, id: SymbolId)

Mark a module as inline (defined with mod name { ... } syntax)

Inline modules stay in their parent file during generation, while external modules get their own files.

pub fn is_inline_module(&self, id: SymbolId) -> bool

Check if a module is inline

pub fn inline_module_ids(&self) -> impl Iterator<Item = SymbolId> + '_

Get all inline module IDs

pub fn get_module_children(&self, module_id: SymbolId) -> Option<&Vec<SymbolId>>

Get child symbol IDs for a module

pub fn get_module_children_mut( &mut self, module_id: SymbolId, ) -> Option<&mut Vec<SymbolId>>

Get child symbol IDs for a module (mutable)

pub fn set_module_children( &mut self, module_id: SymbolId, children: Vec<SymbolId>, )

Set child symbol IDs for a module

pub fn add_child_to_module(&mut self, module_id: SymbolId, child_id: SymbolId)

Add a child to a module

Panics

Panics if module_id is not a valid SymbolId in the underlying SlotMap. Callers are responsible for supplying a registered SymbolId.

pub fn remove_child_from_module( &mut self, module_id: SymbolId, child_id: SymbolId, )

Remove a child from a module

pub fn has_module_children(&self, module_id: SymbolId) -> bool

Check if module has children tracked

pub fn iter_module_children( &self, ) -> impl Iterator<Item = (SymbolId, &Vec<SymbolId>)>

Iterate all (ModuleSymbolId, &Vec<SymbolId>) pairs

pub fn get_module_items(&self, module_id: SymbolId) -> Option<&Vec<PureItem>>

Get all items for a module (including use statements, impl blocks)

pub fn get_module_items_mut( &mut self, module_id: SymbolId, ) -> Option<&mut Vec<PureItem>>

Get all items for a module (mutable)

pub fn set_module_items(&mut self, module_id: SymbolId, items: Vec<PureItem>)

Set all items for a module.

If the module doesn’t exist in the AST registry yet, creates a new empty PureMod entry and sets its items. If items is empty and the module doesn’t exist, no entry is created (mod declarations are generated from module hierarchy, not stored in ASTRegistry).

pub fn has_module_items(&self, module_id: SymbolId) -> bool

Check if module has items stored

pub fn iter_module_items( &self, ) -> impl Iterator<Item = (SymbolId, &Vec<PureItem>)>

Iterate all (ModuleSymbolId, &Vec<PureItem>) pairs

pub fn iter_module_items_mut( &mut self, ) -> impl Iterator<Item = (SymbolId, &mut Vec<PureItem>)>

Iterate all (ModuleSymbolId, &mut Vec<PureItem>) pairs

pub fn build_from_files( files: &HashMap<WorkspaceFilePath, Arc<PureFile>>, registry: &SymbolRegistry, _crate_name: &str, ) -> Self

Build ASTRegistry from parsed files.

Iterates over all files and stores PureItem for each symbol found in SymbolRegistry. This establishes the initial AST state before mutations.

Arguments

• files - Parsed files keyed by workspace path
• registry - Symbol registry with pre-registered symbols
• crate_name - Crate name for path resolution

Trait Implementations

impl Clone for ASTRegistry

fn clone(&self) -> ASTRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ASTRegistry

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

Formats the value using the given formatter.

impl Default for ASTRegistry

fn default() -> ASTRegistry

Returns the “default value” for a type.