robotcode-language-server 2.7.0__py3-none-any.whl → 2.8.0.dev8__py3-none-any.whl

robotcode/language_server/robotframework/parts/model_variables.py

@@ -0,0 +1,331 @@
+"""Model-path variable extraction shared by selection range, inline values,
+and debug evaluatable expressions.
+
+A faithful, self-contained port of the legacy
+`ModelHelper.iter_variables_from_token` / `iter_expression_variables_from_token`
+candidate semantics, operating on the `SemanticToken`s of a
+`SemanticStatement`:
+
+- variable occurrences are scanned from the token *values* of the cells the
+  legacy tokenizer type gate admits (arguments, names, keyword cells — not
+  comments or error tokens), in the same order legacy yields them: outer
+  variables before nested ones, the extended-syntax base name before the
+  full inner span;
+- resolution goes through `SemanticModel.find_variable()` (no `ModelHelper`,
+  no `Namespace` re-resolution on the model path);
+- bare-``$var`` expression references come from the pre-computed
+  `PYTHON_VARIABLE_REF` sub-tokens of `CONDITION` cells.
+
+Consumers differ only in how they use the candidates: selection range takes
+the first candidate whose range contains the cursor; inline values and debug
+extraction re-resolve the primary candidate of each occurrence at the
+debugger's stopped location and keep only found definitions.
+"""
+
+from dataclasses import dataclass
+from typing import Iterator, List, Optional
+
+from robotcode.core.lsp.types import Position, Range
+from robotcode.robot.diagnostics.semantic_analyzer.enums import NodeKind, TokenKind
+from robotcode.robot.diagnostics.semantic_analyzer.model import SemanticModel
+from robotcode.robot.diagnostics.semantic_analyzer.nodes import SemanticStatement, SemanticToken
+from robotcode.robot.diagnostics.semantic_analyzer.variable_tokenizer import (
+    _MATCH_EXTENDED,
+    _build_python_expression_sub_tokens,
+)
+from robotcode.robot.utils.variables import contains_variable, is_number_literal, search_variable
+
+# Statement cells the legacy `tokenize_variables` walk actually scans — its
+# type gate allows `Token.ALLOW_VARIABLES` (arguments, names, test-case and
+# keyword definition names) plus KEYWORD, ASSIGN, and OPTION cells;
+# `Token.VARIABLE` cells pass through whole. Comments, error tokens, setting
+# names, control-flow words, and structural tokens are never scanned.
+_SCANNABLE_KINDS = frozenset(
+    {
+        TokenKind.ARGUMENT,
+        TokenKind.TAG,
+        TokenKind.CONDITION,
+        TokenKind.NAMED_ARGUMENT_NAME,
+        TokenKind.NAMED_ARGUMENT_VALUE,
+        TokenKind.PARAMETER,
+        TokenKind.OPTION,
+        TokenKind.OPTION_NAME,
+        TokenKind.OPTION_VALUE,
+        TokenKind.TEST_NAME,
+        TokenKind.KEYWORD_NAME,
+        TokenKind.KEYWORD,
+        TokenKind.KEYWORD_INNER,
+        TokenKind.BDD_PREFIX,
+        TokenKind.NAMESPACE,
+        TokenKind.IMPORT_NAME,
+        TokenKind.VARIABLE,
+        TokenKind.VARIABLE_NOT_FOUND,
+        TokenKind.VARIABLE_NAME,
+    }
+)
+
+
+def scannable_statement_tokens(stmt: SemanticStatement) -> List[SemanticToken]:
+    """The top-level tokens of a statement that the legacy variable iteration
+    would scan (see the `_SCANNABLE_KINDS` gate above)."""
+    return [token for token in stmt.tokens if token.kind in _SCANNABLE_KINDS]
+
+
+@dataclass
+class ModelVariableCandidate:
+    """One selectable/resolvable variable occurrence candidate."""
+
+    range: Range
+    lookup_name: str
+    primary: bool
+    """True for the first candidate of an occurrence — the one whose lookup
+    name mirrors the legacy resolution (extended syntax resolves the base)."""
+
+
+# Statements whose variable-family cells come from `Token.VARIABLE` in the
+# AST (definition names, FOR/EXCEPT/VAR targets) — outside the legacy
+# tokenizer's type gate. Assign targets in keyword calls / inline IF are
+# `Token.ASSIGN` and tokenize normally.
+_UNGATED_STMT_KINDS = frozenset({NodeKind.VARIABLE_DEF, NodeKind.FOR_HEADER, NodeKind.EXCEPT_HEADER})
+
+
+def iter_model_variable_candidates(
+    token: SemanticToken,
+    model: SemanticModel,
+    resolve_line: int,
+    resolve_col: Optional[int] = None,
+    stmt_kind: Optional[NodeKind] = None,
+) -> Iterator[ModelVariableCandidate]:
+    """Yield the regular variable candidates of one statement token in legacy
+    order (`iter_variables_from_token`).
+
+    ``resolve_line`` / ``resolve_col`` form the position used for
+    visibility-aware lookups (the cursor position for selection range, the
+    debugger's stopped location for inline values). ``stmt_kind`` is the
+    containing statement's kind — it decides whether a variable-family cell
+    is a `Token.VARIABLE` (processed whole, outside the legacy tokenizer's
+    type gate) or a tokenized `Token.ASSIGN`.
+    """
+    if token.value and token.col_offset is not None:
+        ungated = stmt_kind in _UNGATED_STMT_KINDS and token.kind in (
+            TokenKind.VARIABLE,
+            TokenKind.VARIABLE_NOT_FOUND,
+            TokenKind.VARIABLE_NAME,
+        )
+        yield from _scan_value(token.value, token.line, token.col_offset, ungated, model, resolve_line, resolve_col)
+
+
+def iter_condition_ref_candidates(token: SemanticToken) -> Iterator[ModelVariableCandidate]:
+    """Yield the bare ``$var`` expression-reference candidates of a
+    `CONDITION` cell from its pre-computed `PYTHON_VARIABLE_REF` sub-tokens
+    (legacy `iter_expression_variables_from_token`). Used by inline values
+    and debug extraction, but not by selection range."""
+    if token.kind is not TokenKind.CONDITION:
+        return
+    for sub in token.sub_tokens or []:
+        if sub.kind is TokenKind.PYTHON_VARIABLE_REF:
+            yield from _expression_ref_candidate(sub)
+
+
+def _scan_value(
+    value: str,
+    line: int,
+    col_offset: int,
+    ungated: bool,
+    model: SemanticModel,
+    resolve_line: int,
+    resolve_col: Optional[int],
+) -> Iterator[ModelVariableCandidate]:
+    """Scan a value fragment for variable occurrences, mirroring the legacy
+    `tokenize_variables` walk (outer occurrence first, then its index-access
+    content and the rest of the fragment)."""
+    pos = 0
+    while pos < len(value):
+        matcher = search_variable(value[pos:], "$@&%", ignore_errors=True)
+        base = matcher.base
+        if base is None:
+            if ungated and pos == 0 and len(value) >= 2 and value[0] in "$@&%" and value[1] == "{":
+                # Unclosed variable at the start of the cell (`${aaa`):
+                # legacy yields the whole raw token
+                # (`strip_variable_token` leaves unparseable values untouched).
+                yield ModelVariableCandidate(
+                    range=_make_range(line, col_offset, len(value)),
+                    lookup_name=value,
+                    primary=True,
+                )
+            return
+
+        var_start = pos + matcher.start
+        name = matcher.name or ""
+        if not name:
+            # `${}` / `@{}`: legacy yields the whole unstripped remainder once
+            # and stops scanning the token.
+            span = value[var_start : pos + matcher.end] or value[var_start:]
+            yield ModelVariableCandidate(
+                range=_make_range(line, col_offset + var_start, len(span)),
+                lookup_name=span,
+                primary=True,
+            )
+            return
+
+        yield from _occurrence_candidates(
+            name, base, line, col_offset + var_start, ungated, model, resolve_line, resolve_col
+        )
+        if ungated:
+            # An ungated cell is processed as a single whole occurrence.
+            return
+
+        # Continue right after the variable's closing brace: index-access
+        # content (`${x}[${i}]`) and the remaining text are scanned like the
+        # legacy rest-recursion.
+        pos = var_start + len(name)
+
+
+def _occurrence_candidates(
+    name: str,
+    base: str,
+    line: int,
+    col_offset: int,
+    ungated: bool,
+    model: SemanticModel,
+    resolve_line: int,
+    resolve_col: Optional[int],
+) -> Iterator[ModelVariableCandidate]:
+    """Candidates of one well-formed variable occurrence ``name`` (e.g.
+    ``${obj.attr}``) whose ``$`` sits at ``col_offset``.
+
+    Mirrors the legacy resolution order: raw lookup → number-literal skip →
+    extended-syntax base lookup → not-found candidates; nested variables
+    always follow their container.
+    """
+    if base.startswith("{") and base.endswith("}"):
+        # `${{expr}}`: only bare `$var` refs inside the expression count.
+        yield from _python_expression_candidates(base[1:-1], line, col_offset + 3)
+        return
+
+    nested = contains_variable(base, "$@&%")
+    stripped = base.strip()
+    inner_range = _make_range(
+        line,
+        col_offset + 2 + (len(base) - len(base.lstrip())),
+        len(stripped),
+    )
+
+    if model.find_variable(name, resolve_line, resolve_col, extended=False) is not None:
+        # Raw name resolves (including literal names with spaces or nested
+        # syntax, e.g. a definition row `${VALID VAR ${A}}`).
+        yield ModelVariableCandidate(range=inner_range, lookup_name=name, primary=True)
+    elif is_number_literal(name):
+        # Number literals (`${42}`, `${0x1F}`) are values, not variables.
+        pass
+    else:
+        extended = _MATCH_EXTENDED.match(base)
+        if extended is not None:
+            base_name = extended.group(1).strip()
+            base_lookup = f"{name[0]}{{{base_name}}}"
+            base_range = _make_range(line, col_offset + 2, len(base_name))
+            if base_name and not contains_variable(base_name, "$@&%"):
+                if model.find_variable(base_lookup, resolve_line, resolve_col, extended=False) is not None:
+                    yield ModelVariableCandidate(range=base_range, lookup_name=base_lookup, primary=True)
+                elif not is_number_literal(base_lookup) and not contains_variable(base, "$@&"):
+                    # Legacy quirk: the unresolved-container check runs with
+                    # the default `$@&` identifiers, so `%{}`-only nesting
+                    # still yields the not-found pair.
+                    yield ModelVariableCandidate(range=base_range, lookup_name=base_lookup, primary=True)
+                    yield ModelVariableCandidate(range=inner_range, lookup_name=name, primary=False)
+        elif not nested:
+            yield ModelVariableCandidate(range=inner_range, lookup_name=name, primary=True)
+
+    if nested:
+        if ungated:
+            # Legacy re-slices ungated containers raw (`value[2:-1]`) instead
+            # of tokenizing them: the whole inner span comes back once as an
+            # unresolvable pseudo-variable; the nested variables themselves
+            # are never reached.
+            yield ModelVariableCandidate(
+                range=_make_range(line, col_offset + 2, len(base)),
+                lookup_name=base,
+                primary=True,
+            )
+            return
+        # Nested occurrences inside the container's braces.
+        yield from _scan_value(base, line, col_offset + 2, False, model, resolve_line, resolve_col)
+
+
+def _python_expression_candidates(expr: str, line: int, col_offset: int) -> Iterator[ModelVariableCandidate]:
+    """Name-only candidates for the ``$var`` refs of a `${{expr}}` body,
+    positions identical to the analyzer's `PYTHON_VARIABLE_REF` sub-tokens."""
+    for ref in _build_python_expression_sub_tokens(expr, line, col_offset) or []:
+        yield from _expression_ref_candidate(ref)
+
+
+def _expression_ref_candidate(ref: SemanticToken) -> Iterator[ModelVariableCandidate]:
+    """Name-only candidate of a `PYTHON_VARIABLE_REF` (`$var` → `var`)."""
+    if ref.length <= 1:
+        return
+    name = ref.value[1:] if ref.value.startswith("$") else ref.value
+    yield ModelVariableCandidate(
+        range=_make_range(ref.line, ref.col_offset + 1, ref.length - 1),
+        lookup_name=f"${{{name}}}",
+        primary=True,
+    )
+
+
+def _make_range(line: int, col_offset: int, length: int) -> Range:
+    return Range(
+        start=Position(line=line - 1, character=col_offset),
+        end=Position(line=line - 1, character=col_offset + length),
+    )
+
+
+def iter_statement_tokens_at_line(model: SemanticModel, line: int) -> Iterator[SemanticToken]:
+    """Scannable top-level tokens of every statement covering a 1-indexed
+    line.
+
+    A line can hold several statements (inline `IF` header plus its branch
+    calls), so the single most-specific `statement_at()` result is not
+    enough for position-based candidate searches.
+    """
+    for stmt in model.statements:
+        if stmt.line_start <= line <= stmt.line_end:
+            yield from scannable_statement_tokens(stmt)
+
+
+def iter_line_variable_candidates(
+    model: SemanticModel,
+    line: int,
+    resolve_col: Optional[int] = None,
+) -> Iterator[ModelVariableCandidate]:
+    """Regular variable candidates of every statement covering a 1-indexed
+    line."""
+    for stmt in model.statements:
+        if stmt.line_start <= line <= stmt.line_end:
+            for token in scannable_statement_tokens(stmt):
+                yield from iter_model_variable_candidates(token, model, line, resolve_col, stmt.kind)
+
+
+def iter_line_condition_ref_candidates(model: SemanticModel, line: int) -> Iterator[ModelVariableCandidate]:
+    """Bare ``$var`` expression-reference candidates of every condition cell
+    on a 1-indexed line."""
+    for stmt in model.statements:
+        if stmt.line_start <= line <= stmt.line_end:
+            for token in stmt.tokens:
+                yield from iter_condition_ref_candidates(token)
+
+
+def find_model_variable_range_at(
+    model: SemanticModel,
+    position: Position,
+    within: Range,
+) -> Optional[Range]:
+    """First candidate range containing the position — the model-path
+    replacement for the legacy selection-range variable step.
+
+    ``within`` is the range of the AST token under the cursor: legacy only
+    iterates the variables of that one token, so candidates outside it (a
+    neighbouring cell whose end touches the position) must not match.
+    """
+    for candidate in iter_line_variable_candidates(model, position.line + 1, position.character):
+        if position in candidate.range and candidate.range.start >= within.start and candidate.range.end <= within.end:
+            return candidate.range
+    return None

