[IMP] server: references for xml that return all results without dependency check (only xml)

fda-odoo · fda-odoo · commit 89a518e961bc · 2025-08-06T17:46:33.000+02:00
diff --git a/server/src/core/odoo.rs b/server/src/core/odoo.rs
@@ -4,6 +4,7 @@ use crate::core::symbols::file_symbol;
 use crate::core::xml_data::XmlData;
 use crate::core::xml_validation::XmlValidator;
 use crate::features::document_symbols::DocumentSymbolFeature;
+use crate::features::references::ReferenceFeature;
 use crate::threads::SessionInfo;
 use crate::features::completion::CompletionFeature;
 use crate::features::definition::DefinitionFeature;
@@ -1206,6 +1207,43 @@ impl Odoo {
         Ok(None)
     }
 
+    pub fn handle_references(session: &mut SessionInfo, params: ReferenceParams) -> Result<Option<Vec<Location>>, ResponseError> {
+        if session.sync_odoo.state_init == InitState::NOT_READY {
+            return Ok(None);
+        }
+        session.log_message(MessageType::INFO, format!("References requested on {} at {} - {}",
+            params.text_document_position.text_document.uri.to_string(),
+            params.text_document_position.position.line,
+            params.text_document_position.position.character));
+        let uri = params.text_document_position.text_document.uri.to_string();
+        let path = FileMgr::uri2pathname(uri.as_str());
+        if uri.ends_with(".py") || uri.ends_with(".pyi") || uri.ends_with(".xml") || uri.ends_with(".csv") {
+            if let Some(file_symbol) = SyncOdoo::get_symbol_of_opened_file(session, &PathBuf::from(path.clone())) {
+                let file_info = session.sync_odoo.get_file_mgr().borrow_mut().get_file_info(&path);
+                if let Some(file_info) = file_info {
+                    if file_info.borrow().file_info_ast.borrow().ast.is_none() {
+                        file_info.borrow_mut().prepare_ast(session);
+                    }
+                    let ast_type = file_info.borrow().file_info_ast.borrow().ast_type.clone();
+                    match ast_type {
+                        AstType::Python => {
+                            if file_info.borrow_mut().file_info_ast.borrow().ast.is_some() {
+                                return Ok(ReferenceFeature::get_references(session, &file_symbol, &file_info, params.text_document_position.position.line, params.text_document_position.position.character));
+                            }
+                        },
+                        AstType::Xml => {
+                            return Ok(ReferenceFeature::get_references_xml(session, &file_symbol, &file_info, params.text_document_position.position.line, params.text_document_position.position.character));
+                        },
+                        AstType::Csv => {
+                            return Ok(ReferenceFeature::get_references_csv(session, &file_symbol, &file_info, params.text_document_position.position.line, params.text_document_position.position.character));
+                        },
+                    }
+                }
+            }
+        }
+        Ok(None)
+    }
+
     pub fn handle_autocomplete(session: &mut SessionInfo ,params: CompletionParams) -> Result<Option<CompletionResponse>, ResponseError> {
         if session.sync_odoo.state_init == InitState::NOT_READY {
             return Ok(None);
diff --git a/server/src/features/definition.rs b/server/src/features/definition.rs
@@ -161,7 +161,7 @@ impl DefinitionFeature {
         let document = roxmltree::Document::parse(&data);
         if let Ok(document) = document {
             let root = document.root_element();
-            let (symbols, _range) = XmlAstUtils::get_symbols(session, file_symbol, root, offset);
+            let (symbols, _range) = XmlAstUtils::get_symbols(session, file_symbol, root, offset, true);
             if symbols.is_empty() {
                 return None;
             }
diff --git a/server/src/features/hover.rs b/server/src/features/hover.rs
@@ -37,7 +37,7 @@ impl HoverFeature {
         let document = roxmltree::Document::parse(&data);
         if let Ok(document) = document {
             let root = document.root_element();
-            let (symbols, range) = XmlAstUtils::get_symbols(session, file_symbol, root, offset);
+            let (symbols, range) = XmlAstUtils::get_symbols(session, file_symbol, root, offset, true);
             let range = range.map(|r| (file_info.borrow().std_range_to_range(&r)));
             let evals = symbols.iter().filter(|s| matches!(s, XmlAstResult::SYMBOL(_)))
                 .map(|s| Evaluation::eval_from_symbol(&Rc::downgrade(&s.as_symbol()), Some(false))).collect::<Vec<Evaluation>>();
diff --git a/server/src/features/mod.rs b/server/src/features/mod.rs
@@ -1,7 +1,8 @@
+pub mod ast_utils;
 pub mod completion;
 pub mod definition;
 pub mod document_symbols;
-pub mod hover;
-pub mod ast_utils;
 pub mod features_utils;
+pub mod hover;
+pub mod references;
 pub mod xml_ast_utils;
diff --git a/server/src/features/references.rs b/server/src/features/references.rs
@@ -0,0 +1,71 @@
+use std::{cell::RefCell, path::PathBuf, rc::Rc};
+
+use lsp_server::ResponseError;
+use lsp_types::{Location, Range};
+
+use crate::{constants::SymType, core::{file_mgr::{FileInfo, FileMgr}, symbols::{file_symbol::FileSymbol, symbol::Symbol}}, features::xml_ast_utils::{XmlAstResult, XmlAstUtils}, threads::SessionInfo, utils::PathSanitizer};
+
+
+
+pub struct ReferenceFeature {
+
+}
+
+impl ReferenceFeature {
+    pub fn get_references(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, file_info: &Rc<RefCell<FileInfo>>, line: u32, character: u32) -> Option<Vec<Location>> {
+        // Implementation for getting references
+        None
+    }
+
+    pub fn get_references_xml(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, file_info: &Rc<RefCell<FileInfo>>, line: u32, character: u32) -> Option<Vec<Location>> {
+        let offset = file_info.borrow().position_to_offset(line, character);
+        let data = file_info.borrow().file_info_ast.borrow().text_rope.as_ref().unwrap().to_string();
+        let document = roxmltree::Document::parse(&data);
+        if let Ok(document) = document {
+            let root = document.root_element();
+            let (symbols, _range) = XmlAstUtils::get_symbols(session, file_symbol, root, offset, false);
+            if symbols.is_empty() {
+                return None;
+            }
+            let mut links = vec![];
+            for xml_result in symbols.iter() {
+                match xml_result {
+                    crate::features::xml_ast_utils::XmlAstResult::SYMBOL(s) => {
+                        if let Some(file) = s.borrow().get_file() {
+                            for path in file.upgrade().unwrap().borrow().paths().iter() {
+                                let full_path = match file.upgrade().unwrap().borrow().typ() {
+                                    SymType::PACKAGE(_) => PathBuf::from(path).join(format!("__init__.py{}", file.upgrade().unwrap().borrow().as_package().i_ext())).sanitize(),
+                                    _ => path.clone()
+                                };
+                                let range = match s.borrow().typ() {
+                                    SymType::PACKAGE(_) | SymType::FILE | SymType::NAMESPACE | SymType::DISK_DIR => Range::default(),
+                                    _ => session.sync_odoo.get_file_mgr().borrow().text_range_to_range(session, &full_path, &s.borrow().range()),
+                                };
+                                links.push(Location{uri: FileMgr::pathname2uri(&full_path), range});
+                            }
+                        }
+                    },
+                    XmlAstResult::XML_DATA(xml_file_symbol, range) => {
+                        for path in xml_file_symbol.borrow().paths().iter() {
+                            let full_path = match xml_file_symbol.borrow().typ() {
+                                SymType::PACKAGE(_) => PathBuf::from(path).join(format!("__init__.py{}", xml_file_symbol.borrow().as_package().i_ext())).sanitize(),
+                                _ => path.clone()
+                            };
+                            let range = match xml_file_symbol.borrow().typ() {
+                                SymType::PACKAGE(_) | SymType::FILE | SymType::NAMESPACE | SymType::DISK_DIR => Range::default(),
+                                _ => session.sync_odoo.get_file_mgr().borrow().std_range_to_range(session, &full_path, &range),
+                            };
+                            links.push(Location{uri: FileMgr::pathname2uri(&full_path), range: range});
+                        }
+                    }
+                }
+            }
+            return Some(links);
+        }
+        None
+    }
+
+    pub fn get_references_csv(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, file_info: &Rc<RefCell<FileInfo>>, line: u32, character: u32) -> Option<Vec<Location>> {
+        None
+    }
+}
diff --git a/server/src/features/xml_ast_utils.rs b/server/src/features/xml_ast_utils.rs
@@ -2,7 +2,7 @@ use std::{cell::RefCell, collections::HashMap, ops::Range, rc::Rc};
 
 use roxmltree::Node;
 
-use crate::{constants::OYarn, core::{evaluation::ContextValue, symbols::symbol::Symbol, xml_data::XmlData}, threads::SessionInfo, Sy, S};
+use crate::{constants::OYarn, core::{evaluation::ContextValue, symbols::{module_symbol::ModuleSymbol, symbol::Symbol}, xml_data::XmlData}, threads::SessionInfo, Sy, S};
 
 pub enum XmlAstResult {
     SYMBOL(Rc<RefCell<Symbol>>),
@@ -29,61 +29,65 @@ pub struct XmlAstUtils {}
 
 impl XmlAstUtils {
 
-    pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, root: roxmltree::Node, offset: usize) -> (Vec<XmlAstResult>, Option<Range<usize>>) {
+    pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, root: roxmltree::Node, offset: usize, on_dep_only: bool) -> (Vec<XmlAstResult>, Option<Range<usize>>) {
         let mut results = (vec![], None);
         let from_module = file_symbol.borrow().find_module();
         let mut context_xml = HashMap::new();
         for node in root.children() {
-            XmlAstUtils::visit_node(session, &node, offset, from_module.clone(), &mut context_xml, &mut results);
+            XmlAstUtils::visit_node(session, &node, offset, from_module.clone(), &mut context_xml, &mut results, on_dep_only);
         }
         results
     }
 
-    fn visit_node(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {
+    fn visit_node(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {
         if node.is_element() {
             match node.tag_name().name()  {
                 "record" => {
-                    XmlAstUtils::visit_record(session, &node, offset, from_module.clone(), ctxt, results);
+                    XmlAstUtils::visit_record(session, &node, offset, from_module.clone(), ctxt, results, on_dep_only);
                 }
                 "field" => {
-                    XmlAstUtils::visit_field(session, &node, offset, from_module.clone(), ctxt, results);
+                    XmlAstUtils::visit_field(session, &node, offset, from_module.clone(), ctxt, results, on_dep_only);
                 }
                 _ => {
                     for child in node.children() {
-                        XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results);
+                        XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results, on_dep_only);
                     }
                 }
             }
         } else if node.is_text() {
-            XmlAstUtils::visit_text(session, &node, offset, from_module, ctxt, results);
+            XmlAstUtils::visit_text(session, &node, offset, from_module, ctxt, results, on_dep_only);
         }
     }
 
-    fn visit_record(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {
+    fn visit_record(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {
         for attr in node.attributes() {
             if attr.name() == "model" {
                 let model_name = attr.value().to_string();
                 ctxt.insert(S!("record_model"), ContextValue::STRING(model_name.clone()));
                 if attr.range_value().start <= offset && attr.range_value().end >= offset {
                     if let Some(model) = session.sync_odoo.models.get(&Sy!(model_name)).cloned() {
-                        results.0.extend(model.borrow().all_symbols(session, from_module.clone(), false).iter().filter(|s| s.1.is_none()).map(|s| XmlAstResult::SYMBOL(s.0.clone())));
+                        let from_module = match on_dep_only {
+                            true => from_module.clone(),
+                            false => None,
+                        };
+                        results.0.extend(model.borrow().all_symbols(session, from_module, false).iter().filter(|s| s.1.is_none()).map(|s| XmlAstResult::SYMBOL(s.0.clone())));
                         results.1 = Some(attr.range_value());
                     }
                 }
             } else if attr.name() == "id" {
                 if attr.range_value().start <= offset && attr.range_value().end >= offset {
-                    XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results);
+                    XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results, on_dep_only);
                     results.1 = Some(attr.range_value());
                 }
             }
         }
         for child in node.children() {
-            XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results);
+            XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results, on_dep_only);
         }
         ctxt.remove(&S!("record_model"));
     }
 
-    fn visit_field(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {
+    fn visit_field(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {
         for attr in node.attributes() {
             if attr.name() == "name" {
                 ctxt.insert(S!("field_name"), ContextValue::STRING(attr.value().to_string()));
@@ -93,7 +97,11 @@ impl XmlAstUtils {
                         continue;
                     }
                     if let Some(model) = session.sync_odoo.models.get(&Sy!(model_name)).cloned() {
-                        for symbol in model.borrow().all_symbols(session, from_module.clone(), true) {
+                        let from_module = match on_dep_only {
+                            true => from_module.clone(),
+                            false => None,
+                        };
+                        for symbol in model.borrow().all_symbols(session, from_module, true) {
                             if symbol.1.is_none() {
                                 let content = symbol.0.borrow().get_content_symbol(attr.value(), u32::MAX);
                                 for symbol in content.symbols.iter() {
@@ -113,19 +121,19 @@ impl XmlAstUtils {
                         }
                     }
                     if field_name == "inherit_id" {
-                        XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results);
+                        XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results, on_dep_only);
                         results.1 = Some(attr.range_value());
                     }
                 }
             }
         }
         for child in node.children() {
-            XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results);
+            XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results, on_dep_only);
         }
         ctxt.remove(&S!("field_name"));
     }
 
-    fn visit_text(session: &mut SessionInfo, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {
+    fn visit_text(session: &mut SessionInfo, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {
         if node.range().start <= offset && node.range().end >= offset {
             let model = ctxt.get(&S!("record_model")).cloned().unwrap_or(ContextValue::STRING(S!(""))).as_string();
             let field = ctxt.get(&S!("field_name")).cloned().unwrap_or(ContextValue::STRING(S!(""))).as_string();
@@ -135,16 +143,34 @@ impl XmlAstUtils {
             if model == "ir.ui.view" {
                 if field == "model" {
                     if let Some(model) = session.sync_odoo.models.get(node.text().unwrap()).cloned() {
-                        results.0.extend(model.borrow().all_symbols(session, from_module.clone(), false).iter().filter(|s| s.1.is_none()).map(|s| XmlAstResult::SYMBOL(s.0.clone())));
+                        let from_module = match on_dep_only {
+                            true => from_module.clone(),
+                            false => None,
+                        };
+                        results.0.extend(model.borrow().all_symbols(session, from_module, false).iter().filter(|s| s.1.is_none()).map(|s| XmlAstResult::SYMBOL(s.0.clone())));
                         results.1 = Some(node.range());
                     }
                 }
             }
         }
     }
 
-    fn add_xml_id_result(session: &mut SessionInfo, xml_id: &str, file_symbol: &Rc<RefCell<Symbol>>, range: Range<usize>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {
-        let xml_ids = session.sync_odoo.get_xml_ids(file_symbol, xml_id, &range, &mut vec![]);
+    fn add_xml_id_result(session: &mut SessionInfo, xml_id: &str, file_symbol: &Rc<RefCell<Symbol>>, range: Range<usize>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {
+        let mut xml_ids = session.sync_odoo.get_xml_ids(file_symbol, xml_id, &range, &mut vec![]);
+        if on_dep_only {
+            xml_ids = xml_ids.into_iter().filter(|x| 
+                {
+                    let file = x.get_xml_file_symbol();
+                    if let Some(file) = file {
+                        let module = file.borrow().find_module();
+                        if let Some(module) = module {
+                            return ModuleSymbol::is_in_deps(session, &file_symbol.borrow().find_module().unwrap(), module.borrow().name());
+                        }
+                    }
+                        return false;
+                }
+            ).collect::<Vec<_>>();
+        }
         for xml_data in xml_ids.iter() {
             match xml_data {
                 XmlData::RECORD(r) => {
diff --git a/server/src/server.rs b/server/src/server.rs
diff --git a/server/src/threads.rs b/server/src/threads.rs
diff --git a/vscode/package.json b/vscode/package.json

Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ impl DefinitionFeature {`
`161`	`161`	`let document = roxmltree::Document::parse(&data);`
`162`	`162`	`if let Ok(document) = document {`
`163`	`163`	`let root = document.root_element();`
`164`		`- let (symbols, _range) = XmlAstUtils::get_symbols(session, file_symbol, root, offset);`
	`164`	`+ let (symbols, _range) = XmlAstUtils::get_symbols(session, file_symbol, root, offset, true);`
`165`	`165`	`if symbols.is_empty() {`
`166`	`166`	`return None;`
`167`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ use std::{cell::RefCell, collections::HashMap, ops::Range, rc::Rc};`
`2`	`2`
`3`	`3`	`use roxmltree::Node;`
`4`	`4`
`5`		`-use crate::{constants::OYarn, core::{evaluation::ContextValue, symbols::symbol::Symbol, xml_data::XmlData}, threads::SessionInfo, Sy, S};`
	`5`	`+use crate::{constants::OYarn, core::{evaluation::ContextValue, symbols::{module_symbol::ModuleSymbol, symbol::Symbol}, xml_data::XmlData}, threads::SessionInfo, Sy, S};`
`6`	`6`
`7`	`7`	`pub enum XmlAstResult {`
`8`	`8`	`SYMBOL(Rc<RefCell<Symbol>>),`
`@@ -29,61 +29,65 @@ pub struct XmlAstUtils {}`
`29`	`29`
`30`	`30`	`impl XmlAstUtils {`
`31`	`31`
`32`		`- pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, root: roxmltree::Node, offset: usize) -> (Vec<XmlAstResult>, Option<Range<usize>>) {`
	`32`	`+ pub fn get_symbols(session: &mut SessionInfo, file_symbol: &Rc<RefCell<Symbol>>, root: roxmltree::Node, offset: usize, on_dep_only: bool) -> (Vec<XmlAstResult>, Option<Range<usize>>) {`
`33`	`33`	`let mut results = (vec![], None);`
`34`	`34`	`let from_module = file_symbol.borrow().find_module();`
`35`	`35`	`let mut context_xml = HashMap::new();`
`36`	`36`	`for node in root.children() {`
`37`		`- XmlAstUtils::visit_node(session, &node, offset, from_module.clone(), &mut context_xml, &mut results);`
	`37`	`+ XmlAstUtils::visit_node(session, &node, offset, from_module.clone(), &mut context_xml, &mut results, on_dep_only);`
`38`	`38`	`}`
`39`	`39`	`results`
`40`	`40`	`}`
`41`	`41`
`42`		`- fn visit_node(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {`
	`42`	`+ fn visit_node(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {`
`43`	`43`	`if node.is_element() {`
`44`	`44`	`match node.tag_name().name() {`
`45`	`45`	`"record" => {`
`46`		`- XmlAstUtils::visit_record(session, &node, offset, from_module.clone(), ctxt, results);`
	`46`	`+ XmlAstUtils::visit_record(session, &node, offset, from_module.clone(), ctxt, results, on_dep_only);`
`47`	`47`	`}`
`48`	`48`	`"field" => {`
`49`		`- XmlAstUtils::visit_field(session, &node, offset, from_module.clone(), ctxt, results);`
	`49`	`+ XmlAstUtils::visit_field(session, &node, offset, from_module.clone(), ctxt, results, on_dep_only);`
`50`	`50`	`}`
`51`	`51`	`_ => {`
`52`	`52`	`for child in node.children() {`
`53`		`- XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results);`
	`53`	`+ XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results, on_dep_only);`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`	`} else if node.is_text() {`
`58`		`- XmlAstUtils::visit_text(session, &node, offset, from_module, ctxt, results);`
	`58`	`+ XmlAstUtils::visit_text(session, &node, offset, from_module, ctxt, results, on_dep_only);`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`62`		`- fn visit_record(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {`
	`62`	`+ fn visit_record(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {`
`63`	`63`	`for attr in node.attributes() {`
`64`	`64`	`if attr.name() == "model" {`
`65`	`65`	`let model_name = attr.value().to_string();`
`66`	`66`	`ctxt.insert(S!("record_model"), ContextValue::STRING(model_name.clone()));`
`67`	`67`	`if attr.range_value().start <= offset && attr.range_value().end >= offset {`
`68`	`68`	`if let Some(model) = session.sync_odoo.models.get(&Sy!(model_name)).cloned() {`
`69`		`- results.0.extend(model.borrow().all_symbols(session, from_module.clone(), false).iter().filter(\|s\| s.1.is_none()).map(\|s\| XmlAstResult::SYMBOL(s.0.clone())));`
	`69`	`+ let from_module = match on_dep_only {`
	`70`	`+ true => from_module.clone(),`
	`71`	`+ false => None,`
	`72`	`+ };`
	`73`	`+ results.0.extend(model.borrow().all_symbols(session, from_module, false).iter().filter(\|s\| s.1.is_none()).map(\|s\| XmlAstResult::SYMBOL(s.0.clone())));`
`70`	`74`	`results.1 = Some(attr.range_value());`
`71`	`75`	`}`
`72`	`76`	`}`
`73`	`77`	`} else if attr.name() == "id" {`
`74`	`78`	`if attr.range_value().start <= offset && attr.range_value().end >= offset {`
`75`		`- XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results);`
	`79`	`+ XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results, on_dep_only);`
`76`	`80`	`results.1 = Some(attr.range_value());`
`77`	`81`	`}`
`78`	`82`	`}`
`79`	`83`	`}`
`80`	`84`	`for child in node.children() {`
`81`		`- XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results);`
	`85`	`+ XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results, on_dep_only);`
`82`	`86`	`}`
`83`	`87`	`ctxt.remove(&S!("record_model"));`
`84`	`88`	`}`
`85`	`89`
`86`		`- fn visit_field(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {`
	`90`	`+ fn visit_field(session: &mut SessionInfo<'_>, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {`
`87`	`91`	`for attr in node.attributes() {`
`88`	`92`	`if attr.name() == "name" {`
`89`	`93`	`ctxt.insert(S!("field_name"), ContextValue::STRING(attr.value().to_string()));`
`@@ -93,7 +97,11 @@ impl XmlAstUtils {`
`93`	`97`	`continue;`
`94`	`98`	`}`
`95`	`99`	`if let Some(model) = session.sync_odoo.models.get(&Sy!(model_name)).cloned() {`
`96`		`- for symbol in model.borrow().all_symbols(session, from_module.clone(), true) {`
	`100`	`+ let from_module = match on_dep_only {`
	`101`	`+ true => from_module.clone(),`
	`102`	`+ false => None,`
	`103`	`+ };`
	`104`	`+ for symbol in model.borrow().all_symbols(session, from_module, true) {`
`97`	`105`	`if symbol.1.is_none() {`
`98`	`106`	`let content = symbol.0.borrow().get_content_symbol(attr.value(), u32::MAX);`
`99`	`107`	`for symbol in content.symbols.iter() {`
`@@ -113,19 +121,19 @@ impl XmlAstUtils {`
`113`	`121`	`}`
`114`	`122`	`}`
`115`	`123`	`if field_name == "inherit_id" {`
`116`		`- XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results);`
	`124`	`+ XmlAstUtils::add_xml_id_result(session, attr.value(), &from_module.as_ref().unwrap(), attr.range_value(), results, on_dep_only);`
`117`	`125`	`results.1 = Some(attr.range_value());`
`118`	`126`	`}`
`119`	`127`	`}`
`120`	`128`	`}`
`121`	`129`	`}`
`122`	`130`	`for child in node.children() {`
`123`		`- XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results);`
	`131`	`+ XmlAstUtils::visit_node(session, &child, offset, from_module.clone(), ctxt, results, on_dep_only);`
`124`	`132`	`}`
`125`	`133`	`ctxt.remove(&S!("field_name"));`
`126`	`134`	`}`
`127`	`135`
`128`		`- fn visit_text(session: &mut SessionInfo, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {`
	`136`	`+ fn visit_text(session: &mut SessionInfo, node: &Node, offset: usize, from_module: Option<Rc<RefCell<Symbol>>>, ctxt: &mut HashMap<String, ContextValue>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {`
`129`	`137`	`if node.range().start <= offset && node.range().end >= offset {`
`130`	`138`	`let model = ctxt.get(&S!("record_model")).cloned().unwrap_or(ContextValue::STRING(S!(""))).as_string();`
`131`	`139`	`let field = ctxt.get(&S!("field_name")).cloned().unwrap_or(ContextValue::STRING(S!(""))).as_string();`
`@@ -135,16 +143,34 @@ impl XmlAstUtils {`
`135`	`143`	`if model == "ir.ui.view" {`
`136`	`144`	`if field == "model" {`
`137`	`145`	`if let Some(model) = session.sync_odoo.models.get(node.text().unwrap()).cloned() {`
`138`		`- results.0.extend(model.borrow().all_symbols(session, from_module.clone(), false).iter().filter(\|s\| s.1.is_none()).map(\|s\| XmlAstResult::SYMBOL(s.0.clone())));`
	`146`	`+ let from_module = match on_dep_only {`
	`147`	`+ true => from_module.clone(),`
	`148`	`+ false => None,`
	`149`	`+ };`
	`150`	`+ results.0.extend(model.borrow().all_symbols(session, from_module, false).iter().filter(\|s\| s.1.is_none()).map(\|s\| XmlAstResult::SYMBOL(s.0.clone())));`
`139`	`151`	`results.1 = Some(node.range());`
`140`	`152`	`}`
`141`	`153`	`}`
`142`	`154`	`}`
`143`	`155`	`}`
`144`	`156`	`}`
`145`	`157`
`146`		`- fn add_xml_id_result(session: &mut SessionInfo, xml_id: &str, file_symbol: &Rc<RefCell<Symbol>>, range: Range<usize>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>)) {`
`147`		`- let xml_ids = session.sync_odoo.get_xml_ids(file_symbol, xml_id, &range, &mut vec![]);`
	`158`	`+ fn add_xml_id_result(session: &mut SessionInfo, xml_id: &str, file_symbol: &Rc<RefCell<Symbol>>, range: Range<usize>, results: &mut (Vec<XmlAstResult>, Option<Range<usize>>), on_dep_only: bool) {`
	`159`	`+ let mut xml_ids = session.sync_odoo.get_xml_ids(file_symbol, xml_id, &range, &mut vec![]);`
	`160`	`+ if on_dep_only {`
	`161`	`+ xml_ids = xml_ids.into_iter().filter(\|x\|`
	`162`	`+ {`
	`163`	`+ let file = x.get_xml_file_symbol();`
	`164`	`+ if let Some(file) = file {`
	`165`	`+ let module = file.borrow().find_module();`
	`166`	`+ if let Some(module) = module {`
	`167`	`+ return ModuleSymbol::is_in_deps(session, &file_symbol.borrow().find_module().unwrap(), module.borrow().name());`
	`168`	`+ }`
	`169`	`+ }`
	`170`	`+ return false;`
	`171`	`+ }`
	`172`	`+ ).collect::<Vec<_>>();`
	`173`	`+ }`
`148`	`174`	`for xml_data in xml_ids.iter() {`
`149`	`175`	`match xml_data {`
`150`	`176`	`XmlData::RECORD(r) => {`