[IMP] server: record - validate model. Add validation step to xml files

Author: fda-odoo

server/src/core/mod.rs

@@ -17,4 +17,5 @@ pub mod python_utils;
 pub mod symbols;
 pub mod xml_arch_builder;
 pub mod xml_arch_builder_rng_validation;
-pub mod xml_data;
+pub mod xml_data;
+pub mod xml_validation;

server/src/core/odoo.rs

@@ -1,4 +1,5 @@
 use crate::core::entry_point::EntryPointType;
+use crate::core::xml_validation::XmlValidator;
 use crate::features::document_symbols::DocumentSymbolFeature;
 use crate::threads::SessionInfo;
 use crate::features::completion::CompletionFeature;
@@ -599,8 +600,17 @@ impl SyncOdoo {
                     session.sync_odoo.add_to_validations(sym_rc.clone());
                     return true;
                 }
-                let mut validator = PythonValidator::new(entry.unwrap(), sym_rc);
-                validator.validate(session);
+                let typ = sym_rc.borrow().typ();
+                match typ {
+                    SymType::XML_FILE => {
+                        let mut validator = XmlValidator::new(entry.as_ref().unwrap(), sym_rc);
+                        validator.validate(session);
+                    },
+                    _ => {
+                        let mut validator = PythonValidator::new(entry.unwrap(), sym_rc);
+                        validator.validate(session);
+                    }
+                }
                 continue;
             }
         }

server/src/core/python_odoo_builder.rs