robotcode/language_server/robotframework/parts/references.py

@@ -26,6 +26,7 @@ from robotcode.robot.diagnostics.entities import (
     ResourceEntry,
     VariableDefinition,
     VariableDefinitionType,
+    VariablesEntry,
 )
 from robotcode.robot.diagnostics.library_doc import (
     RESOURCE_FILE_EXTENSION,
@@ -33,7 +34,6 @@ from robotcode.robot.diagnostics.library_doc import (
     KeywordDoc,
     LibraryDoc,
 )
-from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.diagnostics.namespace import Namespace
 from robotcode.robot.utils import RF_VERSION
 from robotcode.robot.utils.ast import (
@@ -55,7 +55,7 @@ _ReferencesMethod = Callable[
 ]
 
 
-class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -68,7 +68,7 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         parent.references.collect.add(self.collect)
         parent.documents.did_change.add(self.document_did_change)
-        parent.documents.on_document_cache_invalidated(self.document_did_change)
+        parent.documents.on_document_cache_invalidated.add(self.document_did_change)
         parent.diagnostics.on_workspace_diagnostics_break.add(self.on_workspace_diagnostics_break)
 
     @event
@@ -80,7 +80,8 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
             f"**/*.{{{ROBOT_FILE_EXTENSION[1:]},{RESOURCE_FILE_EXTENSION[1:]}}}",
             WatchKind.CREATE | WatchKind.DELETE,
         )
-        self.parent.documents_cache.namespace_invalidated(self.namespace_invalidated)
+        self.parent.documents_cache.namespace_invalidated.add(self.namespace_invalidated)
+        self.parent.documents_cache.namespace_initialized.add(self.namespace_initialized)
 
     def do_on_file_changed(self, sender: Any, files: List[FileEvent]) -> None:
         self.clear_cache()
@@ -93,6 +94,11 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
     def namespace_invalidated(self, sender: Any, namespace: Namespace) -> None:
         self.clear_cache()
 
+    @language_id("robotframework")
+    def namespace_initialized(self, sender: Any, namespace: Namespace) -> None:
+        # the new analysis changed the index, so a result found before it can miss its references
+        self.clear_cache()
+
     def on_workspace_diagnostics_break(self, sender: Any) -> None:
         self.clear_cache()
 
@@ -144,7 +150,37 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
             if result is not None:
                 return result
 
-        return None
+        return self._references_at_namespace_prefix(document, position, context)
+
+    def _references_at_namespace_prefix(
+        self,
+        document: TextDocument,
+        position: Position,
+        context: ReferenceContext,
+    ) -> Optional[List[Location]]:
+        namespace = self.parent.documents_cache.get_namespace(document)
+
+        # the analysis keeps the range of every prefix of a keyword call, keyed by the library or resource it names
+        entries = [
+            entry
+            for entry, locations in namespace.namespace_references.items()
+            if not isinstance(entry, VariablesEntry) and any(position in location.range for location in locations)
+        ]
+        if not entries:
+            return None
+
+        # a prefix has the references of the import it names
+        result: List[Location] = []
+        for entry in entries:
+            if isinstance(entry, ResourceEntry):
+                result.extend(self._resource_references(document, entry, context))
+            elif entry.alias:
+                result.extend(self._library_alias_references(document, entry, context))
+            else:
+                result.extend(self._library_references(document, entry.library_doc))
+
+        # a prefix can name more than one entry, and their answers overlap
+        return list(dict.fromkeys(result))
 
     def _find_references_in_workspace(
         self,
@@ -224,10 +260,7 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         include_declaration: bool = True,
         stop_at_first: bool = False,
     ) -> List[Location]:
-        result = []
-
-        if include_declaration and variable.source:
-            result.append(Location(str(Uri.from_path(variable.source)), variable.name_range))
+        result: List[Location] = []
 
         if variable.type == VariableDefinitionType.LOCAL_VARIABLE:
             result.extend(self.find_variable_references_in_file(document, variable, False))
@@ -237,6 +270,11 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                 result.append(next(iter(refs)))
             else:
                 result.extend(refs)
+
+        # the declaration last: LSP4IJ searches from the first location, and finds nothing in a Python file
+        if include_declaration and variable.source:
+            result.append(Location(str(Uri.from_path(variable.source)), variable.name_range))
+
         return result
 
     @_logger.call
@@ -315,33 +353,37 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
     ) -> List[Location]:
         result = []
 
