Resolve class scopes in their own symbol table

typechecker/src/build_source.rs

@@ -29,7 +29,7 @@ impl BuildSource {
 }
 
 pub fn get_module_name(path: &Path) -> String {
-    path.to_str().unwrap_or_default().replace(['/', '\\'], ".")
+    path.to_str().unwrap().replace(['/', '\\'], ".")
 }
 
 // impl Into<EnderpyFile> for BuildSource {

typechecker/src/semantic_analyzer.rs

@@ -608,7 +608,8 @@ impl TraversalVisitor for SemanticAnalyzer {
 
         self.symbol_table.exit_scope();
 
-        let class_declaration = Declaration::Class(Class::new(c.clone(), methods));
+        let class_declaration =
+            Declaration::Class(Class::new(c.clone(), methods, self.file.path()));
         let flags = SymbolFlags::empty();
         self.create_symbol(c.name.clone(), class_declaration, flags);
     }

typechecker/src/symbol_table.rs

@@ -203,11 +203,11 @@ pub struct Class {
 }
 
 impl Class {
-    pub fn new(class_node: ast::ClassDef, methods: Vec<String>) -> Self {
+    pub fn new(class_node: ast::ClassDef, methods: Vec<String>, file_path: PathBuf) -> Self {
         Class {
             name: class_node.name.clone(),
             declaration_path: DeclarationPath {
-                module_name: PathBuf::new(),
+                module_name: file_path,
                 node: Node {
                     start: class_node.node.start,
                     end: class_node.node.end,

typechecker/src/type_check/type_evaluator.rs

@@ -2,7 +2,7 @@
 #![allow(unused_variables)]
 
 use core::panic;
-use std::{path::Path};
+use std::path::Path;
 
 use enderpy_python_parser as parser;
 use enderpy_python_parser::ast;
@@ -239,15 +239,10 @@ impl TypeEvaluator {
                         return Ok(PythonType::Unknown);
                     }
                 };
-                log::debug!("checking type for expression: {:#?}", a);
                 log::debug!("looking up attribute in type: {:?}", value_type);
                 match value_type {
                     PythonType::Class(c) => {
-                        let class_scope = self
-                            .symbol_table
-                            .get_scope(&c.details.declaration_path.node)
-                            .expect("cannot find class scope for attribute access");
-
+                        let class_scope = self.get_scope_of(&c);
                         log::debug!("class scope for the attribute: {:#?}", class_scope);
                         let symbol_table_node =
                             self.symbol_table.lookup_attribute(&a.attr, class_scope);
@@ -878,6 +873,26 @@ impl TypeEvaluator {
             .find(|symbol_table| symbol_table.file_path == path);
         symbol_table
     }
+
+    fn get_scope_of(&self, c: &ClassType) -> &symbol_table::SymbolTableScope {
+        let symbol_table = self
+            .imported_symbol_tables
+            .iter()
+            .find(|symbol_table| {
+                symbol_table
+                    .file_path
+                    .ends_with(&c.details.declaration_path.module_name)
+            })
+            .unwrap_or_else(|| {
+                panic!(
+                    "Declaration path not found: {:?}",
+                    c.details.declaration_path,
+                )
+            });
+        symbol_table
+            .get_scope(&c.details.declaration_path.node)
+            .unwrap_or_else(|| panic!("Scope not found for: {:?}", c.details.declaration_path))
+    }
 }
 
 impl TraversalVisitorImmutGeneric<PythonType> for TypeEvaluator {

typechecker/test_data/inputs/base.py

@@ -38,3 +38,5 @@ def	get_x(self) -> float:
 d = {"a": 1, "b": 2}
 s = {1,2,3}
 
+l.append(4)
+

typechecker/test_data/output/enderpy_python_type_checker__build__tests__symbol_table@class_definition.py.snap

@@ -269,7 +269,7 @@ SymbolFlags(
 --:   Class {
     name: "c",
     declaration_path: DeclarationPath {
-        module_name: "",
+        module_name: "[TYPECHECKER]/test_data/inputs/symbol_table/class_definition.py",
         node: Node {
             start: 0,
             end: 80,