robotcode-language-server 2.6.2__py3-none-any.whl → 2.8.0.dev548__py3-none-any.whl

robotcode/language_server/robotframework/parts/debugging_utils.py

@@ -3,24 +3,30 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional
 
-from robot.parsing.model.statements import Statement
+from robot.parsing.model.statements import IfElseHeader, Statement, WhileHeader
 
 from robotcode.core.lsp.types import Position, Range, TextDocumentIdentifier
 from robotcode.core.utils.dataclasses import CamelSnakeMixin
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
 from robotcode.robot.diagnostics.model_helper import ModelHelper
+from robotcode.robot.diagnostics.semantic_analyzer.model import SemanticModel
 from robotcode.robot.utils.ast import (
     get_nodes_at_position,
     get_tokens_at_position,
     range_from_token,
 )
 
+from .model_variables import iter_line_condition_ref_candidates, iter_line_variable_candidates
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
+# The statements whose first argument cell is an expression (legacy
+# `ModelHelper.get_expression_statement_types()`).
+_EXPRESSION_STATEMENT_TYPES = (IfElseHeader, WhileHeader)
+
 
 @dataclass(repr=False)
 class EvaluatableExpressionParams(CamelSnakeMixin):
@@ -34,12 +40,61 @@ class EvaluatableExpression(CamelSnakeMixin):
     expression: Optional[str]
 
 
-class RobotDebuggingUtilsProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotDebuggingUtilsProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         super().__init__(parent)
 