-        if include_declaration and kw_doc.source:
-            result.append(Location(str(Uri.from_path(kw_doc.source)), kw_doc.range))
-
         refs = self.parent.documents_cache.get_project_index(document).find_keyword_references(kw_doc)
         if stop_at_first and refs:
             result.append(next(iter(refs)))
         else:
             result.extend(refs)
 
+        # the declaration last: LSP4IJ searches from the first location, and finds nothing in a Python file
+        if include_declaration and kw_doc.source:
+            result.append(Location(str(Uri.from_path(kw_doc.source)), kw_doc.range))
+
         return result
 
     @_logger.call
     def _find_library_import_references_in_file(self, doc: TextDocument, library_doc: LibraryDoc) -> List[Location]:
         namespace = self.parent.documents_cache.get_namespace(doc)
 
-        result: List[Location] = []
-        for lib_entry in namespace.libraries.values():
-            if (
-                lib_entry.import_source == str(doc.uri.to_path())
-                and lib_entry.library_doc.source_or_origin == library_doc.source_or_origin
-            ):
-                result.append(Location(str(doc.uri), lib_entry.import_range))
-
+        # every import statement, also one of a library that is already imported
+        result: List[Location] = [
+            Location(str(doc.uri), lib_entry.import_range)
+            for lib_entry in namespace.import_entries.values()
+            if not isinstance(lib_entry, (ResourceEntry, VariablesEntry))
+            and lib_entry.import_source == str(doc.uri.to_path())
+            and lib_entry.library_doc.source_or_origin == library_doc.source_or_origin
+            and lib_entry.library_doc.name == library_doc.name
+        ]
+
+        # the analysis also keeps a repeated import as a reference of the first one
         references = namespace.namespace_references
         for k, v in references.items():
             if not k.alias and k.library_doc == library_doc:
