Skip to content

Commit 6f982e2

Browse files
mmahroussmmahrouss
committed
DRAFT
1 parent 8c2d332 commit 6f982e2

File tree

7 files changed

+241
-175
lines changed

7 files changed

+241
-175
lines changed

‎server/src/core/import_resolver.rs‎

Lines changed: 119 additions & 82 deletions
Large diffs are not rendered by default.

‎server/src/core/odoo.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@ use crate::core::entry_point::EntryPointType;
33
use crate::core::file_mgr::AstType;
44
use crate::core::xml_data::OdooData;
55
use crate::core::xml_validation::XmlValidator;
6+
use crate::crash_buffer::report_counter;
67
use crate::features::document_symbols::DocumentSymbolFeature;
78
use crate::features::references::ReferenceFeature;
89
use crate::features::workspace_symbols::WorkspaceSymbolFeature;
@@ -499,6 +500,7 @@ impl SyncOdoo {
499500
//fs::write("out_architecture.json", self.get_symbol(&tree(vec!["odoo", "addons", "module_1"], vec![])).as_ref().unwrap().borrow().debug_to_json().to_string()).expect("Unable to write file");
500501
let modules_count = session.sync_odoo.modules.len();
501502
info!("End building modules. {} modules loaded", modules_count);
503+
report_counter();
502504
session.log_message(MessageType::INFO, format!("End building modules. {} modules loaded", modules_count));
503505
session.sync_odoo.state_init = InitState::ODOO_READY;
504506
}

‎server/src/core/python_arch_builder.rs‎

