Bunch of rewrites to scope resolver

schala-lang/language/src/ast/mod.rs

@@ -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;

schala-lang/language/src/ast/visitor.rs

@@ -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(&mut self, _expression: &Expression) -> Recursion { Recursion::Continue }
-    fn expression_post(&mut self, _expression: &Expression) {}
+    fn declaration(&mut self, _declaration: &Declaration) -> Recursion { Recursion::Continue }
 
-    fn declaration(&mut self, _declaration: &Declaration) {}
+    fn import(&mut self, _import: &ImportSpecifier) -> Recursion { Recursion::Continue }
-    fn declaration_post(&mut self, _declaration: &Declaration) {}
+    fn module(&mut self, _module: &ModuleSpecifier) -> Recursion { Recursion::Continue }
 
-    fn import(&mut self, _import: &ImportSpecifier) {}
+    fn pattern(&mut self, _pat: &Pattern) -> Recursion { Recursion::Continue }
-    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) {}
 }
 
 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);
 }

schala-lang/language/src/reduced_ast/mod.rs

@@ -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
         }
     }
 

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

@@ -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(

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

@@ -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
+    // Import statements bring in a bunch of local names that all map to a specific FQSN.
-    fn import(&mut self, import_spec: &ImportSpecifier) {
+    // 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
     }
 }