-                result.extend(v)
+                result.extend(location for location in v if location not in result)
 
         return result
 
@@ -379,12 +421,7 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
             if library_doc is None:
                 return None
 
-            return self._find_references_in_workspace(
-                document,
-                False,
-                self._find_library_import_references_in_file,
-                library_doc,
-            )
+            return self._library_references(document, library_doc)
 
         separator = import_node.get_token(RobotToken.WITH_NAME)
         alias_token = import_node.get_tokens(RobotToken.NAME)[-1] if separator else None
@@ -404,6 +441,19 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         if entry is None:
             return None
 
+        return self._library_alias_references(document, entry, context)
+
+    def _library_references(self, document: TextDocument, library_doc: LibraryDoc) -> List[Location]:
+        return self._find_references_in_workspace(
+            document,
+            False,
+            self._find_library_import_references_in_file,
+            library_doc,
+        )
+
+    def _library_alias_references(
+        self, document: TextDocument, entry: LibraryEntry, context: ReferenceContext
+    ) -> List[Location]:
         result = list(self.parent.documents_cache.get_project_index(document).find_namespace_references(entry))
 
         if context.include_declaration and entry.import_source:
@@ -415,17 +465,20 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
     def _find_resource_import_references_in_file(self, doc: TextDocument, entry: ResourceEntry) -> List[Location]:
         namespace = self.parent.documents_cache.get_namespace(doc)
 
