refactor(langserver): speed up hovering for keywords, variables and namespace by using references from code analysis

Author: d-biehl

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/analyzer.py

@@ -36,17 +36,18 @@
 from robotcode.language_server.robotframework.utils.version import get_robot_version
 
 from .entities import (
+    CommandLineVariableDefinition,
     EnvironmentVariableDefinition,
+    LibraryEntry,
+    ResourceEntry,
     VariableDefinition,
     VariableNotFoundDefinition,
 )
 from .library_doc import KeywordDoc, KeywordMatcher, is_embedded_keyword
 from .namespace import (
     DIAGNOSTICS_SOURCE_NAME,
     KeywordFinder,
-    LibraryEntry,
     Namespace,
-    ResourceEntry,
 )
 
 
@@ -55,6 +56,7 @@ class AnalyzerResult:
     diagnostics: List[Diagnostic]
     keyword_references: Dict[KeywordDoc, Set[Location]]
     variable_references: Dict[VariableDefinition, Set[Location]]
+    namespace_references: Dict[LibraryEntry, Set[Location]]
 
 
 class Analyzer(AsyncVisitor, ModelHelperMixin):
@@ -83,14 +85,17 @@ def __init__(
         self._diagnostics: List[Diagnostic] = []
         self._keyword_references: Dict[KeywordDoc, Set[Location]] = defaultdict(set)
         self._variable_references: Dict[VariableDefinition, Set[Location]] = defaultdict(set)
+        self._namespace_references: Dict[LibraryEntry, Set[Location]] = defaultdict(set)
 
     async def run(self) -> AnalyzerResult:
         self._diagnostics = []
         self._keyword_references = defaultdict(set)
 
         await self.visit(self.model)
 
-        return AnalyzerResult(self._diagnostics, self._keyword_references, self._variable_references)
+        return AnalyzerResult(
+            self._diagnostics, self._keyword_references, self._variable_references, self._namespace_references
+        )
 
     def yield_argument_name_and_rest(self, node: ast.AST, token: Token) -> Iterator[Token]:
         from robot.parsing.lexer.tokens import Token as RobotToken
@@ -160,6 +165,13 @@ async def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
             if var_def is None:
                 return
 
+            cmd_line_var = await self.namespace.find_variable(
+                name, skip_commandline_variables=False, position=r.start, ignore_error=True
+            )
+            if isinstance(cmd_line_var, CommandLineVariableDefinition):
+                if self.namespace.document is not None:
+                    self._variable_references[cmd_line_var].add(Location(self.namespace.document.document_uri, r))
+
             if var_def not in self._variable_references:
                 self._variable_references[var_def] = set()
 
@@ -340,6 +352,10 @@ async def _analyze_keyword_call(
 
             kw_range = range_from_token(keyword_token)
 
+            lib_entry = None
+            lib_range = None
+            kw_namespace = None
+
             if keyword is not None:
                 for lib, name in iter_over_keyword_names_and_owners(keyword):
                     if (
@@ -354,8 +370,10 @@ async def _analyze_keyword_call(
                     )
                     if lib_entry and kw_namespace:
                         r = range_from_token(keyword_token)
+                        lib_range = r
                         r.end.character = r.start.character + len(kw_namespace)
                         kw_range.start.character = r.end.character + 1
+                        lib_range.end.character = kw_range.start.character - 1
 
             result = self.finder.find_keyword(keyword)
 
@@ -368,6 +386,10 @@ async def _analyze_keyword_call(
                         code=e.code,
                     )
 
+            if kw_namespace and lib_entry is not None and lib_range is not None:
+                if self.namespace.document is not None:
+                    self._namespace_references[lib_entry].add(Location(self.namespace.document.document_uri, lib_range))
+
             if result is not None:
                 if self.namespace.document is not None:
                     self._keyword_references[result].add(Location(self.namespace.document.document_uri, kw_range))

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/entities.py

@@ -1,12 +1,13 @@
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Tuple, TypeVar, cast
 
 from robotcode.core.lsp.types import Position, Range
-from robotcode.language_server.robotframework.utils.ast_utils import Token, range_from_token
+
+from ..utils.ast_utils import Token, range_from_token
 
 if TYPE_CHECKING:
-    from .library_doc import KeywordDoc
+    from .library_doc import KeywordDoc, LibraryDoc
 
 _F = TypeVar("_F", bound=Callable[..., Any])
 
@@ -289,3 +290,45 @@ class VariableNotFoundDefinition(VariableDefinition):
     @single_call
     def __hash__(self) -> int:
         return hash((type(self), self.name, self.type))
+
+
+@dataclass
+class LibraryEntry:
+    name: str
+    import_name: str
+    library_doc: "LibraryDoc"
+    args: Tuple[Any, ...] = ()
+    alias: Optional[str] = None
+    import_range: Range = field(default_factory=lambda: Range.zero())
+    import_source: Optional[str] = None
+
+    def __str__(self) -> str:
+        result = self.import_name
+        if self.args:
+            result += f"  {self.args!s}"
+        if self.alias:
+            result += f"  WITH NAME  {self.alias}"
+        return result
+
+    @single_call
+    def __hash__(self) -> int:
+        return hash(
+            (type(self), self.name, self.import_name, self.args, self.alias, self.import_range, self.import_source)
+        )
+
+
+@dataclass
+class ResourceEntry(LibraryEntry):
+    imports: List[Import] = field(default_factory=list)
+    variables: List[VariableDefinition] = field(default_factory=list)
+
+    @single_call
+    def __hash__(self) -> int:
+        return hash(
+            (type(self), self.name, self.import_name, self.args, self.alias, self.import_range, self.import_source)
+        )
+
+
+@dataclass
+class VariablesEntry(LibraryEntry):
+    variables: List[ImportedVariableDefinition] = field(default_factory=list)

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -1118,7 +1118,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                     ),
                     LOAD_LIBRARY_TIME_OUT,
                 )
-            except (SystemExit, KeyboardInterrupt):
+            except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
                 raise
             except BaseException as e:
                 self._logger.exception(e)
@@ -1373,7 +1373,7 @@ async def _get_libdoc(name: str, args: Tuple[Any, ...], working_dir: str, base_d
                     ),
                     LOAD_LIBRARY_TIME_OUT,
                 )
