implement reporting of unused suite variables

Author: d-biehl

robotcode/language_server/common/parts/documents.py

@@ -245,10 +245,10 @@ async def _text_document_did_open(self, text_document: TextDocumentItem, *args:
             uri = str(Uri(text_document.uri).normalized())
             document = self._documents.get(uri, None)
 
-            text_changed = True
             normalized_text = self._normalize_line_endings(text_document.text)
 
             if document is None:
+                text_changed = False
                 document = await self._create_document(
                     text_document.uri, normalized_text, text_document.language_id, text_document.version
                 )

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -737,60 +737,63 @@ async def ensure_initialized(self) -> bool:
         if not self._initialized:
             async with self._initialize_lock:
                 if not self._initialized:
+                    try:
+                        self._logger.debug(f"ensure_initialized -> initialize {self.document}")
 
-                    self._logger.debug(f"ensure_initialized -> initialize {self.document}")
-
-                    imports = await self.get_imports()
-
-                    data_entry: Optional[Namespace.DataEntry] = None
-                    if self.document is not None:
-                        # check or save several data in documents data cache,
-                        # if imports are different, then the data is invalid
-                        old_imports: List[Import] = self.document.get_data(Namespace)
-                        if old_imports is None:
-                            self.document.set_data(Namespace, imports)
-                        elif old_imports != imports:
-                            new_imports = []
-                            for e in old_imports:
-                                if e in imports:
-                                    new_imports.append(e)
-                            for e in imports:
-                                if e not in new_imports:
-                                    new_imports.append(e)
-                            self.document.set_data(Namespace, new_imports)
-                            self.document.set_data(Namespace.DataEntry, None)
-                        else:
-                            data_entry = self.document.get_data(Namespace.DataEntry)
-
-                    if data_entry is not None:
-                        self._libraries = data_entry.libraries.copy()
-                        self._resources = data_entry.resources.copy()
-                        self._variables = data_entry.variables.copy()
-                        self._diagnostics = data_entry.diagnostics.copy()
-                        self._import_entries = data_entry.import_entries.copy()
-                    else:
-                        variables = await self.get_resolvable_variables()
-
-                        await self._import_default_libraries(variables)
-                        await self._import_imports(
-                            imports, str(Path(self.source).parent), top_level=True, variables=variables
-                        )
+                        imports = await self.get_imports()
 
+                        data_entry: Optional[Namespace.DataEntry] = None
                         if self.document is not None:
-                            self.document.set_data(
-                                Namespace.DataEntry,
-                                Namespace.DataEntry(
-                                    self._libraries.copy(),
-                                    self._resources.copy(),
-                                    self._variables.copy(),
-                                    self._diagnostics.copy(),
-                                    self._import_entries.copy(),
-                                ),
+                            # check or save several data in documents data cache,
+                            # if imports are different, then the data is invalid
+                            old_imports: List[Import] = self.document.get_data(Namespace)
+                            if old_imports is None:
+                                self.document.set_data(Namespace, imports)
+                            elif old_imports != imports:
+                                new_imports = []
+                                for e in old_imports:
+                                    if e in imports:
+                                        new_imports.append(e)
+                                for e in imports:
+                                    if e not in new_imports:
+                                        new_imports.append(e)
+                                self.document.set_data(Namespace, new_imports)
+                                self.document.set_data(Namespace.DataEntry, None)
+                            else:
+                                data_entry = self.document.get_data(Namespace.DataEntry)
+
+                        if data_entry is not None:
+                            self._libraries = data_entry.libraries.copy()
+                            self._resources = data_entry.resources.copy()
+                            self._variables = data_entry.variables.copy()
+                            self._diagnostics = data_entry.diagnostics.copy()
+                            self._import_entries = data_entry.import_entries.copy()
+                        else:
+                            variables = await self.get_resolvable_variables()
+
+                            await self._import_default_libraries(variables)
+                            await self._import_imports(
+                                imports, str(Path(self.source).parent), top_level=True, variables=variables
                             )
 
-                    await self._reset_global_variables()
+                            if self.document is not None:
+                                self.document.set_data(
+                                    Namespace.DataEntry,
+                                    Namespace.DataEntry(
+                                        self._libraries.copy(),
+                                        self._resources.copy(),
+                                        self._variables.copy(),
+                                        self._diagnostics.copy(),
+                                        self._import_entries.copy(),
+                                    ),
+                                )
 
-                    self._initialized = True
+                        await self._reset_global_variables()
+
+                        self._initialized = True
+                    except BaseException:
+                        await self.invalidate()
+                        raise
 
         return self._initialized
 

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -77,7 +77,7 @@ async def documents_did_change(self, sender: Any, document: TextDocument) -> Non
                 if res_document is not None:
                     await self.parent.diagnostics.create_publish_document_diagnostics_task(
                         res_document,
-                        wait_time=DOCUMENT_DIAGNOSTICS_DEBOUNCE
+                        wait_time=DOCUMENT_DIAGNOSTICS_DEBOUNCE * 2
                         if res_document.opened_in_editor
                         else WORKSPACE_DIAGNOSTICS_DEBOUNCE,
                     )
@@ -284,6 +284,21 @@ async def collect_unused_references(self, sender: Any, document: TextDocument) -
                             tags=[DiagnosticTag.Unnecessary],
                         )
                     )
+
+            for var in await namespace.get_own_variables():
+                references = await self.parent.robot_references.find_variable_references(document, var, False)
+                if not references and not await Analyzer.should_ignore(document, var.name_range):
+                    result.append(
+                        Diagnostic(
+                            range=var.name_range,
+                            message=f"Variable '{var.name}' is not used.",
+                            severity=DiagnosticSeverity.WARNING,
+                            source=self.source_name,
+                            code="VariableNotUsed",
+                            tags=[DiagnosticTag.Unnecessary],
+                        )
+                    )
+
             return DiagnosticsResult(self.collect_unused_references, result)
         except (asyncio.CancelledError, SystemExit, KeyboardInterrupt):
             raise

robotcode/language_server/robotframework/parts/references.py

@@ -50,6 +50,7 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         parent.references.collect.add(self.collect)
         parent.documents.did_change.add(self.document_did_change)
         self._keyword_reference_cache = AsyncSimpleLRUCache(max_items=None)
+        self._variable_reference_cache = AsyncSimpleLRUCache(max_items=None)
 
     @async_event
     async def cache_cleared(sender) -> None:  # NOSONAR
@@ -146,8 +147,20 @@ async def _references_default(
 
         return None
 
+    async def has_cached_variable_references(
+        self, document: TextDocument, variable: VariableDefinition, include_declaration: bool = True
+    ) -> bool:
+        return await self._variable_reference_cache.has(document, variable, include_declaration)
+
     async def find_variable_references(
         self, document: TextDocument, variable: VariableDefinition, include_declaration: bool = True
+    ) -> List[Location]:
+        return await self._variable_reference_cache.get(
+            self._find_variable_references, document, variable, include_declaration
+        )
+
+    async def _find_variable_references(
+        self, document: TextDocument, variable: VariableDefinition, include_declaration: bool = True
     ) -> List[Location]:
         result = []