-        result: List[Location] = []
-        for lib_entry in namespace.resources.values():
-            if (
-                lib_entry.import_source == str(doc.uri.to_path())
-                and lib_entry.library_doc.source == entry.library_doc.source
-            ):
-                result.append(Location(str(doc.uri), lib_entry.import_range))
+        # every import statement, also one of a resource file that is already imported
+        result: List[Location] = [
+            Location(str(doc.uri), lib_entry.import_range)
+            for lib_entry in namespace.import_entries.values()
+            if isinstance(lib_entry, ResourceEntry)
+            and lib_entry.import_source == str(doc.uri.to_path())
+            and lib_entry.library_doc.source == entry.library_doc.source
+        ]
 
+        # the calls with the resource's name as prefix, in every file that imports the resource
         references = namespace.namespace_references
-        if entry in references:
-            result.extend(references[entry])
+        for k, v in references.items():
+            if isinstance(k, ResourceEntry) and k.library_doc.source == entry.library_doc.source:
+                result.extend(location for location in v if location not in result)
 
         return result
 
@@ -448,12 +501,14 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         if not name_token:
             return None
 
-        entries = namespace.resources
+        # the entry of this statement, also of a repeated import of the resource file
         entry = next(
             (
                 v
-                for v in entries.values()
-                if v.import_source == namespace.source and v.import_range == range_from_token(name_token)
+                for v in namespace.import_entries.values()
+                if isinstance(v, ResourceEntry)
+                and v.import_source == namespace.source
+                and v.import_range == range_from_token(name_token)
             ),
             None,
         )
