schala/schala-lang/language/src/symbol_table/resolver.rs

128 lines
4.2 KiB
Rust
Raw Normal View History

2021-10-19 13:48:00 -07:00
use std::rc::Rc;
use crate::ast::*;
2021-10-21 14:46:42 -07:00
use crate::symbol_table::{Fqsn, Scope, SymbolTable};
2021-10-19 13:48:00 -07:00
use crate::util::ScopeStack;
2021-10-19 21:14:15 -07:00
type FqsnPrefix = Vec<Scope>;
2021-10-19 13:48:00 -07:00
pub struct Resolver<'a> {
2021-10-21 14:46:42 -07:00
symbol_table: &'a mut super::SymbolTable,
name_scope_stack: ScopeStack<'a, Rc<String>, FqsnPrefix>,
2021-10-19 13:48:00 -07:00
}
impl<'a> Resolver<'a> {
2021-10-21 14:46:42 -07:00
pub fn new(symbol_table: &'a mut SymbolTable) -> Self {
let name_scope_stack: ScopeStack<'a, Rc<String>, FqsnPrefix> = ScopeStack::new(None);
Self {
symbol_table,
name_scope_stack,
2021-10-19 13:48:00 -07:00
}
2021-10-21 14:46:42 -07:00
}
pub fn resolve(&mut self, ast: &AST) {
walk_ast(self, ast);
}
2021-10-19 13:48:00 -07:00
2021-10-21 14:46:42 -07:00
fn lookup_name_in_scope(&self, sym_name: &QualifiedName) -> Fqsn {
let QualifiedName { components, .. } = sym_name;
let first_component = &components[0];
match self.name_scope_stack.lookup(first_component) {
None => Fqsn {
scopes: components
.iter()
.map(|name| Scope::Name(name.clone()))
.collect(),
},
Some(fqsn_prefix) => {
let mut full_name = fqsn_prefix.clone();
let rest_of_name: FqsnPrefix = components[1..]
.iter()
.map(|name| Scope::Name(name.clone()))
.collect();
full_name.extend_from_slice(&rest_of_name);
Fqsn { scopes: full_name }
}
2021-10-19 13:48:00 -07:00
}
}
fn qualified_name(&mut self, name: &QualifiedName) {
let fqsn = self.lookup_name_in_scope(name);
let symbol = self.symbol_table.fqsn_to_symbol.get(&fqsn);
if let Some(symbol) = symbol {
self.symbol_table.id_to_symbol.insert(name.id.clone(), symbol.clone());
2021-10-21 14:46:42 -07:00
}
2021-10-19 13:48:00 -07:00
}
}
impl<'a> ASTVisitor for Resolver<'a> {
2021-10-21 14:46:42 -07:00
//TODO need to un-insert these - maybe need to rethink visitor
fn import(&mut self, import_spec: &ImportSpecifier) {
let ImportSpecifier {
ref path_components,
ref imported_names,
..
} = &import_spec;
match imported_names {
ImportedNames::All => {
let prefix = Fqsn {
scopes: path_components
.iter()
.map(|c| Scope::Name(c.clone()))
.collect(),
};
let members = self.symbol_table.symbol_trie.get_children(&prefix);
for member in members.into_iter() {
let Scope::Name(n) = member.scopes.last().unwrap();
let local_name = n.clone();
self.name_scope_stack.insert(local_name, member.scopes);
}
}
ImportedNames::LastOfPath => {
let name = path_components.last().unwrap(); //TODO handle better
let fqsn_prefix = path_components
.iter()
.map(|c| Scope::Name(c.clone()))
.collect();
self.name_scope_stack.insert(name.clone(), fqsn_prefix);
}
ImportedNames::List(ref names) => {
let fqsn_prefix: FqsnPrefix = path_components
.iter()
.map(|c| Scope::Name(c.clone()))
.collect();
for name in names.iter() {
self.name_scope_stack
.insert(name.clone(), fqsn_prefix.clone());
}
}
2021-10-19 13:48:00 -07:00
};
2021-10-21 14:46:42 -07:00
}
2021-10-19 13:48:00 -07:00
fn expression(&mut self, expression: &Expression) {
use ExpressionKind::*;
match &expression.kind {
Value(name) => {
self.qualified_name(name);
},
NamedStruct { name, fields: _ } => {
self.qualified_name(name);
},
_ => (),
2021-10-21 21:55:21 -07:00
}
2021-10-21 14:46:42 -07:00
}
2021-10-19 13:48:00 -07:00
2021-10-21 14:46:42 -07:00
fn pattern(&mut self, pat: &Pattern) {
use Pattern::*;
2021-10-21 14:46:42 -07:00
match pat {
//TODO I think not handling TuplePattern is an oversight
TuplePattern(_) => (),
Literal(_) | Ignored => (),
TupleStruct(name, _) | Record(name, _) | VarOrName(name) => {
self.qualified_name(name);
2021-10-21 14:46:42 -07:00
}
};
}
2021-10-19 13:48:00 -07:00
}