Struct JavaResolutionContext 

pub struct JavaResolutionContext { /* private fields */ }

Resolution context for Java

Java has a 5-tier scope system (simpler than Kotlin - no companion objects):

1. Local scope - variables and parameters within methods/blocks
2. Class scope - fields and methods of the current class
3. File scope - other classes in the same file
4. Imported scope - symbols from import statements
5. Package scope - classes in the same package (package-private access)

Implementations

impl JavaResolutionContext

pub fn new(file_id: FileId) -> Self

pub fn set_expression_types(&mut self, _entries: HashMap<String, String>)

Set expression types for type inference TODO: Implement if Java needs type inference

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

Get import binding for a name

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

Resolve expression type from inference TODO: Implement if Java needs type inference

Trait Implementations

impl ResolutionScope for JavaResolutionContext

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

Add symbol to appropriate scope level

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

Resolve symbol name to ID

fn clear_local_scope(&mut self)

Clear local scope (called on scope exit)

fn enter_scope(&mut self, scope_type: ScopeType)

Enter new scope

fn exit_scope(&mut self)

Exit current scope

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

Get all symbols in current scope

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

Downcast to concrete type

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

Resolve relationship (calls, extends, implements, etc.)

Routes relationship resolution based on kind. Most relationships delegate to standard resolution, with special handling for:

• Qualified method calls (Class.method syntax)
• Static imports

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

Populate imports into scope

Processes import statements and stores them for later resolution. Java imports can be:

• Single-type: import com.example.MyClass;
• On-demand (wildcard): import com.example.*;
• Static single: import static com.example.MyClass.method;
• Static on-demand: import static com.example.MyClass.*;

fn register_import_binding(&mut self, binding: ImportBinding)

Register import binding TODO: Implement

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