@@ -82,13 +82,20 @@ impl PythonOdooBuilder {
             None => {
                 let model = Model::new(model_name.clone(), sym.clone());
                 session.sync_odoo.modules.get("base").map(|module| {
+                    let file = self.symbol.borrow().get_file().unwrap().upgrade().unwrap();
                     let xml_id_model_name = oyarn!("model_{}", model_name.replace(".", "_").as_str());
                     let module = module.upgrade().unwrap();
                     let mut module = module.borrow_mut();
-                    let set = module.as_module_package_mut().xml_ids.entry(xml_id_model_name.clone()).or_insert(vec![]);
-                    set.push(XmlData::RECORD(XmlDataRecord {
-                        xml_symbol: sym.clone(),
-                        model: Sy!("ir.model"),
+                    let set = module.as_module_package_mut().xml_ids.entry(xml_id_model_name.clone()).or_insert(PtrWeakHashSet::new());
+                    set.insert(file.clone());
+                    let mut file = file.borrow_mut();
+                    let file = file.as_file_mut();
+                    file.xml_ids.entry(xml_id_model_name.clone()).or_insert(vec![]).push(XmlData::RECORD(XmlDataRecord {
+                        file_symbol: Rc::downgrade(&sym),
+                        model: (Sy!("ir.model"), std::ops::Range::<usize> {
+                            start: 0,
+                            end: 1,
+                        }),
                         xml_id: Some(xml_id_model_name),
                     }));
                 });

server/src/core/symbols/file_symbol.rs

@@ -1,6 +1,6 @@
 use weak_table::{PtrWeakHashSet, PtrWeakKeyHashMap};
 
-use crate::{constants::{BuildStatus, BuildSteps, OYarn}, core::{file_mgr::NoqaInfo, model::Model}, oyarn};
+use crate::{constants::{BuildStatus, BuildSteps, OYarn}, core::{file_mgr::NoqaInfo, model::Model, xml_data::XmlData}, oyarn};
 use std::{cell::RefCell, collections::HashMap, rc::{Rc, Weak}};
 
 use super::{symbol::Symbol, symbol_mgr::{SectionRange, SymbolMgr}};
@@ -17,6 +17,7 @@ pub struct FileSymbol {
     pub odoo_status: BuildStatus,
     pub validation_status: BuildStatus,
     pub not_found_paths: Vec<(BuildSteps, Vec<OYarn>)>,
+    pub xml_ids: HashMap<OYarn, Vec<XmlData>>, //used for dynamic XML_ID records, like ir.models
     in_workspace: bool,
     pub self_import: bool,
     pub model_dependencies: PtrWeakHashSet<Weak<RefCell<Model>>>, //always on validation level, as odoo step is always required
@@ -47,6 +48,7 @@ impl FileSymbol {
             odoo_status: BuildStatus::PENDING,
             validation_status: BuildStatus::PENDING,
             not_found_paths: vec![],
+            xml_ids: HashMap::new(),
             in_workspace: false,
             self_import: false,
             sections: vec![],

server/src/core/symbols/module_symbol.rs

@@ -41,7 +41,7 @@ pub struct ModuleSymbol {
     all_depends: HashSet<OYarn>, //computed all depends to avoid too many recomputations
     data: Vec<(String, TextRange)>, // TODO
     pub module_symbols: HashMap<OYarn, Rc<RefCell<Symbol>>>,
-    pub xml_ids: HashMap<OYarn, Vec<XmlData>>,
+    pub xml_ids: HashMap<OYarn, PtrWeakHashSet<Weak<RefCell<Symbol>>>>, //contains all xml_file_symbols that contains the xml_id. Needed because it can be in another module.
     pub arch_status: BuildStatus,
     pub arch_eval_status: BuildStatus,
     pub odoo_status: BuildStatus,
@@ -375,7 +375,6 @@ impl ModuleSymbol {
                     let root = document.root_element();
                     let mut xml_builder = XmlArchBuilder::new(xml_sym);
                     xml_builder.load_arch(session, &mut file_info, &root);
-                    file_info.publish_diagnostics(session); //TODO do it only if diagnostics are not empty, else in validation
                 } else if data.len() > 0 {
                     let mut diagnostics = vec![];
                     XmlFileSymbol::build_syntax_diagnostics(&session, &mut diagnostics, &mut file_info, &document.unwrap_err());
@@ -527,4 +526,18 @@ impl ModuleSymbol {
         result
     }
 
+    //given an xml_id without "module." part, return all XmlData that declare it ("this_module.xml_id"), regardless of the module declaring it.
+    //For example, stock could create an xml_id called "account.my_xml_id", and so be returned by this function called on "account" module with xml_id "my_xml_id"
+    pub fn get_xml_id(&self, xml_id: &OYarn) -> Vec<XmlData> {
+        let mut res = vec![];
+        if let Some(xml_file_set) = self.xml_ids.get(xml_id) {
+            for xml_file in xml_file_set.iter() {
+                if let Some(xml_data) = xml_file.borrow().as_xml_file_sym().xml_ids.get(xml_id) {
+                    res.extend(xml_data.iter().cloned());
+                }
+            }
+        }
+        res
+    }
+
 }

server/src/core/symbols/symbol.rs

@@ -548,6 +548,20 @@ impl Symbol {
         }
     }
 
+    pub fn as_xml_file_sym(&self) -> &XmlFileSymbol {
+        match self {
+            Symbol::XmlFileSymbol(x) => x,
+            _ => {panic!("Not an XML file symbol")}
+        }
+    }
+
+    pub fn as_xml_file_sym_mut(&mut self) -> &mut XmlFileSymbol {
+        match self {
+            Symbol::XmlFileSymbol(x) => x,
+            _ => {panic!("Not an XML file symbol")}
+        }
+    }
+
     pub fn as_symbol_mgr(&self) -> &dyn SymbolMgr {
         match self {
             Symbol::File(f) => f,
@@ -1074,7 +1088,7 @@ impl Symbol {
                 match step {
                     BuildSteps::SYNTAX => panic!(),
                     BuildSteps::ARCH => x.arch_status = status,
-                    BuildSteps::ARCH_EVAL => panic!(),
+                    BuildSteps::ARCH_EVAL => {},
                     BuildSteps::VALIDATION => x.validation_status = status,
                 }
             },
@@ -1571,8 +1585,8 @@ impl Symbol {
         }
     }
 
-    //Add a symbol as dependency on the step of the other symbol for the build level.
-    //-> The build of the 'step' of self requires the build of 'dep_level' of the other symbol to be done
+    /**Add a symbol as dependency on the step of the other symbol for the build level.
+    * -> The build of the 'step' of self requires the build of 'dep_level' of the other symbol to be done */
     pub fn add_dependency(&mut self, symbol: &mut Symbol, step:BuildSteps, dep_level:BuildSteps) {
         if step == BuildSteps::SYNTAX || dep_level == BuildSteps::SYNTAX {
             panic!("Can't add dependency for syntax step")
@@ -1651,9 +1665,9 @@ impl Symbol {
                         if let Some(hashset) = hashset {
                             for sym in hashset {
                                 if !Symbol::is_symbol_in_parents(&sym, &ref_to_inv) {
-                                    if index == BuildSteps::ARCH_EVAL as usize {
+                                    if index + 1 == BuildSteps::ARCH_EVAL as usize {
                                         session.sync_odoo.add_to_rebuild_arch_eval(sym.clone());
-                                    } else if index == BuildSteps::VALIDATION as usize {
+                                    } else if index + 1 == BuildSteps::VALIDATION as usize {
                                         sym.borrow_mut().invalidate_sub_functions(session);
                                         session.sync_odoo.add_to_validations(sym.clone());
                                     }

server/src/core/symbols/xml_file_symbol.rs

@@ -2,7 +2,8 @@ use lsp_types::Diagnostic;
 use roxmltree::Error;
 use weak_table::PtrWeakHashSet;
 
-use crate::{constants::{BuildStatus, BuildSteps, OYarn}, core::{diagnostics::DiagnosticCode, file_mgr::{FileInfo, NoqaInfo}, model::Model}, oyarn, threads::SessionInfo, S};
+use crate::{core::diagnostics::DiagnosticCode, threads::SessionInfo};
+use crate::{constants::{BuildStatus, BuildSteps, OYarn, EXTENSION_NAME}, core::{file_mgr::{FileInfo, NoqaInfo}, model::Model, xml_data::XmlData}, oyarn, S};
 use std::{cell::RefCell, collections::HashMap, rc::{Rc, Weak}};
 
 use super::{symbol::Symbol, symbol_mgr::SectionRange};
@@ -17,6 +18,7 @@ pub struct XmlFileSymbol {
     pub arch_status: BuildStatus,
     pub validation_status: BuildStatus,
     pub not_found_paths: Vec<(BuildSteps, Vec<OYarn>)>,
+    pub xml_ids: HashMap<OYarn, Vec<XmlData>>,
     in_workspace: bool,
     pub self_import: bool,
     pub model_dependencies: PtrWeakHashSet<Weak<RefCell<Model>>>, //always on validation level, as odoo step is always required
@@ -44,6 +46,7 @@ impl XmlFileSymbol {
             arch_status: BuildStatus::PENDING,
             validation_status: BuildStatus::PENDING,
             not_found_paths: vec![],
+            xml_ids: HashMap::new(),
             in_workspace: false,
             self_import: false,
             sections: vec![],

server/src/core/xml_arch_builder.rs

@@ -38,6 +38,7 @@ impl XmlArchBuilder {
         self.load_odoo_openerp_data(session, node, &mut diagnostics);
         self.xml_symbol.borrow_mut().set_build_status(BuildSteps::ARCH, BuildStatus::DONE);
         file_info.replace_diagnostics(BuildSteps::ARCH, diagnostics);
+        session.sync_odoo.add_to_validations(self.xml_symbol.clone());
     }
 
     pub fn on_operation_creation(
@@ -79,18 +80,18 @@ impl XmlArchBuilder {
                     xml_module = m.upgrade().unwrap();
                 }
             }
-            if xml_module.borrow().as_module_package().xml_ids.get(&Sy!(id.clone())).is_none() {
-                xml_module.borrow_mut().as_module_package_mut().xml_ids.insert(Sy!(id.clone()), vec![]);
-            }
-            xml_data.set_symbol(self.xml_symbol.clone());
-            xml_module.borrow_mut().as_module_package_mut().xml_ids.get_mut(&Sy!(id)).unwrap().push(xml_data);
+            xml_data.set_file_symbol(&self.xml_symbol);
+            xml_module.borrow_mut().as_module_package_mut().xml_ids.entry(Sy!(id.clone())).or_insert(PtrWeakHashSet::new()).insert(self.xml_symbol.clone());
+            self.xml_symbol.borrow_mut().as_xml_file_sym_mut().xml_ids.entry(Sy!(id.clone())).or_insert(vec![]).push(xml_data);
         }
     }
 
+    /**
+     * search for an xml_id in the already registered xml files.
+     * */
     pub fn get_xml_ids(&self, session: &mut SessionInfo, xml_id: &str, attr: &Attribute, diagnostics: &mut Vec<Diagnostic>) -> Vec<XmlData> {
-        let mut res = vec![];
         if !self.is_in_main_ep {
-            return res;
+            return vec![];
         }
         let id_split = xml_id.split(".").collect::<Vec<&str>>();
         let mut module = None;
@@ -115,17 +116,15 @@ impl XmlArchBuilder {
                 None,
                 None
             ));
-            return res;
+            return vec![];
         }
         if module.is_none() {
             warn!("Module not found for id: {}", xml_id);
-            return res;
+            return vec![];
         }
         let module = module.unwrap();
-        if let Some(xml) = module.borrow().as_module_package().xml_ids.get(&oyarn!("{}", id_split.last().unwrap())) {
-            res.extend(xml.iter().map(|x| x.clone()));
-        }
-        res
+        let module = module.borrow();
+        module.as_module_package().get_xml_id(&oyarn!("{}", id_split.last().unwrap()))
     }
 
     pub fn get_group_ids(&self, session: &mut SessionInfo, xml_id: &str, attr: &Attribute, diagnostics: &mut Vec<Diagnostic>) -> Vec<XmlData> {
@@ -134,7 +133,7 @@ impl XmlArchBuilder {
         for data in xml_ids.iter() {
             match data {
                 XmlData::RECORD(r) => {
-                    if r.model == "res.groups" {
+                    if r.model.0 == "res.groups" {
                         res.push(data.clone());
                     }
                 },

server/src/core/xml_arch_builder_rng_validation.rs

@@ -175,7 +175,7 @@ impl XmlArchBuilder {
             }
         }
         let data = XmlData::MENUITEM(XmlDataMenuItem {
-            xml_symbol: self.xml_symbol.clone(),
+            file_symbol: Rc::downgrade(&self.xml_symbol),
             xml_id: found_id.clone().map(|id| oyarn!("{}", id)),
         });
         self.on_operation_creation(session, found_id, node, data, diagnostics);
@@ -225,8 +225,8 @@ impl XmlArchBuilder {
             }
         }
         let data = XmlData::RECORD(XmlDataRecord {
-            xml_symbol: self.xml_symbol.clone(),
-            model: oyarn!("{}", node.attribute("model").unwrap()),
+            file_symbol: Rc::downgrade(&self.xml_symbol),
+            model: (oyarn!("{}", node.attribute("model").unwrap()), node.attribute_node("model").unwrap().range()),
             xml_id: found_id.clone().map(|id| oyarn!("{}", id)),
         });
         self.on_operation_creation(session, found_id, node, data, diagnostics);
@@ -444,7 +444,7 @@ impl XmlArchBuilder {
         //no interesting rule to check, as 'any' is valid
         let found_id = node.attribute("id").map(|s| s.to_string());
         let data = XmlData::TEMPLATE(XmlDataTemplate {
-            xml_symbol: self.xml_symbol.clone(),
+            file_symbol: Rc::downgrade(&self.xml_symbol),
             xml_id: found_id.clone().map(|id| oyarn!("{}", id)),
         });
         self.on_operation_creation(session, found_id, node, data, diagnostics);
@@ -480,7 +480,7 @@ impl XmlArchBuilder {
             }
         }
         let data = XmlData::DELETE(XmlDataDelete {
-            xml_symbol: self.xml_symbol.clone(),
+            file_symbol: Rc::downgrade(&self.xml_symbol),
             xml_id: found_id.clone().map(|id| oyarn!("{}", id)),
             model: Sy!(node.attribute("model").unwrap().to_string()),
         });
@@ -547,7 +547,7 @@ impl XmlArchBuilder {
             }
         }
         let data = XmlData::ACT_WINDOW(XmlDataActWindow {
-            xml_symbol: self.xml_symbol.clone(),
+            file_symbol: Rc::downgrade(&self.xml_symbol),
             xml_id: found_id.clone().map(|id| oyarn!("{}", id)),
             res_model: Sy!(node.attribute("res_model").unwrap().to_string()),
             name: Sy!(node.attribute("name").unwrap().to_string()),
@@ -593,7 +593,7 @@ impl XmlArchBuilder {
             }
         }
         let data = XmlData::REPORT(XmlDataReport {
-            xml_symbol: self.xml_symbol.clone(),
+            file_symbol: Rc::downgrade(&self.xml_symbol),
             xml_id: found_id.clone().map(|id| oyarn!("{}", id)),
             name: Sy!(node.attribute("name").unwrap().to_string()),
             model: Sy!(node.attribute("model").unwrap().to_string()),