greg/schala
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Bunch of rewrites to scope resolver

Browse Source
This commit is contained in:
Greg Shuflin 2021-10-24 00:08:26 -07:00
parent d8f6c41f04
commit ba09919aa1
5 changed files with 198 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
schala-lang/language/src/ast/mod.rs
View File

@ -8,7 +8,7 @@ mod visitor;
mod operators;
pub use operators::{PrefixOp, BinOp};
pub use visitor::{walk_ast, walk_block, ASTVisitor};
pub use visitor::{walk_ast, walk_block, ASTVisitor, Recursion};
use crate::derivative::Derivative;
use crate::tokenizing::Location;

45
schala-lang/language/src/ast/visitor.rs
View File

@ -1,18 +1,19 @@
use crate::ast::*;
#[derive(Debug)]
pub enum Recursion {
Continue,
Stop
}
pub trait ASTVisitor: Sized {
fn expression(&mut self, _expression: &Expression) {}
fn expression_post(&mut self, _expression: &Expression) {}
fn expression(&mut self, _expression: &Expression) -> Recursion { Recursion::Continue }
fn declaration(&mut self, _declaration: &Declaration) -> Recursion { Recursion::Continue }
fn declaration(&mut self, _declaration: &Declaration) {}
fn declaration_post(&mut self, _declaration: &Declaration) {}
fn import(&mut self, _import: &ImportSpecifier) -> Recursion { Recursion::Continue }
fn module(&mut self, _module: &ModuleSpecifier) -> Recursion { Recursion::Continue }
fn import(&mut self, _import: &ImportSpecifier) {}
fn module(&mut self, _module: &ModuleSpecifier) {}
fn module_post(&mut self, _module: &ModuleSpecifier) {}
fn pattern(&mut self, _pat: &Pattern) {}
fn pattern_post(&mut self, _pat: &Pattern) {}
fn pattern(&mut self, _pat: &Pattern) -> Recursion { Recursion::Continue }
}
pub fn walk_ast<V: ASTVisitor>(v: &mut V, ast: &AST) {
@ -29,11 +30,13 @@ pub fn walk_block<V: ASTVisitor>(v: &mut V, block: &Block) {
Declaration(ref decl) => {
walk_declaration(v, decl);
}
Import(ref import_spec) => v.import(import_spec),
Import(ref import_spec) => {
v.import(import_spec);
},
Module(ref module_spec) => {
v.module(module_spec);
if let Recursion::Continue = v.module(module_spec) {
walk_block(v, &module_spec.contents);
v.module_post(module_spec);
}
}
}
}
@ -42,8 +45,7 @@ pub fn walk_block<V: ASTVisitor>(v: &mut V, block: &Block) {
fn walk_declaration<V: ASTVisitor>(v: &mut V, decl: &Declaration) {
use Declaration::*;
v.declaration(decl);
if let Recursion::Continue = v.declaration(decl) {
match decl {
FuncDecl(_sig, block) => {
walk_block(v, block);
@ -58,14 +60,13 @@ fn walk_declaration<V: ASTVisitor>(v: &mut V, decl: &Declaration) {
}
_ => (),
};
v.declaration_post(decl);
}
}
fn walk_expression<V: ASTVisitor>(v: &mut V, expr: &Expression) {
use ExpressionKind::*;
v.expression(expr);
if let Recursion::Continue = v.expression(expr) {
match &expr.kind {
NatLiteral(_) | FloatLiteral(_) | StringLiteral(_) | BoolLiteral(_) | Value(_) => (),
BinExp(_, lhs, rhs) => {
@ -138,7 +139,7 @@ fn walk_expression<V: ASTVisitor>(v: &mut V, expr: &Expression) {
}
}
};
v.expression_post(expr);
}
}
fn walk_if_expr_body<V: ASTVisitor>(v: &mut V, body: &IfExpressionBody) {
@ -187,8 +188,7 @@ fn walk_if_expr_body<V: ASTVisitor>(v: &mut V, body: &IfExpressionBody) {
fn walk_pattern<V: ASTVisitor>(v: &mut V, pat: &Pattern) {
use Pattern::*;
v.pattern(pat);
if let Recursion::Continue = v.pattern(pat) {
match pat {
TuplePattern(patterns) => {
for pat in patterns {
@ -207,6 +207,5 @@ fn walk_pattern<V: ASTVisitor>(v: &mut V, pat: &Pattern) {
}
_ => (),
};
v.pattern_post(pat);
}
}

2
schala-lang/language/src/reduced_ast/mod.rs
View File

@ -125,7 +125,7 @@ impl<'a> Reducer<'a> {
arity: *arity,
},
SymbolSpec::Func(_) => Expr::Sym(local_name.clone()),
SymbolSpec::Binding => Expr::Sym(local_name.clone()), //TODO not sure if this is right, probably needs to eventually be fqsn
SymbolSpec::GlobalBinding => Expr::Sym(local_name.clone()), //TODO not sure if this is right, probably needs to eventually be fqsn
}
}

18
schala-lang/language/src/symbol_table/mod.rs
View File

@ -189,6 +189,7 @@ impl SymbolTable {
self.id_to_symbol.get(id).map(|s| s.as_ref())
}
//TODO optimize this
pub fn lookup_symbol_by_def(&self, def: &DefId) -> Option<&Symbol> {
self.id_to_symbol.iter().find(|(_, sym)| sym.def_id == *def)
.map(|(_, sym)| sym.as_ref())
@ -223,7 +224,7 @@ pub enum SymbolSpec {
members: HashMap<Rc<String>, TypeName>,
type_name: TypeName,
},
Binding,
GlobalBinding, //Only for global variables, not for function-local ones or ones within a `let` scope context
}
impl fmt::Display for SymbolSpec {
@ -283,13 +284,14 @@ impl SymbolTable {
/// up name tables that will be used by further parts of the compiler
fn populate_name_tables(&mut self, ast: &ast::AST) -> Vec<SymbolError> {
let mut scope_stack = vec![];
self.add_from_scope(ast.statements.as_ref(), &mut scope_stack)
self.add_from_scope(ast.statements.as_ref(), &mut scope_stack, false)
}
fn add_from_scope<'a>(
&'a mut self,
statements: &[Statement],
scope_stack: &mut Vec<Scope>,
function_scope: bool,
) -> Vec<SymbolError> {
let mut errors = vec![];
@ -300,7 +302,7 @@ impl SymbolTable {
location,
} = statement; //TODO I'm not sure if I need to do anything with this ID
let location = *location;
if let Err(err) = self.add_single_statement(id, kind, location, scope_stack) {
if let Err(err) = self.add_single_statement(id, kind, location, scope_stack, function_scope) {
errors.push(err);
} else {
// If there's an error with a name, don't recurse into subscopes of that name
@ -308,14 +310,14 @@ impl SymbolTable {
StatementKind::Declaration(Declaration::FuncDecl(signature, body)) => {
let new_scope = Scope::Name(signature.name.clone());
scope_stack.push(new_scope);
let output = self.add_from_scope(body.as_ref(), scope_stack);
let output = self.add_from_scope(body.as_ref(), scope_stack, true);
scope_stack.pop();
output
}
StatementKind::Module(ModuleSpecifier { name, contents }) => {
let new_scope = Scope::Name(name.clone());
scope_stack.push(new_scope);
let output = self.add_from_scope(contents.as_ref(), scope_stack);
let output = self.add_from_scope(contents.as_ref(), scope_stack, false);
scope_stack.pop();
output
}
@ -339,6 +341,7 @@ impl SymbolTable {
kind: &StatementKind,
location: Location,
scope_stack: &[Scope],
function_scope: bool,
) -> Result<(), SymbolError> {
match kind {
StatementKind::Declaration(Declaration::FuncSig(signature)) => {
@ -407,13 +410,14 @@ impl SymbolTable {
kind: NameKind::Binding,
},
)?;
println!("Adding Binding symbol: {:?}", fq_binding);
if !function_scope {
self.add_symbol(
id,
fq_binding,
SymbolSpec::Binding,
SymbolSpec::GlobalBinding,
);
}
}
StatementKind::Module(ModuleSpecifier { name, .. }) => {
let fq_module = Fqsn::from_scope_stack(scope_stack, name.clone());
self.fq_names.register(

70
schala-lang/language/src/symbol_table/resolver.rs
View File

@ -1,24 +1,45 @@
use std::rc::Rc;
use crate::ast::*;
use crate::symbol_table::{Fqsn, Scope, SymbolTable};
use crate::symbol_table::{Fqsn, Scope, SymbolTable, DefId};
use crate::util::ScopeStack;
type FqsnPrefix = Vec<Scope>;
#[derive(Debug)]
enum NameType {
//TODO eventually this needs to support closures
Param(u8), //TODO functions limited to 255 params
LocalVariable,
ImportedDefinition(DefId),
}
#[derive(Debug)]
enum ScopeType {
Function {
name: Rc<String>
},
//TODO add some notion of a let-like scope?
}
pub struct ScopeResolver<'a> {
symbol_table: &'a mut super::SymbolTable,
/// Used for import resolution. TODO maybe this can also use the lexical scope table.
name_scope_stack: ScopeStack<'a, Rc<String>, FqsnPrefix>,
lexical_scopes: ScopeStack<'a, Rc<String>, NameType, ScopeType>
}
impl<'a> ScopeResolver<'a> {
pub fn new(symbol_table: &'a mut SymbolTable) -> Self {
let name_scope_stack: ScopeStack<'a, Rc<String>, FqsnPrefix> = ScopeStack::new(None);
let name_scope_stack = ScopeStack::new(None);
let lexical_scopes = ScopeStack::new(None);
Self {
symbol_table,
name_scope_stack,
lexical_scopes,
}
}
pub fn resolve(&mut self, ast: &AST) {
walk_ast(self, ast);
}
@ -46,10 +67,11 @@ impl<'a> ScopeResolver<'a> {
}
}
fn qualified_name(&mut self, name: &QualifiedName) {
/// This method correctly modifies the id_to_symbol table (ItemId) to have the appropriate
/// mappings.
fn handle_qualified_name(&mut self, name: &QualifiedName) {
println!("Handling qualified_name in resolver.rs: {:?}", name);
let fqsn = self.lookup_name_in_scope(name);
println!("Computed FQSN: {:?}", fqsn);
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());
@ -58,8 +80,10 @@ impl<'a> ScopeResolver<'a> {
}
impl<'a> ASTVisitor for ScopeResolver<'a> {
//TODO need to un-insert these - maybe need to rethink visitor
fn import(&mut self, import_spec: &ImportSpecifier) {
// 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 {
let ImportSpecifier {
ref path_components,
ref imported_names,
@ -99,22 +123,45 @@ impl<'a> ASTVisitor for ScopeResolver<'a> {
}
}
};
Recursion::Continue
}
fn expression(&mut self, expression: &Expression) {
fn declaration(&mut self, declaration: &Declaration) -> Recursion {
if let Declaration::FuncDecl(signature, block) = declaration {
let param_names = signature.params.iter().map(|param| param.name.clone());
let mut new_scope = self.lexical_scopes.new_scope(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));
}
let mut new_resolver = ScopeResolver {
symbol_table: self.symbol_table,
name_scope_stack: self.name_scope_stack.new_scope(None),
lexical_scopes: new_scope,
};
walk_block(&mut new_resolver, block);
Recursion::Stop
} else {
Recursion::Continue
}
}
fn expression(&mut self, expression: &Expression) -> Recursion {
use ExpressionKind::*;
match &expression.kind {
Value(name) => {
self.qualified_name(name);
self.handle_qualified_name(name);
},
NamedStruct { name, fields: _ } => {
self.qualified_name(name);
self.handle_qualified_name(name);
},
_ => (),
}
Recursion::Continue
}
fn pattern(&mut self, pat: &Pattern) {
fn pattern(&mut self, pat: &Pattern) -> Recursion {
use Pattern::*;
match pat {
@ -122,8 +169,9 @@ impl<'a> ASTVisitor for ScopeResolver<'a> {
TuplePattern(_) => (),
Literal(_) | Ignored => (),
TupleStruct(name, _) | Record(name, _) | VarOrName(name) => {
self.qualified_name(name);
self.handle_qualified_name(name);
}
};
Recursion::Continue
}
}