Struct TypeScriptResolutionContext 

pub struct TypeScriptResolutionContext { /* private fields */ }

TypeScript-specific resolution context handling hoisting, namespaces, and dual spaces

TypeScript has unique resolution features:

1. Hoisting (functions and var declarations)
2. Block scoping (let/const)
3. Separate type and value spaces
4. Namespace scoping

Implementations

impl TypeScriptResolutionContext

pub fn new(file_id: FileId) -> Self

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

Add an import (import statement)

pub fn add_namespace_alias(&mut self, alias: String, target_module: String)

Record a namespace alias mapping (e.g., import * as React from ‘react’)

pub fn add_qualified_name(&mut self, qualified: String, symbol_id: SymbolId)

Add a qualified name binding for fast resolution (e.g., “Utils.helper” -> id)

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

Add an imported symbol to the context

This is called when an import is resolved to add the symbol to the appropriate space. Type-only imports go to the type space, others to imported_symbols.

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

Add a symbol with proper scope context

This method uses the symbol’s scope_context to determine proper placement. Functions are hoisted, let/const are block-scoped, var is function-scoped.

Trait Implementations

impl ResolutionScope for TypeScriptResolutionContext

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 is_compatible_relationship( &self, from_kind: SymbolKind, to_kind: SymbolKind, rel_kind: RelationKind, ) -> bool

Check if a relationship between two symbol kinds is valid

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