implement find references for libraries, resources, variables import, refactor find references

Author: d-biehl

CHANGELOG.md

@@ -6,6 +6,8 @@ All notable changes to the "robotcode" extension will be documented in this file
 
 ### added
 
+- implement find references for libraries, resources, variables import
+  
 ##  0.4.2
 
 ### added

robotcode/language_server/common/lsp_types.py

@@ -1073,6 +1073,11 @@ def extend(self, start_line: int = 0, start_character: int = 0, end_line: int =
             end=Position(line=self.end.line + end_line, character=self.end.character + end_character),
         )
 
+    def __contains__(self, x: object) -> bool:
+        if isinstance(x, Position):
+            return x.is_in_range(self)
+        return False
+
 
 @dataclass(repr=False)
 class TextDocumentItem(Model):

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -177,18 +177,24 @@ def __init__(self, name: str, extended: bool = False) -> None:
         from robot.utils.normalizing import normalize
         from robot.variables.search import VariableSearcher
 
+        self.name = name
+        self.extended = extended
+
         searcher = VariableSearcher("$@&%", ignore_errors=True)
         match = searcher.search(name)
-        self.name = name
+
         if match.base is None:
             raise InvalidVariableError(f"Invalid variable '{name}'")
 
         self.base = match.base
 
+        self.extended_base: Optional[str] = None
+        self.normalize_extended: Optional[str] = None
         if extended:
             ext_match = self._match_extended.match(self.name[2:-1])
             if ext_match is not None:
-                self.base, _ = ext_match.groups()
+                self.extended_base, _ = ext_match.groups()
+                self.normalize_extended = str(normalize(self.extended_base, "_"))
 
         self.normalized_name = str(normalize(self.base, "_"))
 
@@ -197,16 +203,16 @@ def __eq__(self, o: object) -> bool:
         from robot.variables.search import VariableSearcher
 
         if isinstance(o, VariableMatcher):
-            base = o.base
+            return o.normalized_name == self.normalized_name or (o.extended and self.normalized_name == o.extended_base)
         elif isinstance(o, str):
             searcher = VariableSearcher("$@&%", ignore_errors=True)
             match = searcher.search(o)
             base = match.base
+            normalized = str(normalize(base, "_"))
+            return self.normalized_name == normalized or (self.extended and self.normalize_extended == normalized)
         else:
             return False
 
-        return self.normalized_name == str(normalize(base, "_"))
-
     def __hash__(self) -> int:
         return hash(self.normalized_name)
 
@@ -475,11 +481,11 @@ class LibraryDoc(Model):
     line_no: int = -1
     end_line_no: int = -1
     inits: KeywordStore = KeywordStore()
-    keywords: KeywordStore = KeywordStore()
+    keywords: KeywordStore = field(default_factory=KeywordStore, compare=False)
     module_spec: Optional[ModuleSpec] = None
-    errors: Optional[List[Error]] = None
+    errors: Optional[List[Error]] = field(default=None, compare=False)
     python_path: Optional[List[str]] = None
-    stdout: Optional[str] = None
+    stdout: Optional[str] = field(default=None, compare=False)
     has_listener: Optional[bool] = None
 
     @property
@@ -1123,10 +1129,15 @@ def get_test_library(
                 except BaseException:
                     pass
 
+        real_source = lib.source if lib is not None else source
         libdoc = LibraryDoc(
             name=library_name,
-            source=lib.source if lib is not None else source,
-            module_spec=module_spec,
+            source=real_source,
+            module_spec=module_spec
+            if module_spec is not None
+            and module_spec.origin != real_source
+            and module_spec.submodule_search_locations is None
+            else None,
             python_path=sys.path,
             type="LIBRARY",
         )
@@ -1151,8 +1162,10 @@ def get_test_library(
                             source=kw[0].source,
                             line_no=kw[0].lineno,
                             type="library",
-                            libname=kw[1].libname,
-                            longname=kw[1].longname,
+                            # libname=kw[1].libname,
+                            # longname=kw[1].longname,
+                            libname=libdoc.name,
+                            longname=f"{libdoc.name}.{kw[0].name}",
                             doc_format=str(lib.doc_format) or DEFAULT_DOC_FORMAT,
                             is_initializer=True,
                         )
@@ -1187,8 +1200,8 @@ def get_test_library(
                             tags=tuple(kw[0].tags),
                             source=kw[0].source,
                             line_no=kw[0].lineno,
-                            libname=kw[1].libname,
-                            longname=kw[1].longname,
+                            libname=libdoc.name,
+                            longname=f"{libdoc.name}.{kw[0].name}",
                             is_embedded=is_embedded_keyword(kw[0].name),
                             doc_format=str(lib.doc_format) or DEFAULT_DOC_FORMAT,
                             is_error_handler=kw[1].is_error_handler,

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -475,6 +475,11 @@ async def get_resources_matchers(self) -> Dict[KeywordMatcher, ResourceEntry]:
             }
         return self._resources_matchers
 
+    async def get_imported_variables(self) -> OrderedDict[str, VariablesEntry]:
+        await self.ensure_initialized()
+
+        return self._variables
+
     @_logger.call
     async def get_library_doc(self) -> LibraryDoc:
         if self._library_doc is None:

robotcode/language_server/robotframework/parts/goto.py

@@ -81,13 +81,17 @@ async def run() -> Union[Location, List[Location], List[LocationLink], None]:
             if result_node is None:
                 return None
 
+            result = await self._definition_default(result_nodes, document, position)
+            if result:
+                return result
+
             method = self._find_method(type(result_node))
             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)
+            return None
 
         return await run_coroutine_in_thread(run)
 

robotcode/language_server/robotframework/parts/hover.py

@@ -75,14 +75,18 @@ async def run() -> Optional[Hover]:
             if not result_nodes:
                 return None
 
+            result = await self._hover_default(result_nodes, document, position)
+            if result:
+                return result
+
             for result_node in reversed(result_nodes):
                 method = self._find_method(type(result_node))
                 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)
+            return None
 
         return await run_coroutine_in_thread(run)
 
@@ -118,6 +122,7 @@ async def _hover_default(self, nodes: List[ast.AST], document: TextDocument, pos
                                 ),
                                 range=range,
                             )
+
             except (SystemExit, KeyboardInterrupt, asyncio.CancelledError):
                 raise
             except BaseException: