[IMP] hover and gotodef for inverse_name

Author: mmahrouss

server/src/core/evaluation.rs

@@ -894,7 +894,7 @@ impl Evaluation {
                                     }
                                 }
                                 //1: find __init__ method
-                                let init = base_sym.borrow().get_member_symbol(session, &S!("__init__"), module.clone(), true, false, false, false);
+                                let init = base_sym.borrow().get_member_symbol(session, &S!("__init__"), module.clone(), true, false, false, false, false);
                                 let mut found_hook = false;
                                 if let Some(init) = init.0.first() {
                                     let init_sym_file = init.borrow().get_file().as_ref().unwrap().upgrade().unwrap().clone();
@@ -1052,7 +1052,7 @@ impl Evaluation {
                                 }
                             }
                             let is_super = ibase.is_weak() && ibase.as_weak().is_super;
-                            let (attributes, mut attributes_diagnostics) = base_loc.borrow().get_member_symbol(session, &expr.attr.to_string(), module.clone(), false, false, true, is_super);
+                            let (attributes, mut attributes_diagnostics) = base_loc.borrow().get_member_symbol(session, &expr.attr.to_string(), module.clone(), false, false, false, true, is_super);
                             for diagnostic in attributes_diagnostics.iter_mut(){
                                 diagnostic.range = FileMgr::textRange_to_temporary_Range(&expr.range())
                             }