-            except (SystemExit, KeyboardInterrupt):
+            except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
                 raise
             except BaseException as e:
                 self._logger.exception(e)

packages/language_server/src/robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -9,7 +9,6 @@
 import time
 import weakref
 from collections import OrderedDict
-from dataclasses import dataclass, field
 from itertools import chain
 from pathlib import Path
 from typing import (
@@ -62,13 +61,15 @@
     CommandLineVariableDefinition,
     EnvironmentVariableDefinition,
     Import,
-    ImportedVariableDefinition,
     InvalidVariableError,
+    LibraryEntry,
     LibraryImport,
     LocalVariableDefinition,
+    ResourceEntry,
     ResourceImport,
     VariableDefinition,
     VariableMatcher,
+    VariablesEntry,
     VariablesImport,
 )
 from .imports_manager import ImportsManager
@@ -506,36 +507,6 @@ def visit_VariablesImport(self, node: ast.AST) -> None:  # noqa: N802
             )
 
 
-@dataclass
-class LibraryEntry:
-    name: str
-    import_name: str
-    library_doc: LibraryDoc
-    args: Tuple[Any, ...] = ()
-    alias: Optional[str] = None
-    import_range: Range = field(default_factory=lambda: Range.zero())
-    import_source: Optional[str] = None
-
-    def __str__(self) -> str:
-        result = self.import_name
-        if self.args:
-            result += f"  {self.args!s}"
-        if self.alias:
-            result += f"  WITH NAME  {self.alias}"
-        return result
-
-
-@dataclass
-class ResourceEntry(LibraryEntry):
-    imports: List[Import] = field(default_factory=list)
-    variables: List[VariableDefinition] = field(default_factory=list)
-
-
-@dataclass
-class VariablesEntry(LibraryEntry):
-    variables: List[ImportedVariableDefinition] = field(default_factory=list)
-
-
 class DocumentType(enum.Enum):
     UNKNOWN = "unknown"
     GENERAL = "robot"
@@ -589,6 +560,7 @@ def __init__(
         self._diagnostics: List[Diagnostic] = []
         self._keyword_references: Dict[KeywordDoc, Set[Location]] = {}
         self._variable_references: Dict[VariableDefinition, Set[Location]] = {}
+        self._namespace_references: Dict[LibraryEntry, Set[Location]] = {}
 
         self._imported_keywords: Optional[List[KeywordDoc]] = None
         self._imported_keywords_lock = Lock()
@@ -705,6 +677,7 @@ async def _invalidate(self) -> None:
         self._diagnostics = []
         self._keyword_references = {}
         self._variable_references = {}
+        self._namespace_references = {}
         self._finder = None
         self._in_initialize = False
         self._ignored_lines = None
@@ -740,6 +713,13 @@ async def get_variable_references(self) -> Dict[VariableDefinition, Set[Location
 
         return self._variable_references
 
+    async def get_namespace_references(self) -> Dict[LibraryEntry, Set[Location]]:
+        await self.ensure_initialized()
+
+        await self._analyze()
+
+        return self._namespace_references
+
     @_logger.call
     async def get_libraries(self) -> OrderedDict[str, LibraryEntry]:
         await self.ensure_initialized()
@@ -1593,6 +1573,7 @@ async def _analyze(self) -> None:
                     self._diagnostics += result.diagnostics
                     self._keyword_references = result.keyword_references
                     self._variable_references = result.variable_references
+                    self._namespace_references = result.namespace_references
 
                     lib_doc = await self.get_library_doc()
 

packages/language_server/src/robotcode/language_server/robotframework/parts/code_action_documentation.py

@@ -32,13 +32,13 @@
 from robotcode.language_server.robotframework.configuration import (
     DocumentationServerConfig,
 )
+from robotcode.language_server.robotframework.diagnostics.entities import LibraryEntry
 from robotcode.language_server.robotframework.diagnostics.library_doc import (
     get_library_doc,
     get_robot_library_html_doc_str,
     resolve_robot_variables,
 )
 from robotcode.language_server.robotframework.diagnostics.namespace import (
-    LibraryEntry,
     Namespace,
 )
 from robotcode.language_server.robotframework.utils.ast_utils import (