implement completion, hover and goto for variables

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -121,17 +121,49 @@ def __eq__(self, o: object) -> bool:
         return self.normalized_name == str(normalize(o, "_"))
 
     def __hash__(self) -> int:
-        return hash(self.name)
+        return hash(self.normalized_name)
 
     def __str__(self) -> str:
         return self.name
 
     def __repr__(self) -> str:
-        return (
-            f"{type(self).__name__}(name={repr(self.name)}"
-            f", normalized_name={repr(self.normalized_name)}"
-            f"{f', embedded=True' if self.embedded_arguments else ''})"
-        )
+        return f"{type(self).__name__}(name={repr(self.name)})"
+
+
+class VariableMatcher:
+    def __init__(self, name: str) -> None:
+        from robot.utils.normalizing import normalize
+        from robot.variables.search import VariableSearcher
+
+        searcher = VariableSearcher("$@&%", ignore_errors=True)
+        match = searcher.search(name)
+        self.name = name
+        self.base = match.base
+        self.normalized_name = str(normalize(match.base, "_"))
+
+    def __eq__(self, o: object) -> bool:
+        from robot.utils.normalizing import normalize
+        from robot.variables.search import VariableSearcher
+
+        if isinstance(o, VariableMatcher):
+            base = o.base
+        elif isinstance(o, str):
+            searcher = VariableSearcher("$@&%", ignore_errors=True)
+            match = searcher.search(o)
+            base = match.base
+        else:
+            return False
+
+        return self.normalized_name == str(normalize(base, "_"))
+
+    def __hash__(self) -> int:
+        return hash(self.normalized_name)
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(name={repr(self.name)})"
 
 
 class Model(BaseModel):

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -44,6 +44,7 @@
     KeywordDoc,
     KeywordMatcher,
     LibraryDoc,
+    VariableMatcher,
     is_embedded_keyword,
 )
 
@@ -145,6 +146,18 @@ class VariableDefinition(SourceEntity):
     def __hash__(self) -> int:
         return hash((type(self), self.name, self.type))
 
+    def range(self) -> Range:
+        return Range(
+            start=Position(
+                line=self.name_token.lineno - 1 if self.name_token is not None else self.line_no - 1,
+                character=self.name_token.col_offset if self.name_token is not None else self.col_offset,
+            ),
+            end=Position(
+                line=self.name_token.lineno - 1 if self.name_token is not None else self.end_line_no - 1,
+                character=self.name_token.end_col_offset if self.name_token is not None else self.end_col_offset,
+            ),
+        )
+
 
 @dataclass
 class BuiltInVariableDefinition(VariableDefinition):
@@ -184,7 +197,7 @@ async def visit_Variable(self, node: ast.AST) -> None:  # noqa: N802
         from robot.parsing.model.statements import Variable
 
         n = cast(Variable, node)