Lines changed: 52 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -180,69 +180,71 @@ impl PythonArchBuilder {
180180
}
181181
let mut all_name_allowed = true;
182182
let mut name_filter: Vec<OYarn> = vec![];
183-
if let Some(all) = import_result.symbol.borrow().get_content_symbol("__all__", u32::MAX).symbols.first().cloned() {
184-
let all_value = Symbol::follow_ref(&EvaluationSymbolPtr::WEAK(EvaluationSymbolWeak::new(
185-
Rc::downgrade(&all), None, false
186-
)), session, &mut None, false, true, None);
187-
if let Some(all_value_first) = all_value.get(0) {
188-
if !all_value_first.is_expired_if_weak() {
189-
let all_upgraded = all_value_first.upgrade_weak();
190-
if let Some(all_upgraded_unwrapped) = all_upgraded {
191-
let all_upgraded_unwrapped_bw = (*all_upgraded_unwrapped).borrow();
192-
if all_upgraded_unwrapped_bw.evaluations().is_some() && all_upgraded_unwrapped_bw.evaluations().unwrap().len() == 1 {
193-
let value = &all_upgraded_unwrapped_bw.evaluations().unwrap()[0].value;
194-
if value.is_some() {
195-
let (nf, parse_error) = self.extract_all_symbol_eval_values(&value.as_ref());
196-
if parse_error {
197-
warn!("error during parsing __all__ import in file {}", (*import_result.symbol).borrow().paths()[0] )
183+
for import_symbol in import_result.symbols{
184+
if let Some(all) = import_symbol.borrow().get_content_symbol("__all__", u32::MAX).symbols.first().cloned() {
185+
let all_value = Symbol::follow_ref(&EvaluationSymbolPtr::WEAK(EvaluationSymbolWeak::new(
186+
Rc::downgrade(&all), None, false
187+
)), session, &mut None, false, true, None);
188+
if let Some(all_value_first) = all_value.get(0) {
189+
if !all_value_first.is_expired_if_weak() {
190+
let all_upgraded = all_value_first.upgrade_weak();
191+
if let Some(all_upgraded_unwrapped) = all_upgraded {
192+
let all_upgraded_unwrapped_bw = (*all_upgraded_unwrapped).borrow();
193+
if all_upgraded_unwrapped_bw.evaluations().is_some() && all_upgraded_unwrapped_bw.evaluations().unwrap().len() == 1 {
194+
let value = &all_upgraded_unwrapped_bw.evaluations().unwrap()[0].value;
195+
if value.is_some() {
196+
let (nf, parse_error) = self.extract_all_symbol_eval_values(&value.as_ref());
197+
if parse_error {
198+
warn!("error during parsing __all__ import in file {}", import_symbol.borrow().paths()[0] )
199+
}
200+
name_filter = nf;
201+
all_name_allowed = false;
202+
} else {
203+
warn!("invalid __all__ import in file {} - no value found", import_symbol.borrow().paths()[0])
198204
}
199-
name_filter = nf;
200-
all_name_allowed = false;
201205
} else {
202-
warn!("invalid __all__ import in file {} - no value found", (*import_result.symbol).borrow().paths()[0])
206+
warn!("invalid __all__ import in file {} - multiple evaluation found", import_symbol.borrow().paths()[0])
203207
}
204208
} else {
205-
warn!("invalid __all__ import in file {} - multiple evaluation found", (*import_result.symbol).borrow().paths()[0])
209+
warn!("invalid __all__ import in file {} - localizedSymbol not found", import_symbol.borrow().paths()[0])
206210
}
207211
} else {
208-
warn!("invalid __all__ import in file {} - localizedSymbol not found", (*import_result.symbol).borrow().paths()[0])
212+
warn!("invalid __all__ import in file {} - expired symbol", import_symbol.borrow().paths()[0])
209213
}
210214
} else {
211-
warn!("invalid __all__ import in file {} - expired symbol", (*import_result.symbol).borrow().paths()[0])
215+
warn!("invalid __all__ import in file {} - no symbol found", import_symbol.borrow().paths()[0])
212216
}
213-
} else {
214-
warn!("invalid __all__ import in file {} - no symbol found", (*import_result.symbol).borrow().paths()[0])
215217
}
216-
}
217-
let mut dep_to_add = vec![];
218-
let sym_type = import_result.symbol.borrow().typ();
219-
if sym_type != SymType::COMPILED {
220-
if !Rc::ptr_eq(self.sym_stack.last().unwrap(), &import_result.symbol) { /*We have to check that the imported symbol is not the current one. It can
221-
happen for example in a .pyi that is importing the .pyd file with the same name. As both exists, odools will try to import the pyi a second time in the same file,
222-
and so create a borrow error here
223-
*/
224-
let symbol = import_result.symbol.borrow();
225-
for (name, loc_syms) in symbol.iter_symbols() {
226-
if all_name_allowed || name_filter.contains(&name) {
227-
let variable = self.sym_stack.last().unwrap().borrow_mut().add_new_variable(session, OYarn::from(name.clone()), &import_result.range);
228-
let mut loc = variable.borrow_mut();
229-
loc.as_variable_mut().is_import_variable = true;
230-
loc.as_variable_mut().evaluations = Evaluation::from_sections(&symbol, loc_syms);
231-
dep_to_add.push(variable.clone());
218+
let mut dep_to_add = vec![];
219+
let sym_type = import_symbol.borrow().typ();
220+
if sym_type != SymType::COMPILED {
221+
if !Rc::ptr_eq(self.sym_stack.last().unwrap(), &import_symbol) { /*We have to check that the imported symbol is not the current one. It can
222+
happen for example in a .pyi that is importing the .pyd file with the same name. As both exists, odools will try to import the pyi a second time in the same file,
223+
and so create a borrow error here
224+
*/
225+
let symbol = import_symbol.borrow();
226+
for (name, loc_syms) in symbol.iter_symbols() {
227+
if all_name_allowed || name_filter.contains(&name) {
228+
let variable = self.sym_stack.last().unwrap().borrow_mut().add_new_variable(session, OYarn::from(name.clone()), &import_result.range);
229+
let mut loc = variable.borrow_mut();
230+
loc.as_variable_mut().is_import_variable = true;
231+
loc.as_variable_mut().evaluations = Evaluation::from_sections(&symbol, loc_syms);
232+
dep_to_add.push(variable.clone());
233+
}
232234
}
233235
}
234236
}
235-
}
236-
for sym in dep_to_add {
237-
let mut sym_bw = sym.borrow_mut();
238-
let evaluation = &sym_bw.as_variable_mut().evaluations[0];
239-
let evaluated_type = &evaluation.symbol;
240-
let evaluated_type = evaluated_type.get_symbol_as_weak(session, &mut None, &mut self.diagnostics, None).weak;
241-
if !evaluated_type.is_expired() {
242-
let evaluated_type = evaluated_type.upgrade().unwrap();
243-
let evaluated_type_file = evaluated_type.borrow().get_file().unwrap().clone().upgrade().unwrap();
244-
if !Rc::ptr_eq(&self.file, &evaluated_type_file) {
245-
self.file.borrow_mut().add_dependency(&mut evaluated_type_file.borrow_mut(), self.current_step, BuildSteps::ARCH);
237+
for sym in dep_to_add {
238+
let mut sym_bw = sym.borrow_mut();
239+
let evaluation = &sym_bw.as_variable_mut().evaluations[0];
240+
let evaluated_type = &evaluation.symbol;
241+
let evaluated_type = evaluated_type.get_symbol_as_weak(session, &mut None, &mut self.diagnostics, None).weak;
242+
if !evaluated_type.is_expired() {
243+
let evaluated_type = evaluated_type.upgrade().unwrap();
244+
let evaluated_type_file = evaluated_type.borrow().get_file().unwrap().clone().upgrade().unwrap();
245+
if !Rc::ptr_eq(&self.file, &evaluated_type_file) {
246+
self.file.borrow_mut().add_dependency(&mut evaluated_type_file.borrow_mut(), self.current_step, BuildSteps::ARCH);
247+
}
246248
}
247249
}
248250
}

‎server/src/core/python_arch_eval.rs‎

Lines changed: 41 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -397,57 +397,61 @@ impl PythonArchEval {
397397
level,
398398
&mut Some(&mut self.diagnostics));
399399

400-
for _import_result in import_results.iter() {
401-
let variable = self.sym_stack.last().unwrap().borrow().get_positioned_symbol(&_import_result.var_name, &_import_result.range);
400+
for import_result in import_results.iter() {
401+
let variable = self.sym_stack.last().unwrap().borrow().get_positioned_symbol(&import_result.var_name, &import_result.range);
402402
let Some(variable) = variable.clone() else {
403403
continue;
404404
};
405-
if _import_result.found {
406-
let import_sym_ref = _import_result.symbol.clone();
407-
let has_loop = self.check_for_loop_evaluation(session, import_sym_ref, &variable);
408-
if !has_loop { //anti-loop. We want to be sure we are not evaluating to the same sym
409-
let instance = match _import_result.symbol.borrow().typ() {
410-
SymType::CLASS => Some(false),
411-
_ => None
412-
};
413-
variable.borrow_mut().set_evaluations(vec![Evaluation::eval_from_symbol(&Rc::downgrade(&_import_result.symbol), instance)]);
414-
let file_of_import_symbol = _import_result.symbol.borrow().get_file();
415-
if let Some(import_file) = file_of_import_symbol {
416-
let import_file = import_file.upgrade().unwrap();
417-
if !Rc::ptr_eq(&self.file, &import_file) {
418-
self.file.borrow_mut().add_dependency(&mut import_file.borrow_mut(), self.current_step, BuildSteps::ARCH);
405+
if import_result.found {
406+
variable.borrow_mut().set_evaluations(vec![]);
407+
for import_sym in import_result.symbols.iter() {
408+
let has_loop = self.check_for_loop_evaluation(session, import_sym.clone(), &variable);
409+
if !has_loop { //anti-loop. We want to be sure we are not evaluating to the same sym
410+
let instance = match import_sym.borrow().typ() {
411+
SymType::CLASS => Some(false),
412+
_ => None
413+
};
414+
variable.borrow_mut().evaluations_mut().unwrap().push(Evaluation::eval_from_symbol(&Rc::downgrade(&import_sym), instance));
415+
let file_of_import_symbol = import_sym.borrow().get_file();
416+
if let Some(import_file) = file_of_import_symbol {
417+
let import_file = import_file.upgrade().unwrap();
418+
if !Rc::ptr_eq(&self.file, &import_file) {
419+
self.file.borrow_mut().add_dependency(&mut import_file.borrow_mut(), self.current_step, BuildSteps::ARCH);
420+
}
419421
}
420-
}
421-
} else {
422-
let mut file_tree = _import_result.file_tree.clone();
423-
file_tree.extend(_import_result.name.split(".").map(|s| oyarn!("{}", s)));
424-
self.file.borrow_mut().not_found_paths_mut().push((self.current_step, file_tree.clone()));
425-
self.entry_point.borrow_mut().not_found_symbols.insert(self.file.clone());
426-
if self._match_diag_config(session.sync_odoo, &_import_result.symbol) {
427-
if let Some(diagnostic) = create_diagnostic(&session, DiagnosticCode::OLS02002, &[&file_tree.clone().join(".")]) {
428-
self.diagnostics.push(Diagnostic {
429-
range: Range::new(Position::new(_import_result.range.start().to_u32(), 0), Position::new(_import_result.range.end().to_u32(), 0)),
430-
..diagnostic
431-
});
422+
} else {
423+
let mut file_tree = import_result.file_tree.clone();
424+
file_tree.extend(import_result.name.split(".").map(|s| oyarn!("{}", s)));
425+
self.file.borrow_mut().not_found_paths_mut().push((self.current_step, file_tree.clone()));
426+
self.entry_point.borrow_mut().not_found_symbols.insert(self.file.clone());
427+
if self._match_diag_config(session.sync_odoo, import_sym) {
428+
if let Some(diagnostic) = create_diagnostic(&session, DiagnosticCode::OLS02002, &[&file_tree.clone().join(".")]) {
429+
self.diagnostics.push(Diagnostic {
430+
range: Range::new(Position::new(import_result.range.start().to_u32(), 0), Position::new(import_result.range.end().to_u32(), 0)),
431+
..diagnostic
432+
});
433+
}
432434
}
433435
}
434436
}
435437

436438
} else {
437-
let mut file_tree = _import_result.file_tree.clone();
438-
file_tree.extend(_import_result.name.split(".").map(|s| oyarn!("{}", s)));
439+
let mut file_tree = import_result.file_tree.clone();
440+
file_tree.extend(import_result.name.split(".").map(|s| oyarn!("{}", s)));
439441
if session.sync_odoo.config.diag_missing_imports != DiagMissingImportsMode::All && BUILT_IN_LIBS.contains(&file_tree[0].as_str()) {
440442
continue;
441443
}
442444
if !self.safe_import.last().unwrap() {
443445
self.file.borrow_mut().not_found_paths_mut().push((self.current_step, file_tree.clone()));
444446
self.entry_point.borrow_mut().not_found_symbols.insert(self.file.clone());
445-
if self._match_diag_config(session.sync_odoo, &_import_result.symbol) {
446-
if let Some(diagnostic) = create_diagnostic(&session, DiagnosticCode::OLS02001, &[&file_tree.clone().join(".")]) {
447-
self.diagnostics.push(Diagnostic {
448-
range: Range::new(Position::new(_import_result.range.start().to_u32(), 0), Position::new(_import_result.range.end().to_u32(), 0)),
449-
..diagnostic
450-
});
447+
for import_sym in import_result.symbols.iter() {
448+
if self._match_diag_config(session.sync_odoo, import_sym) {
449+
if let Some(diagnostic) = create_diagnostic(&session, DiagnosticCode::OLS02001, &[&file_tree.clone().join(".")]) {
450+
self.diagnostics.push(Diagnostic {
451+
range: Range::new(Position::new(import_result.range.start().to_u32(), 0), Position::new(import_result.range.end().to_u32(), 0)),
452+
..diagnostic
453+
});
454+
}
451455
}
452456
}
453457
}
@@ -997,7 +1001,7 @@ impl PythonArchEval {
9971001
diagnostics.extend(diags);
9981002
// Check for type annotation `typing.Self`, if so, return a `self` evaluation
9991003
let final_evaluations = evaluations.into_iter().map(|eval|{
1000-
let sym_ptrs = Symbol::follow_ref(&eval.symbol.get_symbol(session, &mut None, diagnostics, None), session, &mut None, false, false, file_sym.clone());
1004+
let sym_ptrs = Symbol::follow_ref(&eval.symbol.get_symbol(session, &mut None, diagnostics, None), session, &mut None, false, false, None);
10011005
for sym_ptr in sym_ptrs.iter(){
10021006
let EvaluationSymbolPtr::WEAK(sym_weak) = sym_ptr else {continue};
10031007
let Some(sym_rc) = sym_weak.weak.upgrade() else {continue};

‎server/src/crash_buffer.rs‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,26 @@ use std::sync::OnceLock;
66

77
const N: usize = 20;
88

9+
pub static COUNTER : OnceLock<Mutex<usize>> = OnceLock::new();
10+
11+
pub fn init_counter() {
12+
let _ = COUNTER.set(Mutex::new(0));
13+
}
14+
15+
pub fn incr_counter() {
16+
if let Some(counter) = COUNTER.get() {
17+
let mut count = counter.lock().unwrap();
18+
*count += 1;
19+
}
20+
}
21+
22+
pub fn report_counter(){
23+
if let Some(counter) = COUNTER.get() {
24+
let count = counter.lock().unwrap();
25+
println!("Import counter: {}", *count);
26+
}
27+
}
28+
929
pub static CRASH_BUFFER: OnceLock<Mutex<VecDeque<Message>>> = OnceLock::new();
1030

1131
pub fn init_crash_buffer() {

0 commit comments

Comments
 (0)