Struct RustResolutionContext 

pub struct RustResolutionContext { /* private fields */ }

Rust-specific resolution context implementing proper scoping rules

Rust has a specific resolution order:

1. Local scope (variables, parameters)
2. Imported symbols (use statements)
3. Module symbols (items in current module)
4. Crate symbols (pub items from crate root)

Implementations

impl RustResolutionContext

pub fn new(file_id: FileId) -> Self

pub fn add_import(&mut self, path: String, alias: Option<String>)

Add an import (use statement)

pub fn add_local(&mut self, name: String, symbol_id: SymbolId)

Add a local variable or parameter to the current scope

pub fn add_import_symbol( &mut self, name: String, symbol_id: SymbolId, _is_aliased: bool, )

Add an imported symbol with resolved SymbolId

pub fn add_module_symbol(&mut self, name: String, symbol_id: SymbolId)

Add a module-level symbol from the current file

pub fn add_crate_symbol(&mut self, name: String, symbol_id: SymbolId)

Add a crate-level public symbol

pub fn is_imported(&self, name: &str) -> bool

Check if a symbol with the given name was imported

Trait Implementations

impl ResolutionScope for RustResolutionContext

fn as_any_mut(&mut self) -> &mut dyn Any

Get as Any for downcasting (needed for language-specific operations)

fn add_symbol( &mut self, name: String, symbol_id: SymbolId, scope_level: ScopeLevel, )

Add a symbol to the scope at the specified level

fn resolve(&self, name: &str) -> Option<SymbolId>

Resolve a symbol name according to language-specific rules

fn clear_local_scope(&mut self)

Clear the local scope (e.g., when exiting a function)

fn enter_scope(&mut self, scope_type: ScopeType)

Enter a new scope (e.g., entering a function or block)

fn exit_scope(&mut self)

Exit the current scope

fn symbols_in_scope(&self) -> Vec<(String, SymbolId, ScopeLevel)>

Get all symbols currently in scope (for debugging)

fn resolve_relationship( &self, _from_name: &str, to_name: &str, kind: RelationKind, _from_file: FileId, ) -> Option<SymbolId>

Resolve a relationship-aware symbol reference

fn populate_imports(&mut self, imports: &[Import])

Populate import records into the resolution context

fn register_import_binding(&mut self, binding: ImportBinding)

Register a processed import binding for later queries

fn import_binding(&self, name: &str) -> Option<ImportBinding>

Retrieve a previously registered import binding by exposed name

fn resolve_expression_type(&self, _expr: &str) -> Option<String>

Resolve an expression (e.g., receiver) to a concrete type string if available

fn is_external_import(&self, name: &str) -> bool

Check if a name refers to an external import

fn is_compatible_relationship( &self, from_kind: SymbolKind, to_kind: SymbolKind, rel_kind: RelationKind, ) -> bool

Check if a relationship between two symbol kinds is valid