robotcode-language-server 2.8.0.dev548__py3-none-any.whl → 2.8.0.dev670__py3-none-any.whl

robotcode/language_server/__version__.py

@@ -1 +1 @@
-__version__ = "2.8.0-dev.548"
+__version__ = "2.8.0-dev.670"

robotcode/language_server/robotframework/parts/code_action_documentation.py

@@ -14,7 +14,6 @@ from robotcode.core.lsp.types import (
     CodeActionContext,
     CodeActionKind,
     Command,
-    Position,
     Range,
 )
 from robotcode.core.text_document import TextDocument
@@ -36,7 +35,6 @@ from robotcode.robot.diagnostics.semantic_analyzer.model import SemanticModel
 from robotcode.robot.diagnostics.semantic_analyzer.nodes import (
     DefinitionStatement,
     ImportStatement,
-    KeywordCallStatement,
 )
 from robotcode.robot.utils.ast import get_node_at_position, range_from_token
 from robotcode.robot.utils.markdown_docs import (
@@ -374,16 +372,13 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
         if isinstance(stmt, ImportStatement) and stmt.import_type in (ImportType.LIBRARY, ImportType.RESOURCE):
             return self._import_target_from_model(stmt, document, range, namespace)
 
-        # Branch 2: keyword call / fixture / template.
-        if isinstance(stmt, KeywordCallStatement):
-            if range.start != range.end:
-                return None
-            kw_doc = stmt.keyword_doc
-            if kw_doc is None:
-                return None
-            if not self._cursor_on_keyword_reference(range.start, stmt):
+        # Branch 2: keyword call / fixture / template, also a call in the body
+        # of an inline IF and an inner call of a Run Keyword variant.
+        call = model.keyword_call_at(range.start.line + 1, range.start.character)
+        if call is not None:
+            if range.start != range.end or call.keyword_doc is None:
                 return None
-            return self.keyword_target(kw_doc, stmt.lib_entry, document, namespace)
+            return self.keyword_target(call.keyword_doc, call.lib_entry, document, namespace)
 
         # Branch 3: keyword definition header.
         if isinstance(stmt, DefinitionStatement) and stmt.kind is NodeKind.KEYWORD_DEF:
@@ -436,21 +431,6 @@ class RobotCodeActionDocumentationProtocolPart(RobotLanguageServerProtocolPart,
             stmt.lib_entry.library_doc if stmt.lib_entry is not None else None,
         )
 
-    @staticmethod
-    def _cursor_on_keyword_reference(pos: Position, stmt: KeywordCallStatement) -> bool:
-        """Cursor is within the NAMESPACE / "." / KEYWORD SemanticTokens
-        that make up the keyword reference (BDD prefix excluded). Mirrors
-        the legacy `position.is_in_range(range_from_token(keyword_token))`
-        after the BDD-prefix strip that
-        `get_keyworddoc_and_token_from_position` does.
-        """
-        ref_toks = [t for t in stmt.tokens if t.kind in (TokenKind.NAMESPACE, TokenKind.KEYWORD)]
-        if not ref_toks:
-            return False
-        # Contiguous span from namespace start to keyword end also covers the
-        # "." operator between them.
-        return pos in Range(start=ref_toks[0].range.start, end=ref_toks[-1].range.end)
-
     def keyword_target(
         self,
         kw_doc: KeywordDoc,

robotcode/language_server/robotframework/parts/references.py

@@ -150,7 +150,37 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
             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,
@@ -230,10 +260,7 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
         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))
@@ -243,6 +270,11 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
                 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
@@ -321,15 +353,16 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
     ) -> 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
@@ -388,12 +421,7 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
             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
@@ -413,6 +441,19 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
         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:
@@ -475,6 +516,11 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart):
         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,

robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -21,6 +21,7 @@ from typing import (
     Union,
     cast,
 )
+from weakref import WeakKeyDictionary
 
 from robot.parsing.lexer.tokens import Token
 from robot.parsing.model.blocks import Section
@@ -55,6 +56,7 @@ from robotcode.core.lsp.types import (
     SemanticTokenTypes,
 )
 from robotcode.core.text_document import TextDocument, range_to_utf16
