Struct CSharpResolutionContext 

pub struct CSharpResolutionContext { /* private fields */ }

C#-specific resolution context

C# has these resolution features:

1. Namespace scoping
2. Using directives
3. Type vs value space separation (limited compared to TypeScript)
4. Class member visibility
5. Assembly boundaries

Implementations

impl CSharpResolutionContext

pub fn new(file_id: FileId) -> Self

pub fn add_using(&mut self, namespace: String, alias: Option<String>)

Add a using directive

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

Add an imported symbol from a using directive

pub fn add_symbol_with_context( &mut self, name: String, symbol_id: SymbolId, scope_context: Option<&ScopeContext>, )

Add a symbol with proper scope context

Trait Implementations

impl ResolutionScope for CSharpResolutionContext

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 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 populate_imports(&mut self, imports: &[Import])

Populate import records into the resolution context

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