[IMP] server: detect "delegate=True" for inherits in models

fda-odoo · fda-odoo · commit 8adfe8b0b1d6 · 2025-08-06T17:46:33.000+02:00
diff --git a/server/src/core/evaluation.rs b/server/src/core/evaluation.rs
@@ -612,6 +612,39 @@ impl Evaluation {
         (None, value.diagnostics)
     }
 
+    /* Given an Expr, try to return the represented Boolean. None if it can't be achieved */
+    pub fn expr_to_bool(session: &mut SessionInfo, ast: &Expr, parent: Rc<RefCell<Symbol>>, max_infer: &TextSize, diagnostics: &mut Vec<Diagnostic>) -> (Option<bool>, Vec<Diagnostic>) {
+        let from_module;
+        if let Some(module) = parent.borrow().find_module() {
+            from_module = ContextValue::MODULE(Rc::downgrade(&module));
+        } else {
+            from_module = ContextValue::BOOLEAN(false);
+        }
+        let mut context: Option<Context> = Some(HashMap::from([
+            (S!("module"), from_module),
+            (S!("range"), ContextValue::RANGE(ast.range()))
+        ]));
+        let value = Evaluation::analyze_ast(session, &ExprOrIdent::Expr(ast), parent, max_infer, &mut context, &mut vec![]);
+        if value.evaluations.len() == 1 { //only handle strict evaluations
+            let eval = &value.evaluations[0];
+            let v = eval.follow_ref_and_get_value(session, &mut None, diagnostics);
+            if let Some(v) = v {
+                match v {
+                    EvaluationValue::CONSTANT(v) => {
+                        match v {
+                            Expr::BooleanLiteral(s) => {
+                                return (Some(s.value), value.diagnostics);
+                            },
+                            _ => {}
+                        }
+                    },
+                    _ => {}
+                }
+            }
+        }
+        (None, value.diagnostics)
+    }
+
 
     /**
     analyze_ast will extract all known information about an ast:
diff --git a/server/src/core/model.rs b/server/src/core/model.rs
@@ -208,7 +208,7 @@ impl Model {
             } else {
                 symbols.push((s.clone(), None));
             }
-            if with_inheritance {
+            if with_inheritance { //TODO wrong, should be recursive
                 let inherited_models = s.borrow().as_class_sym()._model.as_ref().unwrap().inherit.clone();
                 for inherited_model in inherited_models.iter() {
                     if !seen_inherited_models.contains(inherited_model) {
diff --git a/server/src/core/python_arch_eval_hooks.rs b/server/src/core/python_arch_eval_hooks.rs
@@ -1,5 +1,6 @@
 use std::cmp::Ordering;
 use std::collections::HashMap;
+use std::ops::Index;
 use std::rc::Rc;
 use std::rc::Weak;
 use std::cell::RefCell;
@@ -866,6 +867,7 @@ impl PythonArchEvalHooks {
             "comodel_name",
             "related",
             "compute",
+            "delegate",
         ];
         contexts_to_add.extend(
             context_arguments.into_iter()
@@ -880,6 +882,11 @@ impl PythonArchEvalHooks {
             if let Some(related_string) = maybe_related_string {
                 context.insert(S!(arg_name), ContextValue::STRING(related_string.to_string()));
                 context.insert(format!("{arg_name}_arg_range"), ContextValue::RANGE(arg_range.clone()));
+            } else {
+                let maybe_boolean = Evaluation::expr_to_bool(session, field_name_expr, parent.clone(), &parameters.range.start(), &mut vec![]).0;
+                if let Some(boolean) = maybe_boolean {
+                    context.insert(S!(arg_name), ContextValue::BOOLEAN(boolean));
+                }
             }
         }
 
diff --git a/server/src/core/python_odoo_builder.rs b/server/src/core/python_odoo_builder.rs
@@ -1,5 +1,5 @@
 use std::cmp::Ordering;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 use std::cell::RefCell;
 use ruff_python_ast::Expr;
@@ -191,6 +191,33 @@ impl PythonOdooBuilder {
                 }
             }
         }
+        drop(_inherits);
+        drop(symbol);
+        //Add inherits from delegate=True from fields
+        let mut all_fields = HashMap::new();
+        Symbol::all_members(&self.symbol, session, &mut all_fields, false, true, false, None, &mut None, false);
+        for (field_name, symbols) in all_fields.iter() {
+            for (symbol, _deps) in symbols.iter() {
+                if let Some(evals) = symbol.borrow().evaluations() {
+                    for eval in evals.iter() {
+                        let symbol_weak = eval.symbol.get_symbol_as_weak(session, &mut None, diagnostics, self.symbol.borrow().get_file().unwrap().upgrade());
+                        if let Some(eval_symbol) = symbol_weak.weak.upgrade() {
+                            if eval_symbol.borrow().name() == &Sy!("Many2one") {
+                                let context = &symbol_weak.context;
+                                if let Some(delegate) = context.get("delegate") {
+                                    if delegate.as_bool() == true {
+                                        if let Some(comodel) = context.get("comodel_name") {
+                                            let comodel_name = oyarn!("{}", comodel.as_string());
+                                            self.symbol.borrow_mut().as_class_sym_mut()._model.as_mut().unwrap().inherits.push((comodel_name, field_name.clone()));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
 
     fn _get_attribute(session: &mut SessionInfo, loc_sym: &mut Symbol, attr: &String, diagnostics: &mut Vec<Diagnostic>) -> Option<EvaluationValue> {
diff --git a/server/src/core/python_validator.rs b/server/src/core/python_validator.rs
@@ -5,8 +5,9 @@ use tracing::{trace, warn};
 use std::rc::Rc;
 use std::cell::RefCell;
 use std::path::PathBuf;
-use lsp_types::{Diagnostic, Position, Range};
+use lsp_types::{Diagnostic, DiagnosticSeverity, NumberOrString, Position, Range};
 use crate::core::diagnostics::{create_diagnostic, DiagnosticCode};
+use crate::core::evaluation::ContextValue;
 use crate::{constants::*, oyarn, Sy};
 use crate::core::symbols::symbol::Symbol;
 use crate::core::odoo::SyncOdoo;
@@ -389,7 +390,7 @@ impl PythonValidator {
                     if !symbol.borrow().is_field_class(session){
                         continue;
                     }
-                    if let Some(related_field_name) = eval_weak.as_weak().context.get(&S!("related")).map(|ctx_val| ctx_val.as_string()) {
+                    if let Some(related_field_name) = eval_weak.as_weak().context.get(&S!("related")).filter(|val| matches!(val, ContextValue::STRING(s))).map(|ctx_val| ctx_val.as_string()) {
                         let Some(special_arg_range) = eval_weak.as_weak().context.get(&S!("related_arg_range")).map(|ctx_val| ctx_val.as_text_range()) else {
                             continue;
                         };
diff --git a/server/src/core/symbols/symbol.rs b/server/src/core/symbols/symbol.rs
@@ -2259,7 +2259,7 @@ impl Symbol {
         iter.into_iter()
     }
 
-    //store in result all available members for self: sub symbols, base class elements and models symbols
+    //store in result all available members for symbol: sub symbols, base class elements and models symbols
     //TODO is order right of Vec in HashMap? if we take first or last in it, do we have the last effective value?
     pub fn all_members(symbol: &Rc<RefCell<Symbol>>, session: &mut SessionInfo, result: &mut HashMap<OYarn, Vec<(Rc<RefCell<Symbol>>, Option<OYarn>)>>, with_co_models: bool, only_fields: bool, only_methods: bool, from_module: Option<Rc<RefCell<Symbol>>>, acc: &mut Option<HashSet<Tree>>, is_super: bool) {
         if acc.is_none() {
@@ -2279,7 +2279,7 @@ impl Symbol {
                         if only_fields && !symbol.borrow().is_field(session){
                             continue;
                         }
-                        if only_methods && symbol.borrow().typ() != SymType::FUNCTION{
+                        if only_methods && symbol.borrow().typ() != SymType::FUNCTION {
                             continue;
                         }
                         let name = symbol.borrow().name().clone();
@@ -2311,6 +2311,25 @@ impl Symbol {
                                             result.insert(name.clone(), vec![(s, Some(model_sym.borrow().name().clone()))]);
                                         }
                                     }
+                                    //add fields from _inherits
+                                    if let Some(model_data) = model_sym.borrow().as_class_sym()._model.as_ref() {
+                                        for (inherits_model, inherits_field) in model_data.inherits.iter() {
+                                            let inherits_model_sym = session.sync_odoo.models.get(inherits_model).cloned();
+                                            if let Some(inherits_model_sym) = inherits_model_sym {
+                                                for (model_symbol, deps) in inherits_model_sym.borrow().all_symbols(session, from_module.clone(), true).iter().filter(|(x, deps)| deps.is_none()) {
+                                                    for (field_name, field_symbols) in Symbol::all_fields(&model_symbol, session, from_module.clone()) {
+                                                        for (s, deps) in field_symbols.iter().filter(|(x, deps)| deps.is_none()) {
+                                                            if let Some(vec) = result.get_mut(&field_name) {
+                                                                vec.push((s.clone(), Some(model_sym.borrow().name().clone())));
+                                                            } else {
+                                                                result.insert(field_name.clone(), vec![(s.clone(), Some(model_sym.borrow().name().clone()))]);
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -2319,6 +2338,7 @@ impl Symbol {
                 let bases = symbol.borrow().as_class_sym().bases.clone();
                 for base in bases.iter() {
                     //no comodel as we will search for co-model from original class (what about overrided _name?)
+                    //TODO what about base of co-models classes?
                     if let Some(base) = base.upgrade() {
                         Symbol::all_members(&base, session, result, false, only_fields, only_methods, from_module.clone(), acc, false);
                     }
@@ -2339,6 +2359,9 @@ impl Symbol {
             }
         }
     }
+
+
+
     /* return the Symbol (class, function or file) the closest to the given offset */
     pub fn get_scope_symbol(file_symbol: Rc<RefCell<Symbol>>, offset: u32, is_param: bool) -> Rc<RefCell<Symbol>> {
         let mut result = file_symbol.clone();
@@ -2610,6 +2633,12 @@ impl Symbol {
         false
     }
 
+    pub fn all_fields(symbol: &Rc<RefCell<Symbol>>, session: &mut SessionInfo, from_module: Option<Rc<RefCell<Symbol>>>) -> HashMap<OYarn, Vec<(Rc<RefCell<Symbol>>, Option<OYarn>)>> {
+        let mut all_fields = HashMap::new();
+        Symbol::all_members(symbol, session, &mut all_fields, true, true, false, from_module.clone(), &mut None, false);
+        all_fields
+    }
+
     /* similar to get_symbol: will return the symbol that is under this one with the specified name.
     However, if the symbol is a class or a model, it will search in the base class or in comodel classes
     if not all, it will return the first found. If all, the all found symbols are returned, but the first one
diff --git a/server/src/core/xml_validation.rs b/server/src/core/xml_validation.rs
@@ -88,8 +88,7 @@ impl XmlValidator {
         for main_sym in main_symbols.iter() {
             dependencies.push(main_sym.borrow().get_file().unwrap().upgrade().unwrap());
         }
-        let mut all_fields = HashMap::new();
-        Symbol::all_members(&main_symbols[0], session, &mut all_fields, true, true, false, Some(module.clone()), &mut None, false);
+        let all_fields = Symbol::all_fields(&main_symbols[0], session, Some(module.clone()));
         for field in &xml_data_record.fields {
             let declared_field = all_fields.get(&field.name);
             if let Some(declared_field) = declared_field {

Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ impl Model {`
`208`	`208`	`} else {`
`209`	`209`	`symbols.push((s.clone(), None));`
`210`	`210`	`}`
`211`		`- if with_inheritance {`
	`211`	`+ if with_inheritance { //TODO wrong, should be recursive`
`212`	`212`	`let inherited_models = s.borrow().as_class_sym()._model.as_ref().unwrap().inherit.clone();`
`213`	`213`	`for inherited_model in inherited_models.iter() {`
`214`	`214`	`if !seen_inherited_models.contains(inherited_model) {`
Original file line number	Diff line number	Diff line change
`@@ -2259,7 +2259,7 @@ impl Symbol {`
`2259`	`2259`	`iter.into_iter()`
`2260`	`2260`	`}`
`2261`	`2261`
`2262`		`- //store in result all available members for self: sub symbols, base class elements and models symbols`
	`2262`	`+ //store in result all available members for symbol: sub symbols, base class elements and models symbols`
`2263`	`2263`	`//TODO is order right of Vec in HashMap? if we take first or last in it, do we have the last effective value?`
`2264`	`2264`	`pub fn all_members(symbol: &Rc<RefCell<Symbol>>, session: &mut SessionInfo, result: &mut HashMap<OYarn, Vec<(Rc<RefCell<Symbol>>, Option<OYarn>)>>, with_co_models: bool, only_fields: bool, only_methods: bool, from_module: Option<Rc<RefCell<Symbol>>>, acc: &mut Option<HashSet<Tree>>, is_super: bool) {`
`2265`	`2265`	`if acc.is_none() {`
`@@ -2279,7 +2279,7 @@ impl Symbol {`
`2279`	`2279`	`if only_fields && !symbol.borrow().is_field(session){`
`2280`	`2280`	`continue;`
`2281`	`2281`	`}`
`2282`		`- if only_methods && symbol.borrow().typ() != SymType::FUNCTION{`
	`2282`	`+ if only_methods && symbol.borrow().typ() != SymType::FUNCTION {`
`2283`	`2283`	`continue;`
`2284`	`2284`	`}`
`2285`	`2285`	`let name = symbol.borrow().name().clone();`
`@@ -2311,6 +2311,25 @@ impl Symbol {`
`2311`	`2311`	`result.insert(name.clone(), vec![(s, Some(model_sym.borrow().name().clone()))]);`
`2312`	`2312`	`}`
`2313`	`2313`	`}`
	`2314`	`+ //add fields from _inherits`
	`2315`	`+ if let Some(model_data) = model_sym.borrow().as_class_sym()._model.as_ref() {`
	`2316`	`+ for (inherits_model, inherits_field) in model_data.inherits.iter() {`
	`2317`	`+ let inherits_model_sym = session.sync_odoo.models.get(inherits_model).cloned();`
	`2318`	`+ if let Some(inherits_model_sym) = inherits_model_sym {`
	`2319`	`+ for (model_symbol, deps) in inherits_model_sym.borrow().all_symbols(session, from_module.clone(), true).iter().filter(\|(x, deps)\| deps.is_none()) {`
	`2320`	`+ for (field_name, field_symbols) in Symbol::all_fields(&model_symbol, session, from_module.clone()) {`
	`2321`	`+ for (s, deps) in field_symbols.iter().filter(\|(x, deps)\| deps.is_none()) {`
	`2322`	`+ if let Some(vec) = result.get_mut(&field_name) {`
	`2323`	`+ vec.push((s.clone(), Some(model_sym.borrow().name().clone())));`
	`2324`	`+ } else {`
	`2325`	`+ result.insert(field_name.clone(), vec![(s.clone(), Some(model_sym.borrow().name().clone()))]);`
	`2326`	`+ }`
	`2327`	`+ }`
	`2328`	`+ }`
	`2329`	`+ }`
	`2330`	`+ }`
	`2331`	`+ }`
	`2332`	`+ }`
`2314`	`2333`	`}`
`2315`	`2334`	`}`
`2316`	`2335`	`}`
`@@ -2319,6 +2338,7 @@ impl Symbol {`
`2319`	`2338`	`let bases = symbol.borrow().as_class_sym().bases.clone();`
`2320`	`2339`	`for base in bases.iter() {`
`2321`	`2340`	`//no comodel as we will search for co-model from original class (what about overrided _name?)`
	`2341`	`+ //TODO what about base of co-models classes?`
`2322`	`2342`	`if let Some(base) = base.upgrade() {`
`2323`	`2343`	`Symbol::all_members(&base, session, result, false, only_fields, only_methods, from_module.clone(), acc, false);`
`2324`	`2344`	`}`
`@@ -2339,6 +2359,9 @@ impl Symbol {`
`2339`	`2359`	`}`
`2340`	`2360`	`}`
`2341`	`2361`	`}`
	`2362`	`+`
	`2363`	`+`
	`2364`	`+`
`2342`	`2365`	`/* return the Symbol (class, function or file) the closest to the given offset */`
`2343`	`2366`	`pub fn get_scope_symbol(file_symbol: Rc<RefCell<Symbol>>, offset: u32, is_param: bool) -> Rc<RefCell<Symbol>> {`
`2344`	`2367`	`let mut result = file_symbol.clone();`
`@@ -2610,6 +2633,12 @@ impl Symbol {`
`2610`	`2633`	`false`
`2611`	`2634`	`}`
`2612`	`2635`
	`2636`	`+ pub fn all_fields(symbol: &Rc<RefCell<Symbol>>, session: &mut SessionInfo, from_module: Option<Rc<RefCell<Symbol>>>) -> HashMap<OYarn, Vec<(Rc<RefCell<Symbol>>, Option<OYarn>)>> {`
	`2637`	`+ let mut all_fields = HashMap::new();`
	`2638`	`+ Symbol::all_members(symbol, session, &mut all_fields, true, true, false, from_module.clone(), &mut None, false);`
	`2639`	`+ all_fields`
	`2640`	`+ }`
	`2641`	`+`
`2613`	`2642`	`/* similar to get_symbol: will return the symbol that is under this one with the specified name.`
`2614`	`2643`	`However, if the symbol is a class or a model, it will search in the base class or in comodel classes`
`2615`	`2644`	`if not all, it will return the first found. If all, the all found symbols are returned, but the first one`