robotcode-language-server 2.8.0.dev548__tar.gz → 2.8.0.dev631__tar.gz

{robotcode_language_server-2.8.0.dev548 → robotcode_language_server-2.8.0.dev631}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: robotcode-language-server
-Version: 2.8.0-dev.548
+Version: 2.8.0-dev.631
 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.631
+Requires-Dist: robotcode-jsonrpc2==2.8.0-dev.631
+Requires-Dist: robotcode-robot==2.8.0-dev.631
+Requires-Dist: robotcode==2.8.0-dev.631
 Requires-Dist: robotframework>=5.0.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-2.8.0.dev548 → robotcode_language_server-2.8.0.dev631}/pyproject.toml

@@ -29,10 +29,10 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=5.0.0",
-  "robotcode-jsonrpc2==2.8.0-dev.548",
-  "robotcode-robot==2.8.0-dev.548",
-  "robotcode-analyze==2.8.0-dev.548",
-  "robotcode==2.8.0-dev.548",
+  "robotcode-jsonrpc2==2.8.0-dev.631",
+  "robotcode-robot==2.8.0-dev.631",
+  "robotcode-analyze==2.8.0-dev.631",
+  "robotcode==2.8.0-dev.631",
 ]
 dynamic = ["version"]
 

robotcode_language_server-2.8.0.dev631/src/robotcode/language_server/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.8.0-dev.631"

{robotcode_language_server-2.8.0.dev548 → robotcode_language_server-2.8.0.dev631}/src/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-2.8.0.dev548 → robotcode_language_server-2.8.0.dev631}/src/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/src/robotcode/language_server/__version__.py

@@ -1 +0,0 @@
-__version__ = "2.8.0-dev.548"