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

322 lines
13 KiB
Rust
Raw Normal View History

2021-10-19 13:48:00 -07:00
use std::rc::Rc;
use crate::ast::*;
2021-10-24 17:57:56 -07:00
use crate::symbol_table::{Fqsn, Scope, SymbolTable, SymbolSpec};
2021-10-19 13:48:00 -07:00
use crate::util::ScopeStack;
2021-10-24 00:08:26 -07:00
#[derive(Debug)]
enum NameType {
//TODO eventually this needs to support closures
Param(u8), //TODO handle implications of functions being limited to 255 params
LocalVariable(ItemId),
Import(Fqsn),
2021-10-24 00:08:26 -07:00
}
#[derive(Debug)]
enum ScopeType {
Function {
name: Rc<String>
},
2021-10-24 19:05:41 -07:00
Lambda,
2021-10-26 11:37:43 -07:00
PatternMatch,
2021-10-24 00:08:26 -07:00
//TODO add some notion of a let-like scope?
}
pub struct ScopeResolver<'a> {
2021-10-21 14:46:42 -07:00
symbol_table: &'a mut super::SymbolTable,
2021-10-26 11:37:43 -07:00
//TODO maybe this shouldn't be a scope stack, b/c the recursion behavior comes from multiple
//instances of ScopeResolver
lexical_scopes: ScopeStack<'a, Rc<String>, NameType, ScopeType>,
2021-10-19 13:48:00 -07:00
}
impl<'a> ScopeResolver<'a> {
2021-10-21 14:46:42 -07:00
pub fn new(symbol_table: &'a mut SymbolTable) -> Self {
2021-10-24 00:08:26 -07:00
let lexical_scopes = ScopeStack::new(None);
2021-10-21 14:46:42 -07:00
Self {
symbol_table,
2021-10-24 00:08:26 -07:00
lexical_scopes,
2021-10-19 13:48:00 -07:00
}
2021-10-21 14:46:42 -07:00
}
2021-10-24 00:08:26 -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
}
}
*/
2021-10-19 13:48:00 -07:00
2021-10-24 00:08:26 -07:00
/// This method correctly modifies the id_to_symbol table (ItemId) to have the appropriate
/// mappings.
fn lookup_name_in_scope(&mut self, name: &QualifiedName) {
let QualifiedName { id, components } = name;
2021-10-26 13:02:40 -07:00
//TODO handle a "partial" qualified name, and also handle it down in the pattern-matching
//section
//TODO some of these if lets that look into the fqsn_to_symbol table should probaby fail
//with an error
if components.len() == 1 {
let local_name: Rc<String> = components[0].clone();
let name_type = self.lexical_scopes.lookup(&local_name);
match name_type {
Some(NameType::Import(fqsn)) => {
let symbol = self.symbol_table.fqsn_to_symbol.get(&fqsn);
if let Some(symbol) = symbol {
self.symbol_table.id_to_symbol.insert(id.clone(), symbol.clone());
}
},
Some(NameType::Param(n)) => {
let spec = SymbolSpec::FunctionParam(*n);
//TODO need to come up with a better solution for local variable FQSNs
let lscope = Scope::Name(Rc::new("<local-param>".to_string()));
let fqsn = Fqsn { scopes: vec![lscope, Scope::Name(local_name.clone())] };
self.symbol_table.add_symbol(id, fqsn, spec);
}
Some(NameType::LocalVariable(item_id)) => {
let symbol = self.symbol_table.id_to_symbol.get(&item_id).cloned();
if let Some(symbol) = symbol {
self.symbol_table.id_to_symbol.insert(id.clone(), symbol);
}
},
2021-10-24 02:54:21 -07:00
None => {
//TODO see if I can reduce this duplicate code
let fqsn = Fqsn { scopes: vec![Scope::Name(local_name.clone())] };
let symbol = self.symbol_table.fqsn_to_symbol.get(&fqsn);
if let Some(symbol) = symbol {
self.symbol_table.id_to_symbol.insert(id.clone(), symbol.clone());
}
}
}
} else {
let fqsn = Fqsn { scopes: components.iter().map(|name| Scope::Name(name.clone())).collect() };
let symbol = self.symbol_table.fqsn_to_symbol.get(&fqsn);
if let Some(symbol) = symbol {
self.symbol_table.id_to_symbol.insert(id.clone(), symbol.clone());
}
2021-10-21 14:46:42 -07:00
}
2021-10-19 13:48:00 -07:00
}
}
impl<'a> ASTVisitor for ScopeResolver<'a> {
2021-10-24 00:08:26 -07:00
// Import statements bring in a bunch of local names that all map to a specific FQSN.
// FQSNs map to a Symbol (or this is an error), Symbols have a DefId. So for every
// name we import, we map a local name (a string) to a NameType::ImportedDefinition(DefId).
fn import(&mut self, import_spec: &ImportSpecifier) -> Recursion {
2021-10-21 14:46:42 -07:00
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 fqsn in members.into_iter() {
self.lexical_scopes.insert( fqsn.local_name(), NameType::Import(fqsn));
2021-10-21 14:46:42 -07:00
}
}
ImportedNames::LastOfPath => {
let fqsn = Fqsn {
scopes: path_components
2021-10-21 14:46:42 -07:00
.iter()
.map(|c| Scope::Name(c.clone()))
.collect()
};
self.lexical_scopes.insert(fqsn.local_name(), NameType::Import(fqsn));
2021-10-21 14:46:42 -07:00
}
ImportedNames::List(ref names) => {
let fqsn_prefix: Vec<Scope> = path_components
2021-10-21 14:46:42 -07:00
.iter()
.map(|c| Scope::Name(c.clone()))
.collect();
for name in names.iter() {
let mut scopes = fqsn_prefix.clone();
scopes.push(Scope::Name(name.clone()));
let fqsn = Fqsn { scopes };
self.lexical_scopes.insert(fqsn.local_name(), NameType::Import(fqsn));
2021-10-21 14:46:42 -07:00
}
}
2021-10-19 13:48:00 -07:00
};
2021-10-24 00:08:26 -07:00
Recursion::Continue
}
fn declaration(&mut self, declaration: &Declaration, id: &ItemId) -> Recursion {
let cur_function_name = match self.lexical_scopes.get_name() {
//TODO this needs to be a fqsn
Some(ScopeType::Function { name }) => Some(name.clone()),
_ => None
};
match declaration {
Declaration::FuncDecl(signature, block) => {
let param_names = signature.params.iter().map(|param| param.name.clone());
//TODO I'm 90% sure this is right, until I get to closures
//let mut new_scope = self.lexical_scopes.new_scope(Some(ScopeType::Function { name: signature.name.clone() }));
let mut new_scope = ScopeStack::new(Some(ScopeType::Function { name: signature.name.clone() }));
for (n, param) in param_names.enumerate().into_iter() {
new_scope.insert(param, NameType::Param(n as u8));
}
2021-10-24 00:08:26 -07:00
let mut new_resolver = ScopeResolver {
symbol_table: self.symbol_table,
lexical_scopes: new_scope,
};
walk_block(&mut new_resolver, block);
Recursion::Stop
2021-10-24 00:08:26 -07:00
}
Declaration::Binding { name, .. } => {
if let Some(fn_name) = cur_function_name {
// We are within a function scope
let fqsn = Fqsn { scopes: vec![Scope::Name(fn_name.clone()), Scope::Name(name.clone())] };
self.symbol_table.add_symbol(id, fqsn, SymbolSpec::LocalVariable);
self.lexical_scopes.insert(name.clone(), NameType::LocalVariable(id.clone()));
}
Recursion::Continue
}
_ => Recursion::Continue
2021-10-24 00:08:26 -07:00
}
2021-10-21 14:46:42 -07:00
}
2021-10-19 13:48:00 -07:00
2021-10-24 00:08:26 -07:00
fn expression(&mut self, expression: &Expression) -> Recursion {
use ExpressionKind::*;
match &expression.kind {
Value(name) => {
self.lookup_name_in_scope(name);
},
NamedStruct { name, fields: _ } => {
self.lookup_name_in_scope(name);
},
2021-10-24 19:05:41 -07:00
Lambda { params, body, .. } => {
let param_names = params.iter().map(|param| param.name.clone());
//TODO need to properly handle closure scope, this is currently broken
//let mut new_scope = self.lexical_scopes.new_scope(Some(ScopeType::Function { name: signature.name.clone() }));
let mut new_scope = ScopeStack::new(Some(ScopeType::Lambda));
for (n, param) in param_names.enumerate().into_iter() {
new_scope.insert(param, NameType::Param(n as u8));
}
let mut new_resolver = ScopeResolver {
symbol_table: self.symbol_table,
lexical_scopes: new_scope,
};
walk_block(&mut new_resolver, body);
return Recursion::Stop;
}
2021-10-26 11:37:43 -07:00
IfExpression { discriminator, body } => {
if let Some(d) = discriminator.as_ref() {
walk_expression(self, &d);
}
let mut resolver = ScopeResolver {
lexical_scopes: self.lexical_scopes.new_scope(Some(ScopeType::PatternMatch)),
symbol_table: self.symbol_table
};
let new_resolver = &mut resolver;
match body.as_ref() {
IfExpressionBody::SimpleConditional {
then_case,
else_case,
} => {
walk_block(new_resolver, then_case);
if let Some(block) = else_case.as_ref() {
walk_block(new_resolver, block)
}
}
IfExpressionBody::SimplePatternMatch {
pattern,
then_case,
else_case,
} => {
walk_pattern(new_resolver, pattern);
walk_block(new_resolver, &then_case);
if let Some(ref block) = else_case.as_ref() {
walk_block(new_resolver, &block)
}
}
IfExpressionBody::CondList(arms) => {
for arm in arms {
match arm.condition {
Condition::Pattern(ref pat) => {
walk_pattern(new_resolver, pat);
}
Condition::TruncatedOp(ref _binop, ref expr) => {
walk_expression(new_resolver, expr);
}
Condition::Expression(ref expr) => {
walk_expression(new_resolver, expr);
}
Condition::Else => (),
}
if let Some(ref guard) = arm.guard {
walk_expression(new_resolver, &guard);
}
walk_block(new_resolver, &arm.body);
}
}
};
return Recursion::Stop;
},
_ => (),
2021-10-21 21:55:21 -07:00
}
2021-10-24 00:08:26 -07:00
Recursion::Continue
2021-10-21 14:46:42 -07:00
}
2021-10-19 13:48:00 -07:00
2021-10-24 00:08:26 -07:00
fn pattern(&mut self, pat: &Pattern) -> Recursion {
2021-10-21 14:46:42 -07:00
use Pattern::*;
2021-10-21 14:46:42 -07:00
match pat {
2021-10-26 11:37:43 -07:00
Literal(..) | Ignored | TuplePattern(..) => (),
TupleStruct(name, _) | Record(name, _) => {
self.lookup_name_in_scope(name);
2021-10-21 14:46:42 -07:00
}
2021-10-26 11:37:43 -07:00
//TODO this isn't really the right syntax for a VarOrName
VarOrName(ref name @ QualifiedName { id, components }) => {
2021-10-26 13:02:40 -07:00
if components.len() == 1 {
//TODO need a better way to construct a FQSN from a QualifiedName
let local_name: Rc<String> = components[0].clone();
let lscope = Scope::Name(Rc::new("<local-case-match>".to_string()));
let fqsn = Fqsn { scopes: vec![lscope, Scope::Name(local_name.clone())] };
//let local_name = fqsn.local_name();
self.symbol_table.add_symbol(id, fqsn, SymbolSpec::LocalVariable);
self.lexical_scopes.insert(local_name.clone(), NameType::LocalVariable(id.clone()));
} else {
let fqsn = Fqsn { scopes: components.iter().map(|name| Scope::Name(name.clone())).collect() };
let symbol = self.symbol_table.fqsn_to_symbol.get(&fqsn);
if let Some(symbol) = symbol {
self.symbol_table.id_to_symbol.insert(id.clone(), symbol.clone());
}
}
2021-10-26 11:37:43 -07:00
},
2021-10-21 14:46:42 -07:00
};
2021-10-24 00:08:26 -07:00
Recursion::Continue
2021-10-21 14:46:42 -07:00
}
2021-10-19 13:48:00 -07:00
}