Struct ASTMutationContext 

pub struct ASTMutationContext<'a> {
    pub ast_registry: &'a mut ASTRegistry,
    pub symbol_registry: &'a mut SymbolRegistry,
    /* private fields */
}

Context passed to ASTRegApply::apply_to_registry

Provides access to ASTRegistry, SymbolRegistry, and event emission.

Binary Entry (main.rs) Support

Binary entry symbols (main.rs, src/bin/*.rs) are registered in the unified items map like library symbols. Use WorkspaceFilePath::is_binary_entry() to identify binary files when needed for file output.

Fields

ast_registry: &'a mut ASTRegistry

AST storage (complete PureItem per symbol)

symbol_registry: &'a mut SymbolRegistry

Symbol metadata (path ↔ id, kind, span, etc.)

Implementations

impl<'a> ASTMutationContext<'a>

pub fn new( ast_registry: &'a mut ASTRegistry, symbol_registry: &'a mut SymbolRegistry, ) -> Self

Create a new mutation context

pub fn into_events(self) -> Vec<MutationEvent>

Consume context and return collected events

pub fn emit(&mut self, event: MutationEvent)

Emit an event (for logging/tracking)

pub fn emit_added(&mut self, path: SymbolPath, kind: SymbolKind)

Emit symbol added event

pub fn emit_removed(&mut self, path: SymbolPath)

Emit symbol removed event

pub fn emit_modified(&mut self, id: SymbolId, modification: ModificationType)

Emit symbol modified event

pub fn emit_renamed(&mut self, old_path: SymbolPath, new_path: SymbolPath)

Emit symbol renamed event

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

Get AST for a symbol (immutable)

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

Get AST for a symbol (mutable)

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

Set AST for a symbol

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

Check if symbol has AST

pub fn lookup(&self, path: &SymbolPath) -> Option<SymbolId>

Lookup symbol by path

pub fn path(&self, id: SymbolId) -> Option<&SymbolPath>

Get symbol path by ID

pub fn kind(&self, id: SymbolId) -> Option<SymbolKind>

Get symbol kind by ID

pub fn resolve_symbol_by_name( &self, name: &str, kinds: &[SymbolKind], ) -> Result<SymbolId, ResolveError>

Resolve symbol ID by name, supporting both simple name and full path.

• If name contains “::”, performs full path match (always unique)
• Otherwise, matches by last segment (symbol name) only

Errors

• ResolveError::NotFound - no matching symbol
• ResolveError::Ambiguous - multiple symbols match (use full path)

Example

// Find struct by simple name (fails if multiple "User" exist)
let id = ctx.resolve_symbol_by_name("User", &[SymbolKind::Struct])?;

// Find by full path (always unambiguous)
let id = ctx.resolve_symbol_by_name("crate::user::UserStatus", &[SymbolKind::Enum])?;

pub fn register( &mut self, path: SymbolPath, kind: SymbolKind, ) -> Option<SymbolId>

Register new symbol (emits SymbolAdded event)

Returns None if registration fails (e.g., duplicate path).

pub fn register_with_ast( &mut self, path: SymbolPath, kind: SymbolKind, ast: PureItem, ) -> Option<SymbolId>

Register new symbol with AST (emits SymbolAdded event)

Returns None if registration fails.

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

Remove symbol (emits SymbolRemoved event)

This removes the symbol from:

1. SymbolRegistry (path → id mapping)
2. ASTRegistry items (id → PureItem mapping)
3. Parent module’s module_items list (for file generation)

pub fn rename_symbol( &mut self, id: SymbolId, new_path: SymbolPath, ) -> Result<(), String>

Rename symbol (emits SymbolRenamed event)