fix: speedup loading and analysing tests

Instead of waiting for diagnostics load and analyse documents one by one, load first the documents and then start analysing and discovering in different tasks/threads

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -152,15 +152,19 @@ async def is_valid(self) -> bool:
 class _LibrariesEntry(_ImportEntry):
     def __init__(
         self,
+        parent: ImportsManager,
         name: str,
         args: Tuple[Any, ...],
-        parent: ImportsManager,
-        get_libdoc_coroutine: Callable[[], Coroutine[Any, Any, LibraryDoc]],
+        working_dir: str,
+        base_dir: str,
+        get_libdoc_coroutine: Callable[[str, Tuple[Any, ...], str, str], Coroutine[Any, Any, LibraryDoc]],
         ignore_reference: bool = False,
     ) -> None:
         super().__init__(parent)
         self.name = name
         self.args = args
+        self.working_dir = working_dir
+        self.base_dir = base_dir
         self._get_libdoc_coroutine = get_libdoc_coroutine
         self._lib_doc: Optional[LibraryDoc] = None
         self.ignore_reference = ignore_reference
@@ -211,7 +215,7 @@ async def check_file_changed(self, changes: List[FileEvent]) -> Optional[FileCha
             return None
 
     async def _update(self) -> None:
-        self._lib_doc = await self._get_libdoc_coroutine()
+        self._lib_doc = await self._get_libdoc_coroutine(self.name, self.args, self.working_dir, self.base_dir)
 
         source_or_origin = (
             self._lib_doc.source
@@ -893,7 +897,7 @@ async def get_libdoc_for_library_import(
             variables,
         )
 
-        async def _get_libdoc() -> LibraryDoc:
+        async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_dir: str) -> LibraryDoc:
 
             meta, source = await self.get_library_meta(
                 name,
@@ -926,7 +930,7 @@ async def _get_libdoc() -> LibraryDoc:
                         get_library_doc,
                         name,
                         args,
-                        str(self.folder.to_path()),
+                        working_dir,
                         base_dir,
                         self.config.robot.variables if self.config.robot is not None else None,
                         variables,
@@ -960,7 +964,13 @@ async def _get_libdoc() -> LibraryDoc:
         async with self._libaries_lock:
             if entry_key not in self._libaries:
                 self._libaries[entry_key] = _LibrariesEntry(
-                    name, args, self, _get_libdoc, ignore_reference=sentinel is None
+                    self,
+                    name,
+                    args,
+                    str(self.folder.to_path()),
+                    base_dir,
+                    _get_libdoc,
+                    ignore_reference=sentinel is None,
                 )
 
         entry = self._libaries[entry_key]

robotcode/language_server/robotframework/parts/discovering.py

@@ -217,7 +217,8 @@ def generate(suite: TestSuite) -> TestItem:
                 else None,
             )
 
-        await self.parent.diagnostics.ensure_workspace_loaded()
+        # await self.parent.diagnostics.ensure_workspace_loaded()
+        await self.parent.robot_workspace.documents_loaded.wait()
 
         workspace_path = Uri(workspace_folder).to_path()
         with LOGGER.cache_only:

robotcode/language_server/robotframework/parts/robot_workspace.py

@@ -40,7 +40,7 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         self.parent.diagnostics.on_get_diagnostics_mode.add(self.on_get_diagnostics_mode)
         self.parent.diagnostics.on_get_analysis_progress_mode.add(self.on_get_analysis_progress_mode)
         self.parent.on_initialized.add(self.on_initialized)
-        self.workspace_loaded = Event()
+        self.documents_loaded = Event()
 
     async def on_initialized(self, sender: Any) -> None:
         await self.parent.workspace.add_file_watcher(
@@ -100,6 +100,22 @@ async def _load_workspace_documents(self, sender: Any) -> List[WorkspaceDocument
                 async with self.parent.window.progress(
                     "Load workspace", cancellable=True, current=0, max=len(files), start=False
                 ) as progress:
+                    for i, f in enumerate(files):
+                        await self.parent.documents.get_or_open_document(f, "robotframework")
+
+                        if config.analysis.progress_mode != AnalysisProgressMode.OFF:
+                            name = f.relative_to(folder.uri.to_path())
+
+                            progress.begin()
+                            progress.report(
+                                f"Load {str(name)}"
+                                if config.analysis.progress_mode == AnalysisProgressMode.DETAILED
+                                else None,
+                                current=i,
+                            )
+
+                    self.documents_loaded.set()
+
                     for i, f in enumerate(files):
                         try:
                             if progress.is_canceled:
@@ -111,7 +127,7 @@ async def _load_workspace_documents(self, sender: Any) -> List[WorkspaceDocument
                             if config.analysis.progress_mode != AnalysisProgressMode.OFF:
                                 progress.begin()
                                 progress.report(
-                                    f"Load {str(name)}"
+                                    f"Initialize {str(name)}"
                                     if config.analysis.progress_mode == AnalysisProgressMode.DETAILED
                                     else None,
                                     current=i,
@@ -140,8 +156,6 @@ async def _load_workspace_documents(self, sender: Any) -> List[WorkspaceDocument
                         except BaseException as e:
                             self._logger.exception(e)
 
-            self.workspace_loaded.set()
-
             if canceled:
                 return []