+    @staticmethod
+    def _find_model_expression(
+        semantic_model: SemanticModel,
+        position: Position,
+        token_range: Range,
+        expression_range: Optional[Range],
+    ) -> Optional[EvaluatableExpression]:
+        """Model path: first resolvable variable occurrence at the position.
+
+        Mirrors the legacy two-step lookup: regular variables limited to the
+        AST token under the cursor first, then — only when the cursor sits in
+        the condition cell of an expression statement (``expression_range``) —
+        the bare ``$var`` expression references as fallback.
+        """
+        line, col = position.line + 1, position.character
+
+        found: Optional[tuple[Range, Any]] = None
+        for candidate in iter_line_variable_candidates(semantic_model, line, col):
+            if (
+                position not in candidate.range
+                or candidate.range.start < token_range.start
+                or candidate.range.end > token_range.end
+            ):
+                continue
+            # `extended=False`: the extended-syntax fallback is already
+            # encoded in the candidates' lookup names.
+            var = semantic_model.find_variable(candidate.lookup_name, line, col, extended=False)
+            if var is not None:
+                found = (candidate.range, var)
+                break
+
+        if found is None and expression_range is not None and position in expression_range:
+            for candidate in iter_line_condition_ref_candidates(semantic_model, line):
+                if position not in candidate.range:
+                    continue
+                var = semantic_model.find_variable(candidate.lookup_name, line, col, extended=False)
+                if var is not None:
+                    found = (candidate.range, var)
+                    break
+
+        if found is None:
+            return None
+
+        var_range, var = found
+        if var.name == "${CURDIR}":
+            return None
+
+        return EvaluatableExpression(var_range, var.name)
+
     @rpc_method(name="robot/debugging/getEvaluatableExpression", param_type=EvaluatableExpressionParams, threaded=True)
     @_logger.call
     async def _get_evaluatable_expression(
@@ -59,17 +114,31 @@ class RobotDebuggingUtilsProtocolPart(RobotLanguageServerProtocolPart, ModelHelp
         model = self.parent.documents_cache.get_model(document)
 
         nodes = get_nodes_at_position(model, position)
+        if not nodes:
+            return None
         node = nodes[-1]
 
         if not isinstance(node, Statement):
             return None
 
-        token = get_tokens_at_position(node, position)[-1]
+        tokens = get_tokens_at_position(node, position)
+        if not tokens:
+            return None
+        token = tokens[-1]
+
+        semantic_model = namespace.semantic_model
+        if semantic_model is not None:
+            expression_range: Optional[Range] = None
+            if isinstance(node, _EXPRESSION_STATEMENT_TYPES):
+                arg_token = node.get_token(RobotToken.ARGUMENT)
+                if arg_token is not None:
+                    expression_range = range_from_token(arg_token)
+            return self._find_model_expression(semantic_model, position, range_from_token(token), expression_range)
 
         token_and_var = next(
             (
                 (t, v)
-                for t, v in self.iter_variables_from_token(token, namespace, position)
+                for t, v in ModelHelper.iter_variables_from_token(token, namespace, position)
                 if position in range_from_token(t)
             ),
             None,
@@ -77,14 +146,14 @@ class RobotDebuggingUtilsProtocolPart(RobotLanguageServerProtocolPart, ModelHelp
 
         if (
             token_and_var is None
-            and isinstance(node, self.get_expression_statement_types())
+            and isinstance(node, ModelHelper.get_expression_statement_types())
             and (token := node.get_token(RobotToken.ARGUMENT)) is not None
             and position in range_from_token(token)
         ):
             token_and_var = next(
                 (
                     (var_token, var)
-                    for var_token, var in self.iter_expression_variables_from_token(token, namespace, position)
+                    for var_token, var in ModelHelper.iter_expression_variables_from_token(token, namespace, position)
                     if position in range_from_token(var_token)
                 ),
                 None,

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -1,7 +1,7 @@
 from concurrent.futures import CancelledError
 from typing import TYPE_CHECKING, Any, List, Optional
 
-from robotcode.core.concurrent import check_current_task_canceled
+from robotcode.core.concurrent import check_current_task_canceled, run_as_task
 from robotcode.core.language import language_id
 from robotcode.core.lsp.types import (
     Diagnostic,
@@ -50,7 +50,8 @@ class RobotDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
 
     def _on_initialized(self, sender: Any) -> None:
         self.parent.diagnostics.analyze.add(self.analyze)
-        self.parent.documents_cache.namespace_initialized(self._on_namespace_initialized)
+        self.parent.documents_cache.namespace_initialized.add(self._on_namespace_initialized)
+        self.parent.documents_cache.namespace_invalidated.add(self._on_namespace_invalidated)
         self.parent.documents_cache.libraries_changed.add(self._on_libraries_changed)
         self.parent.documents_cache.resources_changed.add(self._on_resources_changed)
         self.parent.documents_cache.variables_changed.add(self._on_variables_changed)
@@ -85,8 +86,19 @@ class RobotDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
 
     @language_id("robotframework")
     def _on_namespace_initialized(self, sender: Any, namespace: Namespace) -> None:
+        # only a document open in the editor: a closed one gets its diagnostics renewed through the invalidation
+        # that started the rebuild or through its own changes, marking it again would analyze it once more
+        if namespace.document is not None and namespace.document.opened_in_editor:
+            # the namespace is initialized under the lock of the document's cache entry, while the diagnostics
+            # loop holds the diagnostics lock when it waits for a task that may wait for that entry
+            run_as_task(self.parent.diagnostics.force_refresh_document, namespace.document)
+
+    @language_id("robotframework")
+    def _on_namespace_invalidated(self, sender: Any, namespace: Namespace) -> None:
         if namespace.document is not None:
-            self.parent.diagnostics.force_refresh_document(namespace.document)
+            # also a closed document: the workspace diagnostics loop renews its analysis, which refreshes its
+            # references and diagnostics
+            run_as_task(self.parent.diagnostics.force_refresh_document, namespace.document)
 
     @language_id("robotframework")
     def _on_get_related_documents(self, sender: Any, document: TextDocument) -> Optional[List[TextDocument]]:

robotcode/language_server/robotframework/parts/documents_cache.py

@@ -38,8 +38,12 @@ class DocumentsCachePart(RobotLanguageServerProtocolPart, DocumentsCacheHelper):
         )
 
     def calc_cache_path(self, folder_uri: Uri) -> Path:
-        cache_config = self.parent.workspace.get_configuration(CacheConfig, folder_uri)
         cache_base_path = folder_uri.to_path()
+        # `cache-dir` of the robot.toml wins over the location the editor asks for.
+        if self.analysis_config.cache_dir:
+            return cache_base_path / self.analysis_config.cache_dir
+
+        cache_config = self.parent.workspace.get_configuration(CacheConfig, folder_uri)
         if (
             cache_config.save_location == CacheSaveLocation.WORKSPACE_STORAGE
             and isinstance(self.parent.initialization_options, dict)

robotcode/language_server/robotframework/parts/hover.py

@@ -12,9 +12,10 @@ from typing import (
     cast,
 )
 
+from robot.model.metadata import Metadata as RobotMetadata
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.blocks import TestCase, TestCaseSection
-from robot.parsing.model.statements import Documentation, Tags
+from robot.parsing.model.statements import Documentation, Metadata, Tags
 
 from robotcode.core.concurrent import check_current_task_canceled
 from robotcode.core.language import language_id
@@ -27,15 +28,24 @@ from robotcode.core.lsp.types import (
 )
 from robotcode.core.text_document import TextDocument
 from robotcode.core.utils.logging import TRACE, LoggingDescriptor
-from robotcode.robot.diagnostics.entities import VariableDefinitionType
-from robotcode.robot.diagnostics.model_helper import ModelHelper
+from robotcode.robot.diagnostics.entities import (
+    LibraryEntry,
+    ResourceEntry,
+    VariableDefinitionType,
+    VariablesEntry,
+)
+from robotcode.robot.diagnostics.library_doc import KeywordDoc
+from robotcode.robot.diagnostics.namespace import Namespace
 from robotcode.robot.utils.ast import (
     get_nodes_at_position,
     range_from_node,
     range_from_token,
 )
+from robotcode.robot.utils.markdown_docs import LinkResolver, replace_anchor_links
 from robotcode.robot.utils.markdownformatter import MarkDownFormatter
+from robotcode.robot.utils.variables import contains_variable
 
+from .code_action_documentation import DocumentationTarget, keyword_reference_targets, link_documentation
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:
@@ -54,7 +64,7 @@ class MyRepr(reprlib.Repr):
 _my_repr = MyRepr()
 
 
-class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotHoverProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -176,7 +186,7 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         all_kw_refs = namespace.keyword_references
         if all_kw_refs:
-            result: List[Tuple[Range, str]] = []
+            result: List[Tuple[Range, KeywordDoc]] = []
 
             for kw, kw_refs in all_kw_refs.items():
                 check_current_task_canceled()
@@ -191,23 +201,20 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                 )
 
                 if found_range is not None:
-                    if kw.libtype == "RESOURCE":
-                        txt = kw.to_markdown(
-                            modify_doc_handler=lambda t: namespace.imports_manager.replace_variables_scalar(
-                                t,
-                                str(document.uri.to_path().parent),
-                                namespace.get_resolvable_variables(),
-                                ignore_errors=True,
-                            )
-                        )
-                    else:
-                        txt = kw.to_markdown()
-
-                    result.append((found_range, txt))
+                    result.append((found_range, kw))
             if result:
                 r = result[0][0]
                 if all(r == i[0] for i in result):
-                    doc = "\n\n---\n\n".join(i[1] for i in result)
+                    links = self.parent.robot_initialization_options.documentation_viewer_links
+                    # a call that matches several keywords has no target
+                    target = (
+                        self.parent.robot_code_action_documentation.target_at(document, Range(position, position))
+                        if links and len(result) == 1
+                        else None
+                    )
+                    doc = "\n\n---\n\n".join(
+                        self._keyword_markdown(i[1], document, namespace, links, target) for i in result
+                    )
 
                     return Hover(
                         contents=MarkupContent(kind=MarkupKind.MARKDOWN, value=doc),
@@ -236,13 +243,73 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                     return Hover(
                         contents=MarkupContent(
                             kind=MarkupKind.MARKDOWN,
-                            value=ns.library_doc.to_markdown(),
+                            value=self._namespace_markdown(ns, document, namespace, position),
                         ),
                         range=found_range,
                     )
 
         return None
 
+    def _keyword_markdown(
+        self,
+        kw: KeywordDoc,
+        document: TextDocument,
+        namespace: Namespace,
+        links: bool,
+        target: Optional[DocumentationTarget],
+    ) -> str:
+        modify_doc_handler: Optional[Callable[[str], str]] = None
+        if kw.libtype == "RESOURCE":
+
+            def modify_doc_handler(t: str) -> str:
+                # without a variable, the replacement only doubles each backslash, which breaks escaped link texts
+                if links and not contains_variable(t, "$@&%"):
+                    return t
+                return cast(
+                    str,
+                    namespace.imports_manager.replace_variables_scalar(
+                        t,
+                        str(document.uri.to_path().parent),
+                        namespace.get_resolvable_variables(),
+                        ignore_errors=True,
+                    ),
+                )
+
+        def render(link_resolver: Optional[LinkResolver]) -> str:
+            return kw.to_markdown(
+                modify_doc_handler=modify_doc_handler,
+                link_resolver=link_resolver,
+                reference_targets=keyword_reference_targets(kw, link_resolver is not None),
+            )
+
+        if not links:
+            return render(None)
+        link_resolver = (
+            self.parent.robot_code_action_documentation.link_resolver(document, namespace, target, kw.parent)
+            if target is not None and kw.parent is not None
+            else None
+        )
+        return link_documentation(render, target, kw.parent, link_resolver=link_resolver)
+
+    def _namespace_markdown(
+        self, ns: LibraryEntry, document: TextDocument, namespace: Namespace, position: Position
+    ) -> str:
+        if not self.parent.robot_initialization_options.documentation_viewer_links:
+            return ns.library_doc.to_markdown()
+
+        target: Optional[DocumentationTarget] = None
+        if not isinstance(ns, VariablesEntry):
+            documentation = self.parent.robot_code_action_documentation
+            # on an import name the target of the source actions, which knows the import's own
+            # arguments; on an alias or a prefix the page of the hovered import
+            target = documentation.target_at(document, Range(position, position))
+            if target is None or target.keyword is not None:
+                target = documentation.entry_target(ns, not isinstance(ns, ResourceEntry), document, namespace)
+
+        return link_documentation(
+            lambda link_resolver: ns.library_doc.to_markdown(link_resolver=link_resolver), target, ns.library_doc
+        )
+
     def hover_TestCase(  # noqa: N802
         self,
         node: ast.AST,
@@ -262,6 +329,10 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         doc = next((e for e in test_case.body if isinstance(e, Documentation)), None)
         tags = next((e for e in test_case.body if isinstance(e, Tags)), None)
+        # Robot Framework's own mapping: names are case, space and underscore insensitive, the
+        # first spelling is kept, the last value wins and the entries are sorted by name.
+        # A `[Metadata]` setting with nothing after it is no metadata.
+        metadata = RobotMetadata((e.name, e.value) for e in test_case.body if isinstance(e, Metadata) and e.name)
 
         section = next((e for e in nodes if isinstance(e, TestCaseSection)), None)
         if section is not None and section.tasks:
@@ -277,13 +348,24 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
             txt += "\n*Tags*: "
             txt += f"{', '.join(tags.values)}\n"
 
+        if metadata:
+            txt += "\n*Metadata*:\n"
+            for name, value in metadata.items():
+                # list items keep one line per entry, indented lines continue a multi-line value
+                value = value.replace("\n", "\n  ")
+                txt += f"- {name}: {value}\n"
+
         txt = namespace.imports_manager.replace_variables_scalar(
             txt,
             str(document.uri.to_path().parent),
             namespace.get_resolvable_variables(),
             ignore_errors=True,
         )
+        txt = MarkDownFormatter().format(txt)
+        if self.parent.robot_initialization_options.documentation_viewer_links:
+            # a test case has no page, links to a place in its documentation would open nothing
+            txt = replace_anchor_links(txt, lambda anchor: None)
         return Hover(
-            contents=MarkupContent(kind=MarkupKind.MARKDOWN, value=MarkDownFormatter().format(txt)),
+            contents=MarkupContent(kind=MarkupKind.MARKDOWN, value=txt),
             range=range_from_token(name_token),
         )

robotcode/language_server/robotframework/parts/http_server.py

@@ -16,10 +16,11 @@ from urllib.parse import parse_qs, urlparse
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.core.utils.net import find_free_port
 from robotcode.robot.diagnostics.library_doc import (
+    LibraryDoc,
     get_library_doc,
     get_robot_library_html_doc_str,
 )
-from robotcode.robot.diagnostics.model_helper import ModelHelper
+from robotcode.robot.utils.markdown_docs import anchor_link_resolver
 
 from ..configuration import DocumentationServerConfig
 from .protocol_part import RobotLanguageServerProtocolPart
@@ -72,6 +73,19 @@ MARKDOWN_TEMPLATE = Template(
 )
 
 
+def library_doc_to_markdown_content(libdoc: LibraryDoc) -> str:
+    """The Markdown the documentation view renders for a library.
+
+    The page shows the whole library, so references to keywords and sections
+    in Markdown documentation become links to their headings.
+    """
+    tt = str.maketrans({"<": "&lt;", ">": "&gt;"})
+    markdown = libdoc.to_markdown(
+        add_signature=False, only_doc=False, header_level=0, link_resolver=anchor_link_resolver
+    )
+    return markdown.translate(tt)
+
+
 class LibDocRequestHandler(SimpleHTTPRequestHandler):
     _logger = LoggingDescriptor()
 
@@ -106,11 +120,7 @@ class LibDocRequestHandler(SimpleHTTPRequestHandler):
                         base_dir=basedir if basedir else ".",
                     )
 
-                    def calc_md() -> str:
-                        tt = str.maketrans({"<": "&lt;", ">": "&gt;"})
-                        return libdoc.to_markdown(add_signature=False, only_doc=False, header_level=0).translate(tt)
-
-                    data = MARKDOWN_TEMPLATE.substitute(content=calc_md(), name=name)
+                    data = MARKDOWN_TEMPLATE.substitute(content=library_doc_to_markdown_content(libdoc), name=name)
 
                     self.send_response(200)
                     self.send_header("Content-type", "text/html")
@@ -162,7 +172,7 @@ class DualStackServer(ThreadingHTTPServer):
         return super().server_bind()
 
 
-class HttpServerProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class HttpServerProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:

robotcode/language_server/robotframework/parts/inline_value.py

@@ -1,5 +1,5 @@
 import ast
-from itertools import dropwhile, takewhile
+from itertools import chain, dropwhile, takewhile
 from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Tuple
 
 from robot.parsing.lexer.tokens import Token
@@ -10,24 +10,33 @@ from robotcode.core.lsp.types import (
     InlineValue,
     InlineValueContext,
     InlineValueEvaluatableExpression,
+    Position,
     Range,
 )
 from robotcode.core.text_document import TextDocument
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.robot.diagnostics.model_helper import ModelHelper
+from robotcode.robot.diagnostics.semantic_analyzer.enums import NodeKind
+from robotcode.robot.diagnostics.semantic_analyzer.model import SemanticModel
+from robotcode.robot.diagnostics.semantic_analyzer.nodes import SemanticToken
 from robotcode.robot.utils.ast import (
     iter_nodes,
     range_from_node,
     range_from_token,
 )
 
+from .model_variables import (
+    iter_condition_ref_candidates,
+    iter_model_variable_candidates,
+    scannable_statement_tokens,
+)
 from .protocol_part import RobotLanguageServerProtocolPart
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -50,10 +59,14 @@ class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart, ModelHelper)
 
         namespace = self.parent.documents_cache.get_namespace(document)
 
-        model = self.parent.documents_cache.get_model(document)
-
         real_range = Range(range.start, min(range.end, context.stopped_location.end))
 
+        semantic_model = namespace.semantic_model
+        if semantic_model is not None:
+            return self._collect_from_model(semantic_model, real_range, context)
+
+        model = self.parent.documents_cache.get_model(document)
+
         def get_tokens() -> Iterator[Tuple[Token, ast.AST]]:
             for n in iter_nodes(model):
                 r = range_from_node(n)
@@ -71,15 +84,64 @@ class RobotInlineValueProtocolPart(RobotLanguageServerProtocolPart, ModelHelper)
                 get_tokens(),
             ),
         ):
-            if token.type == RobotToken.ARGUMENT and isinstance(node, self.get_expression_statement_types()):
-                for t, var in self.iter_expression_variables_from_token(
+            if token.type == RobotToken.ARGUMENT and isinstance(node, ModelHelper.get_expression_statement_types()):
+                for t, var in ModelHelper.iter_expression_variables_from_token(
                     token, namespace, context.stopped_location.start
                 ):
                     if var.name != "${CURDIR}":
                         result.append(InlineValueEvaluatableExpression(range_from_token(t), var.name))
 
-            for t, var in self.iter_variables_from_token(token, namespace, context.stopped_location.start):
+            for t, var in ModelHelper.iter_variables_from_token(token, namespace, context.stopped_location.start):
                 if var.name != "${CURDIR}":
                     result.append(InlineValueEvaluatableExpression(range_from_token(t), var.name))
 
         return result
+
+    def _collect_from_model(
+        self,
+        semantic_model: SemanticModel,
+        real_range: Range,
+        context: InlineValueContext,
+    ) -> List[InlineValue]:
+        """Model path: variable occurrences from the pre-built statement
+        tokens, resolved at the debugger's stopped location."""
+        resolve_line = context.stopped_location.start.line + 1
+        resolve_col = context.stopped_location.start.character
+
+        def get_model_tokens() -> Iterator[Tuple[NodeKind, SemanticToken]]:
+            for stmt in semantic_model.statements:
+                if not stmt.tokens:
+                    continue
+                first = stmt.tokens[0]
+                last = stmt.tokens[-1]
+                start = Position(line=first.line - 1, character=first.col_offset)
+                end = Position(line=last.line - 1, character=last.col_offset + last.length)
+                if start in real_range or end in real_range:
+                    for token in scannable_statement_tokens(stmt):
+                        yield stmt.kind, token
+                if start > real_range.end:
+                    break
+
+        result: List[InlineValue] = []
+        for stmt_kind, token in takewhile(
+            lambda t: t[1].line - 1 <= real_range.end.line,
+            dropwhile(
+                lambda t: Position(line=t[1].line - 1, character=t[1].col_offset) < real_range.start,
+                get_model_tokens(),
+            ),
+        ):
+            # Legacy per-token order: the condition cell's bare-`$var`
+            # expression refs first, then the regular variables.
+            for candidate in chain(
+                iter_condition_ref_candidates(token),
+                iter_model_variable_candidates(token, semantic_model, resolve_line, resolve_col, stmt_kind),
+            ):
+                if not candidate.primary:
+                    continue
+                # `extended=False`: the extended-syntax fallback is already
+                # encoded in the candidates' lookup names.
+                var = semantic_model.find_variable(candidate.lookup_name, resolve_line, resolve_col, extended=False)
+                if var is not None and var.name != "${CURDIR}":
+                    result.append(InlineValueEvaluatableExpression(candidate.range, var.name))
+
+        return result