[IMP] validate inverse_name reverse model name

Author: mmahrouss

server/src/core/diagnostic_codes_list.rs

@@ -163,6 +163,10 @@ OLS03021, DiagnosticSetting::Error, "Inverse field {0} does not exist on comodel
  * On a One2many field, the inverse_name should be a field on the comodel that is a Many2one to the current model.
  */
 OLS03022, DiagnosticSetting::Error, "Inverse field is not a Many2one field",
+/**
+ * On a One2many field, the inverse_name should be a field on the comodel that is a Many2one to the current model.
+ */
+OLS03023, DiagnosticSetting::Error, "Inverse field {0} is not pointing to the current model {1}, but rather to {2}",
 /**
 * A __manifest__.py file should be evaluated with a literal_eval to a single dictionary.
 * Do not store any other information in it.

server/src/core/python_validator.rs

@@ -429,7 +429,7 @@ impl PythonValidator {
                             }
                             let Some(field_type) = symbol
                                 .borrow()
-                                .get_member_symbol(session, &S!("type"), None, false, false, false, false)
+                                .get_member_symbol(session, &S!("type"), None, false, false, false, false, false)
                                 .0.first()
                                 .and_then(|field_type_var| field_type_var.borrow().evaluations().cloned())
                                 .and_then(|evals| evals.first().cloned())
@@ -452,7 +452,7 @@ impl PythonValidator {
                                     };
                                     let found = related_field_class_sym
                                         .borrow()
-                                        .get_member_symbol(session, &S!("type"), None, false, false, false, false)
+                                        .get_member_symbol(session, &S!("type"), None, false, false, false, false, false)
                                         .0.first()
                                         .and_then(|field_type_var| field_type_var.borrow().evaluations().cloned())
                                         .and_then(|evals| evals.first().cloned())
@@ -574,7 +574,42 @@ impl PythonValidator {
                                     ..diagnostic_base.clone()
                                 });
                             }
-
+                        } else {
+                            // Check if we have a many2one field pointing to the comodel with another name than the current model
+                            let mut comodel_eval_weaks = Vec::new();
+                            for sym in symbols.iter() {
+                                let sym_ref = sym.borrow();
+                                let evals = sym_ref.evaluations().as_ref().unwrap().iter();
+                                for eval in evals {
+                                    let followed = Symbol::follow_ref(
+                                        &eval.symbol.get_symbol(session, &mut None, &mut vec![], None),
+                                        session,
+                                        &mut None,
+                                        true,
+                                        false,
+                                        None,
+                                    );
+                                    comodel_eval_weaks.extend(followed);
+                                }
+                            }
+                            for comodel_eval_weak in comodel_eval_weaks {
+                                let Some(model_name) = comodel_eval_weak.as_weak().context.get(&S!("comodel_name")).map(|ctx_val| ctx_val.as_string()) else {
+                                    continue;
+                                };
+                                if model_name == model_data.name.to_string() { // valid
+                                    continue;
+                                }
+                                let Some(arg_range) = eval_weak.as_weak().context.get(&format!("inverse_name_arg_range")).map(|ctx_val| ctx_val.as_text_range()) else {
+                                    continue;
+                                };
+                                if let Some(diagnostic_base) = create_diagnostic(&session, DiagnosticCode::OLS03023, &[&inverse_name, &model_data.name, &model_name]) {
+                                    self.diagnostics.push(Diagnostic {
+                                        range: Range::new(Position::new(arg_range.start().to_u32(), 0), Position::new(arg_range.end().to_u32(), 0)),
+                                        ..diagnostic_base.clone()
+                                    });
+                                    break;
+                                }
+                            }
                         }
                     }
                 }

server/src/core/symbols/symbol.rs

@@ -2619,6 +2619,29 @@ impl Symbol {
         }
     }
 
+    pub fn is_method(&self, session: &mut SessionInfo) -> bool {
+        match self.typ() {
+            SymType::FUNCTION => true,
+            SymType::VARIABLE => {
+                if let Some(evals) = self.evaluations().as_ref() {
+                    for eval in evals.iter() {
+                        let symbol = eval.symbol.get_symbol(session, &mut None,  &mut vec![], None);
+                        let eval_weaks = Symbol::follow_ref(&symbol, session, &mut None, true, false, None);
+                        for eval_weak in eval_weaks.iter() {
+                            if let Some(symbol) = eval_weak.upgrade_weak() {
+                                if symbol.borrow().typ() == SymType::FUNCTION {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+                false
+            },
+            _ => false,
+        }
+    }
+
     pub fn is_inheriting_from_field(&self, session: &mut SessionInfo) -> bool {
         // if not class return false
         if !matches!(self.typ(), SymType::CLASS) {
@@ -2812,7 +2835,7 @@ impl Symbol {
                 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();
+                content_syms = content_syms.iter().filter(|x| x.borrow().is_method(session)).cloned().collect();
             }
             if !content_syms.is_empty() {
                 if all {

server/src/features/completion.rs

@@ -790,7 +790,7 @@ fn complete_string_literal(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>>
                 };
                 let main_syms = model.borrow().get_main_symbols(session, current_module.clone());
                 main_syms.iter().for_each(|model_sym| {
-                    add_model_attributes(session, &mut items, current_module.clone(), model_sym.clone(), false, true, false, expr_string_literal.value.to_str(), &Some(S!("Many2one")))
+                    add_model_attributes(session, &mut items, current_module.clone(), model_sym.clone(), false, true, false, expr_string_literal.value.to_str(), &Some(Sy!("Many2one")))
                 });
             },
             ExpectedType::CLASS(_) => {},

server/src/features/definition.rs

@@ -158,10 +158,10 @@ impl DefinitionFeature {
             return  false;
         };
         let Some(call_expr) = call_expr else { return false };
-        let compute_symbols = FeaturesUtils::find_field_symbols(
+        let method_symbols = FeaturesUtils::find_kwarg_methods_symbols(
             session, Symbol::get_scope_symbol(file_symbol.clone(), offset as u32, false), file_symbol.borrow().find_module(), &value, call_expr, &offset
         );
-        compute_symbols.iter().for_each(|field|{
+        method_symbols.iter().for_each(|field|{
             if let Some(file_sym) = field.borrow().get_file().and_then(|file_sym_weak| file_sym_weak.upgrade()){
                 let path = file_sym.borrow().paths()[0].clone();
                 let range = session.sync_odoo.get_file_mgr().borrow().text_range_to_range(session, &path, &field.borrow().range());
@@ -173,7 +173,7 @@ impl DefinitionFeature {
                 });
             }
         });
-        compute_symbols.len() > 0
+        method_symbols.len() > 0
     }
 
     pub fn add_display_name_compute_methods(session: &mut SessionInfo, links: &mut Vec<LocationLink>, expr: &ExprOrIdent, file_symbol: &Rc<RefCell<Symbol>>, offset: usize) {
@@ -191,7 +191,7 @@ impl DefinitionFeature {
             let Some(symbol) = eval_ptr.upgrade_weak() else {
                 return  vec![];
             };
-            symbol.borrow().get_member_symbol(session, &S!("_compute_display_name"), maybe_module.clone(), false, false, true, false).0
+            symbol.borrow().get_member_symbol(session, &S!("_compute_display_name"), maybe_module.clone(), false, false, true, true, false).0
         }).collect::<Vec<_>>();
         for symbol in symbols {
             if let Some(file) = symbol.borrow().get_file() {

server/src/features/features_utils.rs

@@ -45,7 +45,7 @@ struct InferredType {
 pub struct FeaturesUtils {}
 
 impl FeaturesUtils {
-    pub fn find_field_symbols(
+    pub fn find_kwarg_methods_symbols(
         session: &mut SessionInfo,
         scope: Rc<RefCell<Symbol>>,
         from_module: Option<Rc<RefCell<Symbol>>>,
@@ -147,7 +147,7 @@ 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, false,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,
@@ -342,9 +342,9 @@ impl FeaturesUtils {
         if string_domain_fields_syms.len() >= 1 {
             return string_domain_fields_syms.into_iter().map(|(sym, _)| sym).collect();
         }
-        let compute_kwarg_syms = FeaturesUtils::find_field_symbols(session, scope.clone(), from_module.clone(),  string_val, call_expr, &offset);
-        if compute_kwarg_syms.len() >= 1{
-            return compute_kwarg_syms;
+        let kwarg_syms = FeaturesUtils::find_kwarg_methods_symbols(session, scope.clone(), from_module.clone(),  string_val, call_expr, &offset);
+        if kwarg_syms.len() >= 1{
+            return kwarg_syms;
         }
         vec![]
     }