Support namespaces when resolving symbols

A definition can resolve a reference in the same or a deeper namespace,
allowing for proper scoping and shadowing. Multiple definitions in the
same namespace cannot share a name.

1 files changed, 4 insertions, 4 deletions

diff --git a/src/resolver.rs b/src/resolver.rs
index 23dc73a..37d0911 100644
--- a/src/resolver.rs
+++ b/src/resolver.rs
@@ -71,15 +71,15 @@ impl Resolver {
             match symbol.role {
                 SymbolRole::Definition(_) => {
                     // Check if the symbol has already been defined.
-                    let equal = |d: &TrackedSymbol| { &d.symbol.name == &symbol.name };
+                    let equal = |d: &TrackedSymbol| { &d.symbol == &symbol };
                     if let Some(original) = self.definitions.iter().position(equal) {
                         let definition = TrackedSymbol { symbol, source_id, source_role };
                         let redefinition = (definition, original);
                         self.redefinitions.push(redefinition);
                     } else {
                         // Resolve all unresolved references that match this symbol.
-                        let equal = |s: &mut TrackedSymbol| s.symbol.name == symbol.name;
-                        for symbol in self.unresolved.extract_if(equal) {
+                        let defines = |r: &mut TrackedSymbol| symbol.defines(&r.symbol);
+                        for symbol in self.unresolved.extract_if(defines) {
                             self.resolved.push(symbol);
                         }
                         let definition = TrackedSymbol { symbol, source_id, source_role };
@@ -88,7 +88,7 @@ impl Resolver {
                 }
                 SymbolRole::Reference => {
                     let reference = TrackedSymbol { symbol, source_id, source_role };
-                    match self.definitions.contains(&reference) {
+                    match self.definitions.iter().any(|d| d.symbol.defines(&reference.symbol)) {
                         true => self.resolved.push(reference),
                         false => self.unresolved.push(reference),
                     }