@@ -461,6 +516,11 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         if entry is None:
             return None
 
+        return self._resource_references(document, entry, context)
+
+    def _resource_references(
+        self, document: TextDocument, entry: ResourceEntry, context: ReferenceContext
+    ) -> List[Location]:
         result = self._find_references_in_workspace(
             document,
             False,
@@ -484,12 +544,14 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
     def _find_variables_import_references_in_file(self, doc: TextDocument, library_doc: LibraryDoc) -> List[Location]:
         namespace = self.parent.documents_cache.get_namespace(doc)
 
-        result: List[Location] = []
-        for lib_entry in namespace.variables_imports.values():
-            if lib_entry.import_source == str(doc.uri.to_path()) and lib_entry.library_doc.source == library_doc.source:
-                result.append(Location(str(doc.uri), lib_entry.import_range))
-
-        return result
+        # every import statement, also one of a variable file that is already imported
+        return [
+            Location(str(doc.uri), lib_entry.import_range)
+            for lib_entry in namespace.import_entries.values()
+            if isinstance(lib_entry, VariablesEntry)
+            and lib_entry.import_source == str(doc.uri.to_path())
+            and lib_entry.library_doc.source == library_doc.source
+        ]
 
     def references_VariablesImport(  # noqa: N802
         self,

robotcode/language_server/robotframework/parts/rename.py

@@ -33,7 +33,6 @@ from robotcode.robot.diagnostics.entities import (
     VariableDefinitionType,
 )
 from robotcode.robot.diagnostics.library_doc import KeywordDoc
-from robotcode.robot.diagnostics.model_helper import ModelHelper
 
 from ...common.parts.rename import CantRenameError
 from .protocol_part import RobotLanguageServerProtocolPart
@@ -48,7 +47,7 @@ _PrepareRenameMethod = Callable[[ast.AST, TextDocument, Position], Optional[Prep
 _T = TypeVar("_T", bound=Callable[..., Any])
 
 
-class RobotRenameProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotRenameProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None: