[REF] symbol path handling with SymbolPath enum

This commit replaces the Vec<String> return type in Symbol::paths() (now
renamed to path) with a new SymbolPath enum that explicitly represents
three cases: Single path, Multiple paths, or None.

The purpose of this change is to force the caller handle the different
cases explicitly, rather than doing [0] on the vector previously
returned by paths().

This commit also renames get_symbol_first_path() to get_file_path() for
clarity, as it only applies to file types (File, Package, XMLFile and
CSVFile) and specifically returns the actual file path including
__init__.py for packages.

Author: cammarosano

server/src/core/csv_arch_builder.rs

@@ -21,7 +21,7 @@ impl CsvArchBuilder {
     pub fn load_csv(&mut self, session: &mut SessionInfo, csv_symbol: Rc<RefCell<Symbol>>, content: &String) -> Vec<Diagnostic> {
         let diagnostics = vec![];
         csv_symbol.borrow_mut().set_build_status(BuildSteps::ARCH, BuildStatus::IN_PROGRESS);
-        let model_name_pb = PathBuf::from(&csv_symbol.borrow().paths()[0]);
+        let model_name_pb = PathBuf::from(&csv_symbol.borrow().path().as_single());
         let model_name = Sy!(model_name_pb.file_stem().unwrap().to_str().unwrap().to_string());
         let csv_module = csv_symbol.borrow().find_module();
         let Some(csv_module) = &csv_module else {

server/src/core/entry_point.rs

@@ -203,7 +203,7 @@ impl EntryPointMgr {
                     } else {
                         // There was an __init__.py, that was renamed or deleted.
                         // Another notification will come for the deletion of the file, so we just warn here.
-                        warn_or_panic!("Trying to create a custom entrypoint on a namespace symbol: {:?}", new_sym.borrow().paths());
+                        warn_or_panic!("Trying to create a custom entrypoint on a namespace symbol: {:?}", new_sym.borrow().path().as_multiple());
                     }
                     return false;
                 }

server/src/core/import_resolver.rs

@@ -57,6 +57,9 @@ fn resolve_import_stmt_hook(alias: &Alias, from_symbol: &Option<Rc<RefCell<Symbo
  * Helper to manually import a symbol. Do not forget to use level instead of '.' in the from_stmt parameter.
  */
 pub fn manual_import(session: &mut SessionInfo, source_file_symbol: &Rc<RefCell<Symbol>>, from_stmt:Option<String>, name: &str, asname: Option<String>, level: u32, diagnostics: &mut Option<&mut Vec<Diagnostic>>) -> Vec<ImportResult> {
+    if source_file_symbol.borrow().path().as_vec().len() > 1 {
+        panic!("Importing from a multi-path namespace symbol is not supported in manual_import");
+    }
     let name_aliases = vec![Alias {
         name: Identifier { id: Name::new(name), range: TextRange::new(TextSize::new(0), TextSize::new(0)), node_index: AtomicNodeIndex::default() },
         asname: match asname {
@@ -82,7 +85,8 @@ pub fn resolve_from_stmt(session: &mut SessionInfo, source_file_symbol: &Rc<RefC
         level,
         from_stmt);
     drop(_source_file_symbol_lock);
-    let source_path = source_file_symbol.borrow().paths()[0].clone();
+    // source_file_symbol is either a file or a namespace with a single path
+    let source_path = source_file_symbol.borrow().path().as_vec()[0].clone();
     let mut start_symbol = None;
     if level != 0 {
         //if level is 0, resolve_packages already built a full tree, so we can start from root
@@ -139,7 +143,8 @@ pub fn resolve_import_stmt(session: &mut SessionInfo, source_file_symbol: &Rc<Re
         } else {
             vec![]
         };
-        let source_path = source_file_symbol.borrow().paths()[0].clone();
+        // source_file_symbol is either a file or a namespace with a single path
+        let source_path = source_file_symbol.borrow().path().as_vec()[0].clone();
         let name_last_name: Vec<OYarn> = vec![name_split.last().unwrap().clone()];
         let (mut next_symbol, mut fallback_sym) = _get_or_create_symbol(
             session,
@@ -223,7 +228,7 @@ pub fn resolve_import_stmt(session: &mut SessionInfo, source_file_symbol: &Rc<Re
 }
 
 pub fn find_module(session: &mut SessionInfo, odoo_addons: Rc<RefCell<Symbol>>, name: &OYarn) -> Option<Rc<RefCell<Symbol>>> {
-    let paths = (*odoo_addons).borrow().paths().clone();
+    let paths = (*odoo_addons).borrow().path().as_vec();
     for path in paths.iter() {
         let full_path = Path::new(path.as_str()).join(name.as_str());
         if !is_dir_cs(full_path.sanitize()) {
@@ -243,7 +248,7 @@ fn _resolve_packages(from_file: &Symbol, level: u32, from_stmt: Option<&Identifi
     let mut first_part_tree: Vec<OYarn> = vec![];
     if level > 0 {
         let mut lvl = level;
-        if lvl > Path::new(&from_file.paths()[0]).components().count() as u32 {
+        if lvl > Path::new(&from_file.path().as_single()).components().count() as u32 {
             panic!("Level is too high!")
         }
         if matches!(from_file.typ(), SymType::PACKAGE(_)) {
@@ -390,7 +395,7 @@ fn _resolve_new_symbol(session: &mut SessionInfo, parent: Rc<RefCell<Symbol>>, n
     if (*parent).borrow().typ() == SymType::COMPILED {
         return Ok((*parent).borrow_mut().add_new_compiled(session, &sym_name, &S!("")));
     }
-    let paths = (*parent).borrow().paths().clone();
+    let paths = (*parent).borrow().path().as_vec();
     for path in paths.iter() {
         let mut full_path = Path::new(path.as_str()).join(name.to_string());
         for stub in session.sync_odoo.stubs_dirs.iter() {
@@ -477,7 +482,7 @@ pub fn get_all_valid_names(session: &mut SessionInfo, source_file_symbol: &Rc<Re
     let source_root = source_file_symbol.borrow().get_root().as_ref().unwrap().upgrade().unwrap();
     let entry = source_root.borrow().get_entry().unwrap();
     let (mut from_symbol, _fallback_sym, file_tree) = resolve_from_stmt(session, source_file_symbol, identifier_from.as_ref(), level);
-    let source_path = source_file_symbol.borrow().paths()[0].clone();
+    let source_path = source_file_symbol.borrow().path().as_single();
     let mut result = HashMap::new();
     let mut symbols_to_browse = vec![];
     if from_symbol.is_none() {
@@ -548,15 +553,16 @@ fn valid_names_for_a_symbol(_session: &mut SessionInfo, symbol: &Rc<RefCell<Symb
             }
             res.extend(valid_name_from_symbol(symbol, start_filter));
         },
-        SymType::NAMESPACE | SymType::DISK_DIR => {
-            for path in symbol.borrow().paths().iter() {
+        SymType::NAMESPACE => {
+            for path in symbol.borrow().path().as_multiple().iter() {
                 res.extend(valid_name_from_disk(path, start_filter));
             }
         },
+        SymType::DISK_DIR => {
+            res.extend(valid_name_from_disk(&symbol.borrow().path().as_single(), start_filter));
+        }
         SymType::PACKAGE(_) => {
-            for path in symbol.borrow().paths().iter() {
-                res.extend(valid_name_from_disk(path, start_filter));
-            }
+            res.extend(valid_name_from_disk(&symbol.borrow().path().as_single(), start_filter));
             if only_on_disk {
                 return res;
             }

server/src/core/odoo.rs

@@ -1,6 +1,7 @@
 use crate::core::diagnostics::{create_diagnostic, DiagnosticCode};
 use crate::core::entry_point::EntryPointType;
 use crate::core::file_mgr::AstType;
+use crate::core::symbols::symbol::SymbolPath;
 use crate::core::xml_data::OdooData;
 use crate::core::xml_validation::XmlValidator;
 use crate::features::document_symbols::DocumentSymbolFeature;
@@ -468,8 +469,10 @@ impl SyncOdoo {
     fn build_modules(session: &mut SessionInfo) {
         {
             let addons_symbol = session.sync_odoo.get_symbol(session.sync_odoo.config.odoo_path.as_ref().unwrap(), &tree(vec!["odoo", "addons"], vec![]), u32::MAX)[0].clone();
-            let addons_path = addons_symbol.borrow().paths().clone();
-            for addon_path in addons_path.iter() {
+            let SymbolPath::Multiple(addons_paths) = addons_symbol.borrow().path() else {
+                panic!("Odoo addons symbol paths should be a namespace");
+            };
+            for addon_path in addons_paths.iter() {
                 info!("searching modules in {}", addon_path);
                 if PathBuf::from(addon_path).exists() {
                     //browse all dir in path
@@ -756,7 +759,7 @@ impl SyncOdoo {
 
     pub fn add_to_rebuild_arch(&mut self, symbol: Rc<RefCell<Symbol>>) {
         if DEBUG_THREADS {
-            trace!("ADDED TO ARCH - {}", symbol.borrow().paths().first().unwrap_or(&symbol.borrow().name().to_string()));
+            trace!("ADDED TO ARCH - {} - {:?}", symbol.borrow().name(), symbol.borrow().path());
         }
         if symbol.borrow().build_status(BuildSteps::ARCH) != BuildStatus::IN_PROGRESS {
             let sym_clone = symbol.clone();
@@ -770,7 +773,7 @@ impl SyncOdoo {
 
     pub fn add_to_rebuild_arch_eval(&mut self, symbol: Rc<RefCell<Symbol>>) {
         if DEBUG_THREADS {
-            trace!("ADDED TO EVAL - {}", symbol.borrow().paths().first().unwrap_or(&symbol.borrow().name().to_string()));
+            trace!("ADDED TO EVAL - {} - {:?}", symbol.borrow().name(), symbol.borrow().path());
         }
         if symbol.borrow().build_status(BuildSteps::ARCH_EVAL) != BuildStatus::IN_PROGRESS {
             let sym_clone = symbol.clone();
@@ -783,7 +786,7 @@ impl SyncOdoo {
 
     pub fn add_to_validations(&mut self, symbol: Rc<RefCell<Symbol>>) {
         if DEBUG_THREADS {
-            trace!("ADDED TO VALIDATION - {}", symbol.borrow().paths().first().unwrap_or(&symbol.borrow().name().to_string()));
+            trace!("ADDED TO VALIDATION - {} - {:?}", symbol.borrow().name(), symbol.borrow().path());
         }
         if symbol.borrow().build_status(BuildSteps::VALIDATION) != BuildStatus::IN_PROGRESS {
             symbol.borrow_mut().set_build_status(BuildSteps::VALIDATION, BuildStatus::PENDING);
@@ -805,10 +808,10 @@ impl SyncOdoo {
         }
         if DEBUG_REBUILD_NOW {
             if symbol.borrow().build_status(step) == BuildStatus::INVALID {
-                panic!("Trying to build an invalid symbol: {}", symbol.borrow().paths().first().unwrap_or(&symbol.borrow().name().to_string()));
+                panic!("Trying to build an invalid symbol: {} - {:?}", symbol.borrow().name(), symbol.borrow().path());
             }
             if symbol.borrow().build_status(step) == BuildStatus::IN_PROGRESS && !session.sync_odoo.is_in_rebuild(&symbol, step) {
-                error!("Trying to build a symbol that is NOT in the queue: {}", symbol.borrow().paths().first().unwrap_or(&symbol.borrow().name().to_string()));
+                error!("Trying to build a symbol that is NOT in the queue: {} - {:?}", symbol.borrow().name(), symbol.borrow().path());
             }
         }
         if symbol.borrow().build_status(step) == BuildStatus::PENDING && symbol.borrow().previous_step_done(step) {
@@ -822,7 +825,7 @@ impl SyncOdoo {
             } else if step == BuildSteps::ARCH_EVAL {
                 if DEBUG_REBUILD_NOW {
                     if symbol.borrow().build_status(BuildSteps::ARCH) != BuildStatus::DONE {
-                        panic!("An evaluation has been requested on a non-arched symbol: {}", symbol.borrow().paths().first().unwrap_or(&symbol.borrow().name().to_string()));
+                        panic!("An evaluation has been requested on a non-arched symbol: {} - {:?}", symbol.borrow().name(), symbol.borrow().path());
                     }
                 }
                 let mut builder = PythonArchEval::new(entry_point, symbol.clone());
@@ -831,7 +834,7 @@ impl SyncOdoo {
             } else if step == BuildSteps::VALIDATION {
                 if DEBUG_REBUILD_NOW {
                     if symbol.borrow().build_status(BuildSteps::ARCH) != BuildStatus::DONE || symbol.borrow().build_status(BuildSteps::ARCH_EVAL) != BuildStatus::DONE {
-                        panic!("An evaluation has been requested on a non-arched symbol: {}", symbol.borrow().paths().first().unwrap_or(&symbol.borrow().name().to_string()));
+                        panic!("An evaluation has been requested on a non-arched symbol: {} - {:?}", symbol.borrow().name(), symbol.borrow().path());
                     }
                 }
                 let mut validator = PythonValidator::new(entry_point, symbol.clone());
@@ -947,7 +950,10 @@ impl SyncOdoo {
                     let mut to_del = Vec::from_iter(path_symbol.borrow().all_module_symbol().map(|x| x.clone()));
                     let mut index = 0;
                     while index < to_del.len() {
-                        FileMgr::delete_path(session, &to_del[index].borrow().paths()[0]);
+                        match to_del[index].borrow().path() {
+                            SymbolPath::Single(p) => FileMgr::delete_path(session, &p),
+                            SymbolPath::Multiple(_) | SymbolPath::None => {}
+                        }
                         let mut to_del_child = Vec::from_iter(to_del[index].borrow().all_module_symbol().map(|x| x.clone()));
                         to_del.append(&mut to_del_child);
                         index += 1;

server/src/core/python_arch_builder.rs

@@ -68,10 +68,10 @@ impl PythonArchBuilder {
             self.current_step = if self.file_mode {BuildSteps::ARCH} else {BuildSteps::VALIDATION};
         }
         if DEBUG_STEPS && (!DEBUG_STEPS_ONLY_INTERNAL || !symbol.borrow().is_external()) {
-            trace!("building {} - {}", self.file.borrow().paths().first().unwrap_or(&S!("No path found")), symbol.borrow().name());
+            trace!("building {} - {}", self.file.borrow().path().as_single(), symbol.borrow().name());
         }
         symbol.borrow_mut().set_build_status(BuildSteps::ARCH, BuildStatus::IN_PROGRESS);
-        let path = self.file.borrow().get_symbol_first_path();
+        let path = self.file.borrow().get_file_path();
         if self.file_mode {
             let in_workspace = (self.file.borrow().parent().is_some() &&
                 self.file.borrow().parent().as_ref().unwrap().upgrade().is_some() &&
@@ -189,24 +189,24 @@ impl PythonArchBuilder {
                                     if value.is_some() {
                                         let (nf, parse_error) = self.extract_all_symbol_eval_values(&value.as_ref());
                                         if parse_error {
-                                            warn!("error during parsing __all__ import in file {}", (*import_result.symbol).borrow().paths()[0] )
+                                            warn!("error during parsing __all__ import in file {}", (*import_result.symbol).borrow().path().as_single())
                                         }
                                         name_filter = nf;
                                         all_name_allowed = false;
                                     } else {
-                                        warn!("invalid __all__ import in file {} - no value found", (*import_result.symbol).borrow().paths()[0])
+                                        warn!("invalid __all__ import in file {} - no value found", (*import_result.symbol).borrow().path().as_single())
                                     }
                                 } else {
-                                    warn!("invalid __all__ import in file {} - multiple evaluation found", (*import_result.symbol).borrow().paths()[0])
+                                    warn!("invalid __all__ import in file {} - multiple evaluation found", (*import_result.symbol).borrow().path().as_single())
                                 }
                             } else {
-                                warn!("invalid __all__ import in file {} - localizedSymbol not found", (*import_result.symbol).borrow().paths()[0])
+                                warn!("invalid __all__ import in file {} - localizedSymbol not found", (*import_result.symbol).borrow().path().as_single())
                             }
                         } else {
-                            warn!("invalid __all__ import in file {} - expired symbol", (*import_result.symbol).borrow().paths()[0])
+                            warn!("invalid __all__ import in file {} - expired symbol", (*import_result.symbol).borrow().path().as_single())
                         }
                     } else {
-                        warn!("invalid __all__ import in file {} - no symbol found", (*import_result.symbol).borrow().paths()[0])
+                        warn!("invalid __all__ import in file {} - no symbol found", (*import_result.symbol).borrow().path().as_single())
                     }
                 }
                 let mut dep_to_add = vec![];

server/src/core/python_arch_builder_hooks.rs

@@ -177,15 +177,15 @@ impl PythonArchBuilderHooks {
         let name = symbol.borrow().name().clone();
         if name == "release" {
             if symbol.borrow().get_main_entry_tree(session) == (vec![Sy!("odoo"), Sy!("release")], vec![]) {
-                let (maj, min, mic) = SyncOdoo::read_version(session, PathBuf::from(symbol.borrow().paths()[0].clone()));
+                let (maj, min, mic) = SyncOdoo::read_version(session, PathBuf::from(symbol.borrow().path().as_single()));
                 if maj != session.sync_odoo.version_major || min != session.sync_odoo.version_minor || mic != session.sync_odoo.version_micro {
                     session.sync_odoo.need_rebuild = true;
                 }
             }
         } else if name == "init" {
             if compare_semver(session.sync_odoo.full_version.as_str(), "18.1") != Ordering::Less {
                 if symbol.borrow().get_main_entry_tree(session) == (vec![Sy!("odoo"), Sy!("init")], vec![]) {
-                    let odoo_namespace = session.sync_odoo.get_symbol(symbol.borrow().paths()[0].as_str(), &(vec![Sy!("odoo")], vec![]), u32::MAX);
+                    let odoo_namespace = session.sync_odoo.get_symbol(&symbol.borrow().path().as_single(), &(vec![Sy!("odoo")], vec![]), u32::MAX);
                     if let Some(odoo_namespace) = odoo_namespace.get(0) {
                         // create _ and Command as ext_symbols
                         let owner = symbol.clone();
@@ -199,7 +199,7 @@ impl PythonArchBuilderHooks {
         } else if name == "werkzeug" {
             if symbol.borrow().get_main_entry_tree(session) == (vec![Sy!("odoo"), Sy!("_monkeypatches"), Sy!("werkzeug")], vec![]) {
                 //doing this patch like this imply that an odoo project will make these functions available for all entrypoints, but heh
-                let werkzeug_url = session.sync_odoo.get_symbol(symbol.borrow().paths()[0].as_str(), &(vec![Sy!("werkzeug"), Sy!("urls")], vec![]), u32::MAX);
+                let werkzeug_url = session.sync_odoo.get_symbol(&symbol.borrow().path().as_single(), &(vec![Sy!("werkzeug"), Sy!("urls")], vec![]), u32::MAX);
                 if let Some(werkzeug_url) = werkzeug_url.first() {
                     let url_join = werkzeug_url.borrow().get_symbol(&(vec![], vec![Sy!("url_join")]), u32::MAX);
                     if url_join.is_empty() { //else, installed version is already patched

server/src/core/python_arch_eval.rs

@@ -72,13 +72,10 @@ impl PythonArchEval {
             self.current_step = if self.file_mode {BuildSteps::ARCH_EVAL} else {BuildSteps::VALIDATION};
         }
         if DEBUG_STEPS && (!DEBUG_STEPS_ONLY_INTERNAL || !symbol.borrow().is_external()) {
-            trace!("evaluating {} - {}", self.file.borrow().paths().first().unwrap_or(&S!("No path found")), symbol.borrow().name());
+            trace!("evaluating {} - {}", self.file.borrow().path().as_single(), symbol.borrow().name());
         }
         symbol.borrow_mut().set_build_status(BuildSteps::ARCH_EVAL, BuildStatus::IN_PROGRESS);
-        if self.file.borrow().paths().len() != 1 {
-            panic!("Trying to eval_arch a symbol without any path")
-        }
-        let path = self.file.borrow().get_symbol_first_path();
+        let path = self.file.borrow().get_file_path();
         let Some(file_info_rc) = session.sync_odoo.get_file_mgr().borrow().get_file_info(&path).clone() else {
             warn!("File info not found for {}", path);
             return;
@@ -515,7 +512,7 @@ impl PythonArchEval {
                             if let Some(sym) = evaluation.symbol.get_symbol_as_weak(session, &mut None, &mut self.diagnostics, None).weak.upgrade() {
                                 if Rc::ptr_eq(&sym, &variable_rc){
                                     // TODO: investigate deps, and fix cyclic evals
-                                    let file_path = parent.borrow().get_file().and_then(|file| file.upgrade()).and_then(|file| file.borrow().paths().first().cloned());
+                                    let file_path = parent.borrow().get_file().and_then(|file| file.upgrade()).and_then(|file| Some(file.borrow().path().as_single()));
                                     warn!("Found cyclic evaluation symbol: {}, parent: {}, file: {}", var_name, parent.borrow().name(), file_path.unwrap_or(S!("N/A")));
                                     evaluations.remove(ix);
                                     continue;