-        name = n.get_value(Token.VARIABLE)
+        name = n.get_token(Token.VARIABLE)
         if n.name:
             self._results.append(
                 VariableDefinition(
@@ -723,7 +736,6 @@ def __init__(
         self._library_doc: Optional[LibraryDoc] = None
         self._imports: Optional[List[Import]] = None
         self._own_variables: Optional[List[VariableDefinition]] = None
-        self._variables_definitions: Optional[Dict[str, VariableDefinition]] = None
         self._diagnostics: List[Diagnostic] = []
 
         self._keywords: Optional[List[KeywordDoc]] = None
@@ -838,26 +850,26 @@ def get_builtin_variables(cls) -> List[BuiltInVariableDefinition]:
 
         return cls._builtin_variables
 
-    async def get_variables(self, nodes: Optional[List[ast.AST]] = None) -> Dict[str, VariableDefinition]:
+    async def get_variables(self, nodes: Optional[List[ast.AST]] = None) -> Dict[VariableMatcher, VariableDefinition]:
         from robot.parsing.model.blocks import Keyword
 
         await self._ensure_initialized()
 
-        if self._variables_definitions is None:
-            result: Dict[str, VariableDefinition] = {}
+        result: Dict[VariableMatcher, VariableDefinition] = {}
 
-            async for var in async_chain(
-                *[await ArgumentsVisitor().get(self.source, n) for n in nodes or [] if isinstance(n, Keyword)],
-                (e for e in await self.get_own_variables()),
-                *(e.variables for e in self._resources.values()),
-                (e for e in self.get_builtin_variables()),
-            ):
-                if var.name is not None and var.name not in result.keys():
-                    result[var.name] = var
+        async for var in async_chain(
+            *[await ArgumentsVisitor().get(self.source, n) for n in nodes or [] if isinstance(n, Keyword)],
+            (e for e in await self.get_own_variables()),
+            *(e.variables for e in self._resources.values()),
+            (e for e in self.get_builtin_variables()),
+        ):
+            if var.name is not None and VariableMatcher(var.name) not in result.keys():
+                result[VariableMatcher(var.name)] = var
 
-            self._variables_definitions = result
+        return result
 
-        return self._variables_definitions
+    async def find_variable(self, name: str, nodes: Optional[List[ast.AST]]) -> Optional[VariableDefinition]:
+        return (await self.get_variables(nodes)).get(VariableMatcher(name), None)
 
     async def _import_imports(self, imports: Iterable[Import], base_dir: str, *, top_level: bool = False) -> None:
         async def _import(value: Import) -> Optional[LibraryEntry]:

robotcode/language_server/robotframework/parts/goto.py

@@ -19,8 +19,10 @@
 from ...common.text_document import TextDocument
 from ...common.types import Location, LocationLink, Position
 from ..utils.ast import (
+    HasTokens,
     Token,
-    get_node_at_position,
+    get_nodes_at_position,
+    get_tokens_at_position,
     range_from_token,
     range_from_token_or_node,
 )
@@ -64,17 +66,60 @@ def _find_method(self, cls: Type[Any]) -> Optional[_DefinitionMethod]:
     async def collect(
         self, sender: Any, document: TextDocument, position: Position
     ) -> Union[Location, List[Location], List[LocationLink], None]:
+        result_nodes = await get_nodes_at_position(await self.parent.documents_cache.get_model(document), position)
 
-        result_node = await get_node_at_position(await self.parent.documents_cache.get_model(document), position)
+        if not result_nodes:
+            return None
+
+        result_node = result_nodes[-1]
 
         if result_node is None:
             return None
 
         method = self._find_method(type(result_node))
-        if method is None:
+        if method is not None:
+            result = await method(result_node, document, position)
+            if result is not None:
+                return result
+
+        return await self._definition_default(result_nodes, document, position)
+
+    async def _definition_default(
+        self, nodes: List[ast.AST], document: TextDocument, position: Position
+    ) -> Union[Location, List[Location], List[LocationLink], None]:
+        namespace = await self.parent.documents_cache.get_namespace(document)
+        if namespace is None:
             return None
 
-        return await method(result_node, document, position)
+        if not nodes:
+            return None
+
+        node = nodes[-1]
+
+        if not isinstance(node, HasTokens):
+            return None
+
+        tokens = get_tokens_at_position(node, position)
+
+        for t in tokens:
+            try:
+                for sub_token in t.tokenize_variables():
+                    range = range_from_token(sub_token)
+
+                    if position.is_in_range(range):
+                        variable = await namespace.find_variable(sub_token.value, nodes)
+                        if variable is not None and variable.source:
+                            return [
+                                LocationLink(
+                                    origin_selection_range=range_from_token_or_node(node, sub_token),
+                                    target_uri=str(Uri.from_path(variable.source)),
+                                    target_range=variable.range(),
+                                    target_selection_range=variable.range(),
+                                )
+                            ]
+            except BaseException:
+                pass
+        return None
 
     async def definition_KeywordCall(  # noqa: N802
         self, node: ast.AST, document: TextDocument, position: Position

robotcode/language_server/robotframework/parts/hover.py

@@ -1,15 +1,27 @@
 from __future__ import annotations
 
 import ast
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional, Type, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    List,
+    Optional,
+    Type,
+    Union,
+    cast,
+)
 
 from ....utils.logging import LoggingDescriptor
 from ...common.language import language_id
 from ...common.text_document import TextDocument
 from ...common.types import Hover, MarkupContent, MarkupKind, Position
 from ..utils.ast import (
+    HasTokens,
     Token,
-    get_node_at_position,
+    get_nodes_at_position,
+    get_tokens_at_position,
     range_from_token,
     range_from_token_or_node,
 )
@@ -43,20 +55,57 @@ def _find_method(self, cls: Type[Any]) -> Optional[_HoverMethod]:
             method = self._find_method(base)
             if method:
                 return cast(_HoverMethod, method)
+
         return None
 
     @language_id("robotframework")
     async def collect(self, sender: Any, document: TextDocument, position: Position) -> Optional[Hover]:
-        result_node = await get_node_at_position(await self.parent.documents_cache.get_model(document), position)
+        result_nodes = await get_nodes_at_position(await self.parent.documents_cache.get_model(document), position)
 
-        if result_node is None:
+        if not result_nodes:
             return None
 
+        result_node = result_nodes[-1]
+
         method = self._find_method(type(result_node))
-        if method is None:
+        if method is not None:
+            result = await method(result_node, document, position)
+            if result is not None:
+                return result
+
+        return await self._hover_default(result_nodes, document, position)
+
+    async def _hover_default(self, nodes: List[ast.AST], document: TextDocument, position: Position) -> Optional[Hover]:
+        namespace = await self.parent.documents_cache.get_namespace(document)
+        if namespace is None:
+            return None
+
+        if not nodes:
             return None
 
-        return await method(result_node, document, position)
+        node = nodes[-1]
+        if not isinstance(node, HasTokens):
+            return None
+
+        tokens = get_tokens_at_position(node, position)
+
+        for t in tokens:
+            try:
+                for sub_token in t.tokenize_variables():
+                    range = range_from_token(sub_token)
+
+                    if position.is_in_range(range):
+                        variable = await namespace.find_variable(sub_token.value, nodes)
+                        if variable is not None:
+                            return Hover(
+                                contents=MarkupContent(
+                                    kind=MarkupKind.MARKDOWN, value=f"({variable.type.value}) {variable.name}"
+                                ),
+                                range=range,
+                            )
+            except BaseException:
+                pass
+        return None
 
     async def hover_KeywordCall(  # noqa: N802
         self, node: ast.AST, document: TextDocument, position: Position