+from robotcode.robot.diagnostics.entities import ArgumentDefinition, EmbeddedArgumentDefinition
 from robotcode.robot.diagnostics.keyword_finder import DEFAULT_BDD_PREFIX_REGEXP, build_bdd_prefix_regexp
 from robotcode.robot.diagnostics.library_doc import (
     ALL_RUN_KEYWORDS_MATCHERS,
@@ -1099,6 +1101,12 @@ class SemanticTokenGenerator:
         TokenModifier.DOCUMENTATION: SemanticTokenModifiers.DOCUMENTATION,
     }
 
+    # Modifiers that change the type instead: a variable that names an argument
+    # renders as `parameter`, like the argument's declaration.
+    _TOKEN_MODIFIER_TO_SEM_TYPE: ClassVar[Dict[Tuple[TokenKind, TokenModifier], AnyTokenType]] = {
+        (TokenKind.VARIABLE, TokenModifier.ARGUMENT): SemanticTokenTypes.PARAMETER,
+    }
+
     # --- Legacy-compat emission policy (design D7) ---
 
     # Whole options of control structures render atomically: one control-flow
@@ -1151,6 +1159,8 @@ class SemanticTokenGenerator:
         """Initialize the generator with its own dependencies."""
         self.token_mapper = SemanticTokenMapper()
         self.keyword_analyzer = KeywordTokenAnalyzer(self.token_mapper)