@@ -1278,7 +1278,7 @@ impl Evaluation {
                     for base_eval_ptr in base_eval_ptrs.iter() {
                         let EvaluationSymbolPtr::WEAK(base_sym_weak_eval) = base_eval_ptr else {continue};
                         let Some(base_sym) = base_sym_weak_eval.weak.upgrade() else {continue};
-                        let (operator_functions, diags) = base_sym.borrow().get_member_symbol(session, &S!(method), module.clone(), true, false, false, false);
+                        let (operator_functions, diags) = base_sym.borrow().get_member_symbol(session, &S!(method), module.clone(), true, false, true, false, false);
                         diagnostics.extend(diags);
                         for operator_function in operator_functions.into_iter(){
                             for eval in operator_function.borrow().evaluations().unwrap_or(&vec![]).iter() {
@@ -1582,6 +1582,7 @@ impl Evaluation {
                                 false,
                                 true,
                                 false,
+                                false,
                                 false);
                             if symbols.is_empty() {
                                 if let Some(diagnostic_base) = create_diagnostic(session, DiagnosticCode::OLS03011, &[&name, &object.borrow().name()]) {

server/src/core/python_arch_eval.rs

@@ -819,7 +819,7 @@ impl PythonArchEval {
                     let symbol_type_rc = symbol_eval[0].upgrade_weak().unwrap();
                     let symbol_type = symbol_type_rc.borrow();
                     if symbol_type.typ() == SymType::CLASS {
-                        let (iter, _) = symbol_type.get_member_symbol(session, &S!("__iter__"), None, true, false, false, false);
+                        let (iter, _) = symbol_type.get_member_symbol(session, &S!("__iter__"), None, true, false, false, false, false);
                         if iter.len() == 1 {
                             SyncOdoo::build_now(session, &iter[0], BuildSteps::ARCH_EVAL);
                             SyncOdoo::build_now(session, &iter[0], BuildSteps::VALIDATION);
@@ -1049,6 +1049,7 @@ impl PythonArchEval {
                 from_module.clone(),
                 false,
                 true,
+                false,
                 true,
                 false);
             if ix == split_expr.len() - 1 {

server/src/core/python_arch_eval_hooks.rs

@@ -1155,7 +1155,7 @@ impl PythonArchEvalHooks {
         for arg in arguments.args.iter() {
             let Expr::StringLiteral(expr) = arg else {return diagnostics};
             let field_name = expr.value.to_string();
-            let (syms, _) = class_sym.borrow().get_member_symbol(session, &field_name, from_module.clone(), false, false, true, false);
+            let (syms, _) = class_sym.borrow().get_member_symbol(session, &field_name, from_module.clone(), false, true, false, true, false);
             if syms.is_empty(){
                 if let Some(diagnostic) = create_diagnostic(session, DiagnosticCode::OLS03014, &[&field_name, &model_name]) {
                     diagnostics.push(Diagnostic {

server/src/core/python_odoo_builder.rs

@@ -203,7 +203,7 @@ impl PythonOdooBuilder {
     }
 
     fn _get_attribute(session: &mut SessionInfo, loc_sym: &mut Symbol, attr: &String, diagnostics: &mut Vec<Diagnostic>) -> Option<EvaluationValue> {
-        let (attr_sym, _) = loc_sym.get_member_symbol(session, attr, None, true, false, false, false);
+        let (attr_sym, _) = loc_sym.get_member_symbol(session, attr, None, true, false, false, false, false);
         if attr_sym.len() == 0 {
             return None;
         }

server/src/core/python_validator.rs

@@ -521,9 +521,10 @@ impl PythonValidator {
                             false,
                             false,
                             true,
+                            true,
                             false
                         );
-                        let method_found = symbols.iter().any(|symbol| symbol.borrow().typ() == SymType::FUNCTION);
+                        let method_found = !symbols.is_empty();
                         if !method_found{
                             let Some(arg_range) = eval_weak.as_weak().context.get(&format!("{special_fn_field_name}_arg_range")).map(|ctx_val| ctx_val.as_text_range()) else {
                                 continue;

server/src/core/symbols/symbol.rs

@@ -2129,7 +2129,7 @@ impl Symbol {
                 if let Some(base_attr) = base_attr {
                     let attribute_type_sym = symbol;
                     //TODO shouldn't we set the from_module in the call to get_member_symbol?
-                    let get_method = attribute_type_sym.get_member_symbol(session, &S!("__get__"), None, true, false, true, false).0.first().cloned();
+                    let get_method = attribute_type_sym.get_member_symbol(session, &S!("__get__"), None, true, false, false, true, false).0.first().cloned();
                     match get_method {
                         Some(get_method) if (base_attr.borrow().typ() == SymType::CLASS) => {
                             let get_method = get_method.borrow();
@@ -2757,12 +2757,33 @@ impl Symbol {
     if not all, it will return the first found. If all, the all found symbols are returned, but the first one
     is the one that is overriding others.
     :param: from_module: optional, can change the from_module of the given class */
-    pub fn get_member_symbol(&self, session: &mut SessionInfo, name: &String, from_module: Option<Rc<RefCell<Symbol>>>, prevent_comodel: bool, only_fields: bool, all: bool, is_super: bool) -> (Vec<Rc<RefCell<Symbol>>>, Vec<Diagnostic>) {
+    pub fn get_member_symbol(
+        &self,
+        session: &mut SessionInfo,
+        name: &String,
+        from_module: Option<Rc<RefCell<Symbol>>>,
+        prevent_comodel: bool,
+        only_fields: bool,
+        only_methods: bool,
+        all: bool,
+        is_super: bool
+    ) -> (Vec<Rc<RefCell<Symbol>>>, Vec<Diagnostic>) {
         let mut visited_classes: PtrWeakHashSet<Weak<RefCell<Symbol>>> = PtrWeakHashSet::new();
-        return self._get_member_symbol_helper(session, name, from_module, prevent_comodel, only_fields, all, is_super, &mut visited_classes);
+        return self._get_member_symbol_helper(session, name, from_module, prevent_comodel, only_fields, only_methods, all, is_super, &mut visited_classes);
     }
 
-    fn _get_member_symbol_helper(&self, session: &mut SessionInfo, name: &String, from_module: Option<Rc<RefCell<Symbol>>>, prevent_comodel: bool, only_fields: bool, all: bool, is_super: bool, visited_classes: &mut PtrWeakHashSet<Weak<RefCell<Symbol>>>) -> (Vec<Rc<RefCell<Symbol>>>, Vec<Diagnostic>) {
+    fn _get_member_symbol_helper(
+        &self,
+        session: &mut SessionInfo,
+        name: &String,
+        from_module: Option<Rc<RefCell<Symbol>>>,
+        prevent_comodel: bool,
+        only_fields: bool,
+        only_methods: bool,
+        all: bool,
+        is_super: bool,
+        visited_classes: &mut PtrWeakHashSet<Weak<RefCell<Symbol>>>
+    ) -> (Vec<Rc<RefCell<Symbol>>>, Vec<Diagnostic>) {
         let mut result: Vec<Rc<RefCell<Symbol>>> = vec![];
         let mut visited_symbols: PtrWeakHashSet<Weak<RefCell<Symbol>>> = PtrWeakHashSet::new();
         let mut extend_result = |syms: Vec<Rc<RefCell<Symbol>>>| {
@@ -2790,6 +2811,9 @@ impl Symbol {
             if only_fields {
                 content_syms = content_syms.iter().filter(|x| x.borrow().is_field(session)).cloned().collect();
             }
+            if only_methods {
+                content_syms = content_syms.iter().filter(|x| x.borrow().typ() == SymType::FUNCTION).cloned().collect();
+            }
             if !content_syms.is_empty() {
                 if all {
                     extend_result(content_syms);
@@ -2812,7 +2836,7 @@ impl Symbol {
                             continue;
                         }
                         visited_classes.insert(model_symbol.clone());
-                        let (attributs, att_diagnostic) = model_symbol.borrow()._get_member_symbol_helper(session, name, None, true, only_fields, all, false, visited_classes);
+                        let (attributs, att_diagnostic) = model_symbol.borrow()._get_member_symbol_helper(session, name, None, true, only_fields, only_methods, all, false, visited_classes);
                         diagnostics.extend(att_diagnostic);
                         if all {
                             extend_result(attributs);
@@ -2830,7 +2854,7 @@ impl Symbol {
                                 continue;
                             }
                             visited_classes.insert(model_symbol.clone());
-                            let (attributs, att_diagnostic) = model_symbol.borrow()._get_member_symbol_helper(session, name, None, true, true, all, false, visited_classes);
+                            let (attributs, att_diagnostic) = model_symbol.borrow()._get_member_symbol_helper(session, name, None, true, true, only_methods, all, false, visited_classes);
                             diagnostics.extend(att_diagnostic);
                             if all {
                                 extend_result(attributs);
@@ -2854,7 +2878,7 @@ impl Symbol {
                     continue;
                 }
                 visited_classes.insert(base.clone());
-                let (s, s_diagnostic) = base.borrow().get_member_symbol(session, name, from_module.clone(), prevent_comodel, only_fields, all, false);
+                let (s, s_diagnostic) = base.borrow().get_member_symbol(session, name, from_module.clone(), prevent_comodel, only_fields, only_methods, all, false);
                     diagnostics.extend(s_diagnostic);
                 if !s.is_empty() {
                     if all {

server/src/features/completion.rs

@@ -1022,6 +1022,7 @@ fn add_nested_field_names(
                     from_module.clone(),
                     false,
                     true,
+                    false,
                     true,
                     false);
                 if symbols.is_empty() {

server/src/features/features_utils.rs

@@ -59,6 +59,9 @@ impl FeaturesUtils {
             let Some(ref arg_id) = keyword.arg else {
                 return vec![];
             };
+            if arg_id.as_str() == "inverse_name" {
+                return FeaturesUtils::find_inverse_name_field_symbol(session, from_module, field_value, call_expr);
+            }
             if !["compute", "inverse", "search"].contains(&arg_id.as_str()){
                 return vec![];
             }
@@ -81,7 +84,32 @@ impl FeaturesUtils {
         ) {
             return vec![];
         }
-        parent_class.clone().borrow().get_member_symbol(session, field_value, from_module.clone(), false, false, true, false).0
+        parent_class.clone().borrow().get_member_symbol(session, field_value, from_module.clone(), false, false, true, true, false).0
+    }
+
+    fn find_inverse_name_field_symbol(
+        session: &mut SessionInfo,
+        from_module: Option<Rc<RefCell<Symbol>>>,
+        field_value: &String,
+        call_expr: &ExprCall,
+    ) -> Vec<Rc<RefCell<Symbol>>>{
+        let model_name = if let Some(Expr::StringLiteral(expr)) = call_expr.arguments.args.first() {
+            expr.value.to_string()
+        } else {
+            let Some(model_name) = call_expr.arguments.keywords.iter().find(|kw| kw.arg.as_ref().map(|arg| arg.id == "comodel_name").unwrap_or(false))
+                .and_then(|kw| match &kw.value {
+                    Expr::StringLiteral(expr) => Some(expr.value.to_string()),
+                    _ => None
+                }) else {
+                    return vec![];
+                };
+            model_name
+        };
+        let Some(model) = session.sync_odoo.models.get(&oyarn!("{}", model_name)).cloned() else {
+            return vec![];
+        };
+        let main_syms = model.borrow().get_main_symbols(session, from_module.clone());
+        main_syms.iter().flat_map(|main_sym| main_sym.clone().borrow().get_member_symbol(session, field_value, from_module.clone(), false, true, false, true, false).0).collect()
     }
 
     fn find_simple_decorator_field_symbol(
@@ -96,7 +124,7 @@ impl FeaturesUtils {
         if parent_class.borrow().as_class_sym()._model.is_none(){
             return vec![];
         }
-        parent_class.clone().borrow().get_member_symbol(session, field_name, from_module.clone(), false, false, true, false).0
+        parent_class.clone().borrow().get_member_symbol(session, field_name, from_module.clone(), false, true, false, true, false).0
     }
 
     fn find_nested_fields(
@@ -119,14 +147,15 @@ impl FeaturesUtils {
             let range_end = range_start + TextSize::new((name.len() + 1) as u32);
             let cursor_section = TextRange::new(range_start, range_end).contains(TextSize::new(*offset as u32));
             if cursor_section {
-                let fields = parent_object.clone().unwrap().borrow().get_member_symbol(session, &name, from_module.clone(), false, true, true, false).0;
+                let fields = parent_object.clone().unwrap().borrow().get_member_symbol(session, &name, from_module.clone(), false, true, false,true, false).0;
                 return fields.into_iter().map(|f| (f, TextRange::new(range_start, range_end - TextSize::new(1)))).collect();
             } else {
                 let (symbols, _diagnostics) = parent_object.clone().unwrap().borrow().get_member_symbol(session,
                     &name.to_string(),
                     from_module.clone(),
                     false,
                     true,
+                    false,
                     true,
                     false);
                 if symbols.is_empty() {