[FIX] Rewrite delayed queue

Delayed queue is now shorter and more efficient, only doing process_rebuild of validation steps.
Features are now able to rebuild arch and arch_eval step on the fly before answering the request.
This way index is always matching the ropes, and arch is valid too.
Validation is delayed to inactivity period, but it is not blocking requests.
Validation (arch and arch_eval) of functions can be done on the fly too

Author: fda-odoo

server/src/constants.rs

@@ -5,6 +5,8 @@ use core::fmt;
 pub const EXTENSION_NAME: &str = "Odoo";
 pub const EXTENSION_VERSION: &str = "1.0.2";
 
+pub const MAX_WATCHED_FILES_UPDATES_BEFORE_RESTART: u32 = 10;
+
 pub const DEBUG_ODOO_BUILDER: bool = false;
 pub const DEBUG_MEMORY: bool = false;
 pub const DEBUG_THREADS: bool = false;

server/src/core/odoo.rs

@@ -13,7 +13,7 @@ use std::collections::HashMap;
 use std::cell::RefCell;
 use std::ffi::OsStr;
 use std::rc::{Rc, Weak};
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::Instant;
 use lsp_server::ResponseError;
@@ -78,7 +78,7 @@ pub struct SyncOdoo {
     pub models: HashMap<OYarn, Rc<RefCell<Model>>>,
     pub interrupt_rebuild: Arc<AtomicBool>,
     pub terminate_rebuild: Arc<AtomicBool>,
-    pub watched_file_updates: Arc<AtomicU32>,
+    pub watched_file_updates: u32,
     rebuild_arch: PtrWeakHashSet<Weak<RefCell<Symbol>>>,
     rebuild_arch_eval: PtrWeakHashSet<Weak<RefCell<Symbol>>>,
     rebuild_validation: PtrWeakHashSet<Weak<RefCell<Symbol>>>,
@@ -117,7 +117,7 @@ impl SyncOdoo {
             models: HashMap::new(),
             interrupt_rebuild: Arc::new(AtomicBool::new(false)),
             terminate_rebuild: Arc::new(AtomicBool::new(false)),
-            watched_file_updates: Arc::new(AtomicU32::new(0)),
+            watched_file_updates: 0,
             rebuild_arch: PtrWeakHashSet::new(),
             rebuild_arch_eval: PtrWeakHashSet::new(),
             rebuild_validation: PtrWeakHashSet::new(),
@@ -151,7 +151,7 @@ impl SyncOdoo {
         session.sync_odoo.state_init = InitState::NOT_READY;
         session.sync_odoo.load_odoo_addons = true;
         session.sync_odoo.need_rebuild = false;
-        session.sync_odoo.watched_file_updates = Arc::new(AtomicU32::new(0));
+        session.sync_odoo.watched_file_updates = 0;
         //drop all entries, except entries of opened files
         session.sync_odoo.entry_point_mgr.borrow_mut().reset_entry_points(false);
         SyncOdoo::init(session, config);
@@ -297,7 +297,7 @@ impl SyncOdoo {
         }
         let _builtins_rc_symbol = Symbol::create_from_path(session, &builtins_path, disk_dir_builtins[0].clone(), false);
         session.sync_odoo.add_to_rebuild_arch(_builtins_rc_symbol.unwrap());
-        SyncOdoo::process_rebuilds(session)
+        SyncOdoo::process_rebuilds(session, false)
     }
 
     pub fn build_database(session: &mut SessionInfo) {
@@ -402,7 +402,7 @@ impl SyncOdoo {
             _ => panic!("Root symbol is not a package or namespace (> 18.0)")
         }
         session.sync_odoo.has_odoo_main_entry = true; // set it now has we need it to parse base addons
-        if !SyncOdoo::process_rebuilds(session){
+        if !SyncOdoo::process_rebuilds(session, false){
             return false;
         }
         //search common odoo addons path
@@ -477,7 +477,7 @@ impl SyncOdoo {
                 }
             }
         }
-        if !SyncOdoo::process_rebuilds(session){
+        if !SyncOdoo::process_rebuilds(session, false){
             return;
         }
         //println!("{}", self.symbols.as_ref().unwrap().borrow_mut().debug_print_graph());
@@ -601,8 +601,11 @@ impl SyncOdoo {
         session.sync_odoo.must_reload_paths.retain(|x| x.0.upgrade().is_some());
     }
 
-    pub fn process_rebuilds(session: &mut SessionInfo) -> bool {
+    pub fn process_rebuilds(session: &mut SessionInfo, no_validation: bool) -> bool {
         session.sync_odoo.interrupt_rebuild.store(false, Ordering::SeqCst);
+        if session.sync_odoo.watched_file_updates > MAX_WATCHED_FILES_UPDATES_BEFORE_RESTART {
+            return false;
+        }
         SyncOdoo::add_from_self_reload(session);
         session.sync_odoo.import_cache = Some(ImportCache{ modules: HashMap::new(), main_modules: HashMap::new() });
         let mut already_arch_rebuilt: HashSet<Tree> = HashSet::new();
@@ -649,12 +652,18 @@ impl SyncOdoo {
                     continue;
                 }
                 already_validation_rebuilt.insert(tree);
-                if session.sync_odoo.state_init == InitState::ODOO_READY && session.sync_odoo.interrupt_rebuild.load(Ordering::SeqCst) {
-                    session.sync_odoo.interrupt_rebuild.store(false, Ordering::SeqCst);
-                    session.log_message(MessageType::INFO, S!("Rebuild interrupted"));
-                    session.request_delayed_rebuild();
-                    session.sync_odoo.add_to_validations(sym_rc.clone());
-                    return true;
+                if session.sync_odoo.state_init == InitState::ODOO_READY {
+                    let mut no_validation = no_validation;
+                    if session.sync_odoo.interrupt_rebuild.load(Ordering::SeqCst) {
+                        session.sync_odoo.interrupt_rebuild.store(false, Ordering::SeqCst);
+                        session.log_message(MessageType::INFO, S!("Rebuild interrupted"));
+                        no_validation = true;
+                    }
+                    if no_validation {
+                        session.request_delayed_rebuild();
+                        session.sync_odoo.add_to_validations(sym_rc.clone());
+                        return true;
+                    }
                 }
                 let typ = sym_rc.borrow().typ();
                 match typ {
@@ -672,9 +681,11 @@ impl SyncOdoo {
         }
         if session.sync_odoo.need_rebuild {
             session.log_message(MessageType::INFO, S!("Rebuild required. Resetting database on breaktime..."));
-            SessionInfo::request_reload(session);
+            info!("Odoo version change detected. OdooLS is restarting");
+            session.send_notification("$Odoo/restartNeeded", ());
         }
         session.sync_odoo.import_cache = None;
+        session.sync_odoo.watched_file_updates = 0;
         trace!("Leaving rebuild with remaining tasks: {:?} - {:?} - {:?}", session.sync_odoo.rebuild_arch.len(), session.sync_odoo.rebuild_arch_eval.len(), session.sync_odoo.rebuild_validation.len());
         true
     }
@@ -925,7 +936,7 @@ impl SyncOdoo {
         if !found_an_entry {
             info!("Path {} not found. Creating new entry", path.to_str().expect("unable to stringify path"));
             if EntryPointMgr::create_new_custom_entry_for_path(session, &path_in_tree.sanitize(), &path.sanitize()) {
-                SyncOdoo::process_rebuilds(session);
+                SyncOdoo::process_rebuilds(session, false);
                 return SyncOdoo::get_symbol_of_opened_file(session, path)
             }
         }
@@ -978,7 +989,7 @@ impl SyncOdoo {
                 }
             }
         }
-        SyncOdoo::process_rebuilds(session);
+        SyncOdoo::process_rebuilds(session, false);
     }
 
     pub fn get_rebuild_queue_size(&self) -> usize {
@@ -1124,6 +1135,7 @@ impl Odoo {
                     session.show_message(MessageType::ERROR, format!("Selected configuration ({}) is abstract. Please select a valid configuration and restart.", config.name));
                     return;
                 }
+                session.update_delay_thread_delay_duration(config.auto_refresh_delay);
                 SyncOdoo::init(session, config);
                 session.log_message(MessageType::LOG, format!("End building database in {} seconds. {} detected modules.",
                     (std::time::Instant::now() - start).as_secs(),
@@ -1419,7 +1431,7 @@ impl Odoo {
                         }
                     }
                     EntryPointMgr::create_new_custom_entry_for_path(session, &tree_path.sanitize(), &path.sanitize());
-                    SyncOdoo::process_rebuilds(session);
+                    SyncOdoo::process_rebuilds(session, false);
                 } else if updated {
                     Odoo::update_file_index(session, path, true, false);
                 }
@@ -1499,21 +1511,21 @@ impl Odoo {
             let _ = SyncOdoo::_unload_path(session, &PathBuf::from(&old_path), false);
             FileMgr::delete_path(session, &old_path);
             session.sync_odoo.entry_point_mgr.borrow_mut().remove_entries_with_path(&old_path);
-            SyncOdoo::process_rebuilds(session);
+            SyncOdoo::process_rebuilds(session, false);
             //2 - create new document
             let new_path_buf = PathBuf::from(new_path.clone());
             let new_path_updated = new_path_buf.to_tree_path().sanitize();
             Odoo::search_symbols_to_rebuild(session, &new_path_updated);
-            SyncOdoo::process_rebuilds(session);
+            SyncOdoo::process_rebuilds(session, false);
             let tree = session.sync_odoo.path_to_main_entry_tree(&new_path_buf);
             if let Some(tree) = tree {
                 if  new_path_buf.is_file() &&  session.sync_odoo.get_main_entry().borrow().root.borrow().get_symbol(&tree, u32::MAX).is_empty() {
                     //file has not been added to main entry. Let's build a new entry point
                     EntryPointMgr::create_new_custom_entry_for_path(session, &new_path_updated, &new_path_buf.sanitize());
-                    SyncOdoo::process_rebuilds(session);
+                    SyncOdoo::process_rebuilds(session, false);
                 }
             }
-            SyncOdoo::process_rebuilds(session);
+            SyncOdoo::process_rebuilds(session, false);
         }
     }
 
@@ -1528,7 +1540,7 @@ impl Odoo {
             Odoo::search_symbols_to_rebuild(session, &path_updated);
             session.sync_odoo.entry_point_mgr.borrow_mut().clean_entries();
         }
-        SyncOdoo::process_rebuilds(session);
+        SyncOdoo::process_rebuilds(session, false);
         //Now let's test if the symbol has been added to main entry tree or not
         for f in params.files.iter() {
             let path = FileMgr::uri2pathname(&f.uri);
@@ -1537,7 +1549,7 @@ impl Odoo {
             if PathBuf::from(&path).is_file() && (tree.is_none() || session.sync_odoo.get_main_entry().borrow().root.borrow().get_symbol(&tree.unwrap(), u32::MAX).is_empty()) {
                 //file has not been added to main entry. Let's build a new entry point
                 EntryPointMgr::create_new_custom_entry_for_path(session, &path_updated, &path);
-                SyncOdoo::process_rebuilds(session);
+                SyncOdoo::process_rebuilds(session, false);
             }
         }
     }
@@ -1554,7 +1566,7 @@ impl Odoo {
             FileMgr::delete_path(session, &path);
             session.sync_odoo.entry_point_mgr.borrow_mut().remove_entries_with_path(&path);
         }
-        SyncOdoo::process_rebuilds(session);
+        SyncOdoo::process_rebuilds(session, false);
     }
 
     pub fn handle_did_change(session: &mut SessionInfo, params: DidChangeTextDocumentParams) {
@@ -1652,6 +1664,7 @@ impl Odoo {
                         session.sync_odoo.config = new_config;
                         // Recalculate diagnostic filters
                         session.sync_odoo.get_file_mgr().borrow_mut().update_all_file_diagnostic_filters(session);
+                        session.update_delay_thread_delay_duration(session.sync_odoo.config.auto_refresh_delay);
                     }
                 }
                 Err(err) => {

server/src/features/ast_utils.rs

@@ -1,7 +1,9 @@
 use std::collections::HashMap;
 use std::rc::Rc;
 use std::cell::RefCell;
+use crate::constants::{BuildStatus, BuildSteps, SymType};
 use crate::core::evaluation::{AnalyzeAstResult, Context, ContextValue, Evaluation, ExprOrIdent};
+use crate::core::odoo::SyncOdoo;
 use crate::core::symbols::symbol::Symbol;
 use crate::core::file_mgr::FileInfo;
 use crate::threads::SessionInfo;
@@ -31,6 +33,7 @@ impl AstUtils {
             return (AnalyzeAstResult::default(), None, None);
         };
         let parent_symbol = Symbol::get_scope_symbol(file_symbol.clone(), offset, matches!(expr, ExprOrIdent::Parameter(_)));
+        AstUtils::build_scope(session, &parent_symbol);
         let from_module;
         if let Some(module) = file_symbol.borrow().find_module() {
             from_module = ContextValue::MODULE(Rc::downgrade(&module));
@@ -58,6 +61,20 @@ impl AstUtils {
         }
     }
 
+    pub fn build_scope(session: &mut SessionInfo<'_>, scope: &Rc<RefCell<Symbol>>) {
+        if scope.borrow().typ() == SymType::FUNCTION {
+            let parent_func = scope.borrow().get_in_parents(&vec![SymType::FUNCTION], true);
+            let scope_to_test = parent_func.and_then(|w| w.upgrade());
+            let scope_to_test = scope_to_test.as_ref().unwrap_or(scope);
+            if scope_to_test.borrow().as_func().arch_status == BuildStatus::PENDING {
+                SyncOdoo::build_now(session, scope_to_test, BuildSteps::ARCH);
+            }
+            if scope_to_test.borrow().as_func().arch_eval_status == BuildStatus::PENDING {
+                SyncOdoo::build_now(session, scope_to_test, BuildSteps::ARCH_EVAL);
+            }
+        }
+    }
+
 }
 
 

server/src/features/completion.rs

@@ -6,11 +6,12 @@ use lsp_types::{CompletionItem, CompletionItemKind, CompletionItemLabelDetails,
 use ruff_python_ast::{Decorator, ExceptHandler, Expr, ExprAttribute, ExprIf, ExprName, ExprSubscript, ExprYield, Stmt, StmtGlobal, StmtImport, StmtImportFrom, StmtNonlocal};
 use ruff_text_size::{Ranged, TextSize};
 
-use crate::constants::{OYarn, SymType};
+use crate::constants::{BuildStatus, BuildSteps, OYarn, SymType};
 use crate::core::evaluation::{Context, ContextValue, Evaluation, EvaluationSymbol, EvaluationSymbolPtr, EvaluationSymbolWeak};
 use crate::core::import_resolver;
 use crate::core::odoo::SyncOdoo;
 use crate::core::symbols::module_symbol::ModuleSymbol;
+use crate::features::ast_utils::AstUtils;
 use crate::threads::SessionInfo;
 use crate::utils::compare_semver;
 use crate::{oyarn, Sy, S};
@@ -537,6 +538,7 @@ fn complete_decorator_call(
         return None; // All the decorators we handle have at least one arg for now
     }
     let scope = Symbol::get_scope_symbol(file.clone(), offset as u32, false);
+    AstUtils::build_scope(session, &scope);
     let dec_evals = Evaluation::eval_from_ast(session, &decorator_base, scope.clone(), max_infer, false, &mut vec![]).0;
     let mut followed_evals = vec![];
     for eval in dec_evals {
@@ -580,6 +582,7 @@ fn complete_call(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>>, expr_cal
         return complete_expr( &expr_call.func, session, file, offset, is_param, expected_type);
     }
     let scope = Symbol::get_scope_symbol(file.clone(), offset as u32, is_param);
+    AstUtils::build_scope(session, &scope);
     let callable_evals = Evaluation::eval_from_ast(session, &expr_call.func, scope, &expr_call.func.range().start(), false, &mut vec![]).0;
     for (arg_index, arg) in expr_call.arguments.args.iter().enumerate() {
         if offset > arg.range().start().to_usize() && offset <= arg.range().end().to_usize() {
@@ -751,6 +754,7 @@ fn complete_string_literal(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>>
             },
             ExpectedType::SIMPLE_FIELD(_) | ExpectedType::NESTED_FIELD(_) | ExpectedType::METHOD_NAME => 'field_block:  {
                 let scope = Symbol::get_scope_symbol(file.clone(), expr_string_literal.range().start().to_u32(), true);
+                AstUtils::build_scope(session, &scope);
                 let Some(parent_class) = scope.borrow().get_in_parents(&vec![SymType::CLASS], true).and_then(|p| p.upgrade()) else {
                     break 'field_block;
                 };
@@ -784,6 +788,7 @@ fn complete_attribut(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>>, attr
     //As symbols are not rebuilt, boundaries are not rights, and a "return self." at the end of a function/class body would be out of scope.
     //Temporary, by using the start of expr, we can hope that it is still in the right scope.
     let scope = Symbol::get_scope_symbol(file.clone(), start_expr, is_param);
+    AstUtils::build_scope(session, &scope);
     if offset > attr.value.range().start().to_usize() && offset <= attr.value.range().end().to_usize() {
         return complete_expr( &attr.value, session, file, offset, is_param, expected_type);
     } else {
@@ -810,6 +815,7 @@ fn complete_attribut(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>>, attr
 
 fn complete_subscript(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>>, expr_subscript: &ExprSubscript, offset: usize, is_param: bool, _expected_type: &Vec<ExpectedType>) -> Option<CompletionResponse> {
     let scope = Symbol::get_scope_symbol(file.clone(), offset as u32, is_param);
+    AstUtils::build_scope(session, &scope);
     let subscripted = Evaluation::eval_from_ast(session, &expr_subscript.value, scope.clone(), &expr_subscript.value.range().start(), false, &mut vec![]).0;
     for eval in subscripted.iter() {
         let eval_symbol = eval.symbol.get_symbol(session, &mut None, &mut vec![], Some(scope.clone()));
@@ -847,6 +853,7 @@ fn complete_name_expression(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>
 
 fn complete_name(session: &mut SessionInfo, file: &Rc<RefCell<Symbol>>, offset: usize, is_param: bool, name: &String) -> Option<CompletionResponse> {
     let scope = Symbol::get_scope_symbol(file.clone(), offset as u32, is_param);
+    AstUtils::build_scope(session, &scope);
     let symbols = Symbol::get_all_inferred_names(&scope, name, offset as u32);
     Some(CompletionResponse::List(CompletionList {
         is_incomplete: false,

server/src/server.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, io::Error, panic, sync::{atomic::AtomicBool, Arc, Mutex}, thread::JoinHandle};
+use std::{io::Error, panic, sync::{atomic::AtomicBool, Arc, Mutex}, thread::JoinHandle};
 
 use crossbeam_channel::{Receiver, Select, Sender};
 use lsp_server::{Connection, IoThreads, Message, ProtocolError, RequestId, ResponseError};