+        # a namespace holds the result of one analysis, so its argument uses never change
+        self._argument_uses_cache: WeakKeyDictionary[Namespace, FrozenSet[Tuple[int, int]]] = WeakKeyDictionary()
 
     def collect_tokens_from_model(
         self,
@@ -1231,6 +1241,8 @@ class SemanticTokenGenerator:
             mapped = {self._TOKEN_MODIFIER_TO_SEM[m] for m in token.modifiers if m in self._TOKEN_MODIFIER_TO_SEM}
             if mapped:
                 sem_mods = (sem_mods or set()) | mapped
+            for m in token.modifiers:
+                sem_type = self._TOKEN_MODIFIER_TO_SEM_TYPE.get((token.kind, m), sem_type)
         return SemTokenInfo(token.line, token.col_offset, token.length, sem_type, sem_mods)
 
     def _iter_model_sem_tokens(
@@ -1815,26 +1827,46 @@ class SemanticTokenGenerator:
         if not sub_tokens:
             yield SemTokenInfo.from_token(token, sem_type, sem_mod)
             return
-        yield from self._iter_variable_name_sem_tokens(sub_tokens, sem_type, sem_mod)
+        yield from self._iter_variable_name_sem_tokens(sub_tokens, sem_type, sem_mod, self._argument_uses(namespace))
+
+    def _argument_uses(self, namespace: Namespace) -> FrozenSet[Tuple[int, int]]:
+        """Where the analysis resolved a name to an argument from `[Arguments]`, the same resolution Find References
+        and Rename use; embedded arguments are left out."""
+        uses = self._argument_uses_cache.get(namespace)
+        if uses is None:
+            uses = frozenset(
+                (location.range.start.line, location.range.start.character)
+                for var, locations in namespace.variable_references.items()
+                if isinstance(var, ArgumentDefinition) and not isinstance(var, EmbeddedArgumentDefinition)
+                for location in locations
+            )
+            self._argument_uses_cache[namespace] = uses
+        return uses
 
     def _iter_variable_name_sem_tokens(
         self,
         sub_tokens: Sequence[SemanticToken],
         sem_type: AnyTokenType,
         sem_mod: Optional[Set[AnyTokenModifier]],
+        argument_uses: FrozenSet[Tuple[int, int]],
     ) -> Iterator[SemTokenInfo]:
         for sub in sub_tokens:
             if sub.kind is TokenKind.VARIABLE:
                 if sub.sub_tokens:
-                    yield from self._iter_variable_name_sem_tokens(sub.sub_tokens, RobotSemTokenTypes.VARIABLE, None)
+                    yield from self._iter_variable_name_sem_tokens(
+                        sub.sub_tokens, RobotSemTokenTypes.VARIABLE, None, argument_uses
+                    )
                 else:
                     yield SemTokenInfo(sub.line, sub.col_offset, sub.length, RobotSemTokenTypes.VARIABLE)
             elif sub.kind is TokenKind.PYTHON_EXPRESSION:
                 continue
             elif sub.sub_tokens:
-                yield from self._iter_variable_name_sem_tokens(sub.sub_tokens, sem_type, sem_mod)
+                yield from self._iter_variable_name_sem_tokens(sub.sub_tokens, sem_type, sem_mod, argument_uses)
             elif sub.kind is TokenKind.VARIABLE_BASE:
-                yield SemTokenInfo(sub.line, sub.col_offset, sub.length, sem_type, sem_mod)
+                # a use of an argument is a parameter, like its declaration
+                is_argument = (sub.range.start.line, sub.range.start.character) in argument_uses
+                base_type = SemanticTokenTypes.PARAMETER if is_argument else sem_type
+                yield SemTokenInfo(sub.line, sub.col_offset, sub.length, base_type, sem_mod)
             elif sub.kind is TokenKind.VARIABLE_TYPE_HINT:
                 yield SemTokenInfo(sub.line, sub.col_offset, sub.length, SemanticTokenTypes.TYPE)
 

{robotcode_language_server-2.8.0.dev548.dist-info → robotcode_language_server-2.8.0.dev670.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-language-server
-Version: 2.8.0-dev.548
+Version: 2.8.0-dev.670
 Summary: RobotCode Language Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -26,10 +26,10 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: robotcode-analyze==2.8.0-dev.548
-Requires-Dist: robotcode-jsonrpc2==2.8.0-dev.548
-Requires-Dist: robotcode-robot==2.8.0-dev.548
-Requires-Dist: robotcode==2.8.0-dev.548
+Requires-Dist: robotcode-analyze==2.8.0-dev.670
+Requires-Dist: robotcode-jsonrpc2==2.8.0-dev.670
+Requires-Dist: robotcode-robot==2.8.0-dev.670
+Requires-Dist: robotcode==2.8.0-dev.670
 Requires-Dist: robotframework>=5.0.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-2.8.0.dev548.dist-info → robotcode_language_server-2.8.0.dev670.dist-info}/RECORD

@@ -1,5 +1,5 @@
 robotcode/language_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/language_server/__version__.py,sha256=4qGR5Sg7VszfoERVpnszHJ_tsWJ0G_bUZdheH0_dqx4,30
+robotcode/language_server/__version__.py,sha256=H0IFmU7VH6n_W0CbM7UtSwMIjNMI6OcCSdI7uBsndDU,30
 robotcode/language_server/cli.py,sha256=FsutR2FF8YjCMRtq2c_i0wYSktP8KkhGnnfEy4fcpww,4136
 robotcode/language_server/hooks.py,sha256=wahxowTEo9Q16q5VK7AmhKDMdbtxcvqg9242-_L9tTA,204
 robotcode/language_server/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
@@ -39,7 +39,7 @@ robotcode/language_server/robotframework/configuration.py,sha256=G6jchWIawSKiqKT
 robotcode/language_server/robotframework/protocol.py,sha256=ONaBVaqz4LZ0DGd9iKy43z4FPh2lI7jt5J1CIDH6mfw,10831
 robotcode/language_server/robotframework/server.py,sha256=-1EQ1zGyLAS1LM6aMa6IRT2KqYiLWWVr6GOhiQZ8Ncw,1045
 robotcode/language_server/robotframework/parts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-robotcode/language_server/robotframework/parts/code_action_documentation.py,sha256=JKG4zE29WgqxxxTUrKsjhvS7vsvLZu1gpdyqF7B-z7M,28416
+robotcode/language_server/robotframework/parts/code_action_documentation.py,sha256=TFztfmk_nZDGJ6nNPHXTDyqL5zx3ZIa4O-DcGCYQVks,27583
 robotcode/language_server/robotframework/parts/code_action_helper_mixin.py,sha256=hAd3e5hMnpqi8vGReHQCI6bS8cwNggr6RA7F_knFL1o,4553
 robotcode/language_server/robotframework/parts/code_action_quick_fixes.py,sha256=wIJduFlNwvzZY371VaaTchXm8GgivSbQyPWQ30DpNOY,33770
 robotcode/language_server/robotframework/parts/code_action_refactor.py,sha256=t9QVp3zZ9VRvv1PSACegdGUiIgHzvE9vvCisIAtqcO8,27419
@@ -61,16 +61,16 @@ robotcode/language_server/robotframework/parts/keywords_treeview.py,sha256=kSfVR
 robotcode/language_server/robotframework/parts/model_variables.py,sha256=F4u_Nua4a_Tga3cVV1pD-hE9xZsxcWITN8umck58Kn0,14137
 robotcode/language_server/robotframework/parts/project_info.py,sha256=5v_livYd7G-x5ZV5SbCt7R7kri0-qfZuqOrFgtd2KaY,1631
 robotcode/language_server/robotframework/parts/protocol_part.py,sha256=4LHac_eBg18Df6J9dJCMtvmR_Y1F6lYMVlghK1Ne8m8,413
-robotcode/language_server/robotframework/parts/references.py,sha256=4zC34ORPl1JkGWKWjWGk1-bGNMeKjYlqQpUeSXPPKRM,22343
+robotcode/language_server/robotframework/parts/references.py,sha256=UPTs2kvn4r0xZMTCzDlXZE0eoBp18ScMeyxGgNt0btY,24471
 robotcode/language_server/robotframework/parts/rename.py,sha256=fynUSzMy5tZ_URjPKyY_6DW42MBj0LagZjchKIzkXAE,9467
 robotcode/language_server/robotframework/parts/robocop_diagnostics.py,sha256=Z94zXFoqDTdGl3hJOrw__wFcLY6sTnNrhDr7QiSOBrQ,10643
 robotcode/language_server/robotframework/parts/robocop_helper.py,sha256=SRmcAq4pRVzT_oP4R8FUB2oACeLcds9rYZqgFNWsmI0,3592
 robotcode/language_server/robotframework/parts/robot_workspace.py,sha256=0IrBgUWs1oed11GeVLwZR_G44vXZmmn27AD29wjM59I,14790
 robotcode/language_server/robotframework/parts/selection_range.py,sha256=ye0PkchedHgkrVJ7IthkAVTVstH7LEcmAcBQPw8t2mQ,3504
-robotcode/language_server/robotframework/parts/semantic_tokens.py,sha256=YkGAMYdNktxGv9Xf9E8OvjHhs21W75zAn8u36bOTwn0,82572
+robotcode/language_server/robotframework/parts/semantic_tokens.py,sha256=pbRpMMdV5XeVfhozYf6uUZG_XmMCN9MYwylBUBqFkPI,84553
 robotcode/language_server/robotframework/parts/signature_help.py,sha256=CJnG8LH21O60kZQLFltb0PzSsN745pYrmtASdE1d2Nw,31306
 robotcode/language_server/robotframework/parts/workspace_symbols.py,sha256=eywbtK56TTLbwuTwoUvNtlhIyAX-2l1BcZntYODuhPQ,3688
-robotcode_language_server-2.8.0.dev548.dist-info/METADATA,sha256=-MPj4JxOKaVB6mDvx1zKwWoOH5HaqPBbR4jHbuieiZ8,3324
-robotcode_language_server-2.8.0.dev548.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-robotcode_language_server-2.8.0.dev548.dist-info/entry_points.txt,sha256=Mz2JImlHxd6aYE41Z2r8KaoCnbOcXlR5Zm9Qw_G9Ff0,57
-robotcode_language_server-2.8.0.dev548.dist-info/RECORD,,
+robotcode_language_server-2.8.0.dev670.dist-info/METADATA,sha256=MeeZJAd1tC39VheE9Wvw1Wu7EX52z9IZH40LLHfAw3I,3324
+robotcode_language_server-2.8.0.dev670.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+robotcode_language_server-2.8.0.dev670.dist-info/entry_points.txt,sha256=Mz2JImlHxd6aYE41Z2r8KaoCnbOcXlR5Zm9Qw_G9Ff0,57
+robotcode_language_server-2.8.0.dev670.dist-info/RECORD,,