robotcode-language-server 1.3.0.dev2__tar.gz → 1.3.0.dev4__tar.gz

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-language-server
-Version: 1.3.0.dev2
+Version: 1.3.0.dev4
 Summary: RobotCode Language Server for Robot Framework
 Project-URL: Homepage, https://robotcode.io
 Project-URL: Donate, https://opencollective.com/robotcode
@@ -25,10 +25,10 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: robotcode-analyze==1.3.0-dev.2
-Requires-Dist: robotcode-jsonrpc2==1.3.0-dev.2
-Requires-Dist: robotcode-robot==1.3.0-dev.2
-Requires-Dist: robotcode==1.3.0-dev.2
+Requires-Dist: robotcode-analyze==1.3.0-dev.4
+Requires-Dist: robotcode-jsonrpc2==1.3.0-dev.4
+Requires-Dist: robotcode-robot==1.3.0-dev.4
+Requires-Dist: robotcode==1.3.0-dev.4
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/pyproject.toml

@@ -27,10 +27,10 @@ classifiers = [
 ]
 dependencies = [
   "robotframework>=4.1.0",
-  "robotcode-jsonrpc2==1.3.0-dev.2",
-  "robotcode-robot==1.3.0-dev.2",
-  "robotcode-analyze==1.3.0-dev.2",
-  "robotcode==1.3.0-dev.2",
+  "robotcode-jsonrpc2==1.3.0-dev.4",
+  "robotcode-robot==1.3.0-dev.4",
+  "robotcode-analyze==1.3.0-dev.4",
+  "robotcode==1.3.0-dev.4",
 ]
 dynamic = ["version"]
 

robotcode_language_server-1.3.0.dev4/src/robotcode/language_server/__version__.py

@@ -0,0 +1 @@
+__version__ = "1.3.0-dev.4"

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/src/robotcode/language_server/robotframework/configuration.py

@@ -33,6 +33,9 @@ class RoboCopConfig(ConfigBase):
     enabled: bool = True
     include: List[str] = field(default_factory=list)
     exclude: List[str] = field(default_factory=list)
+    ignore_git_dir: bool = False
+    ignore_file_config: bool = False
+    config_file: Optional[str] = None
     configurations: List[str] = field(default_factory=list)
 
 

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/src/robotcode/language_server/robotframework/parts/formatting.py

@@ -1,6 +1,5 @@
 import io
 import os
-import re
 from concurrent.futures import CancelledError
 from typing import TYPE_CHECKING, Any, List, Optional, cast
 
@@ -14,26 +13,17 @@ from robotcode.core.lsp.types import (
 )
 from robotcode.core.text_document import TextDocument
 from robotcode.core.utils.logging import LoggingDescriptor
-from robotcode.core.utils.version import create_version_from_str
-from robotcode.robot.diagnostics.model_helper import ModelHelper
 from robotcode.robot.utils import get_robot_version
 
-from ..configuration import RoboTidyConfig
+from ..configuration import RoboCopConfig, RoboTidyConfig
 from .protocol_part import RobotLanguageServerProtocolPart
+from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-def robotidy_installed() -> bool:
-    try:
-        __import__("robotidy")
-    except ImportError:
-        return False
-    return True
-
-
-class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -41,7 +31,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
 
         parent.formatting.format.add(self.format)
 
-        if robotidy_installed():
+        if self.robotidy_installed or (self.robocop_installed and self.robocop_version >= (6, 0)):
             parent.formatting.format_range.add(self.format_range)
 
         self.space_count = 4
@@ -49,14 +39,22 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         self.line_separator = os.linesep
         self.short_test_name_length = 18
         self.setting_and_variable_name_length = 14
+        self.is_robocop_notification_shown = False
 
-    def get_config(self, document: TextDocument) -> RoboTidyConfig:
+    def get_tidy_config(self, document: TextDocument) -> RoboTidyConfig:
         folder = self.parent.workspace.get_workspace_folder(document.uri)
         if folder is None:
             return RoboTidyConfig()
 
         return self.parent.workspace.get_configuration(RoboTidyConfig, folder.uri)
 
+    def get_robocop_config(self, document: TextDocument) -> RoboCopConfig:
+        folder = self.parent.workspace.get_workspace_folder(document.uri)
+        if folder is None:
+            return RoboCopConfig()
+
+        return self.parent.workspace.get_configuration(RoboCopConfig, folder.uri)
+
     @language_id("robotframework")
     @_logger.call
     def format(
@@ -66,23 +64,33 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        config = self.get_config(document)
+        if (get_robot_version() >= (5, 0)) and self.robocop_installed and self.robocop_version >= (6, 0):
+            if not self.is_robocop_notification_shown and self.robotidy_installed:
+                self.parent.window.show_message(
+                    "`robotframework-robocop >= 6.0` is installed and will be used for formatting.\n\n"
+                    "`robotframework-tidy` is also detected in the workspace, but its use is redundant.\n"
+                    "Robocop fully supports all formatting tasks and provides a more comprehensive solution.\n\n"
+                    "Note: The use of `robotframework-tidy` is deprecated and should be avoided in favor of Robocop.",
+                    MessageType.INFO,
+                )
+                self.is_robocop_notification_shown = True
 
-        if (config.enabled or get_robot_version() >= (5, 0)) and robotidy_installed():
-            return self.format_robot_tidy(document, options, config=config, **further_options)
+            return self.format_robocop(document, options, **further_options)
+
+        tidy_config = self.get_tidy_config(document)
+        if (tidy_config.enabled or get_robot_version() >= (5, 0)) and self.robotidy_installed:
+            return self.format_robot_tidy(document, options, config=tidy_config, **further_options)
 
         if get_robot_version() < (5, 0):
             return self.format_internal(document, options, **further_options)
 
         self.parent.window.show_message(
-            "RobotFramework formatter is not available, please install 'robotframework-tidy'.",
+            "RobotFramework formatter is not available, please install 'robotframework-robocop'.",
             MessageType.ERROR,
         )
 
         return None
 
-    RE_LINEBREAKS = re.compile(r"\r\n|\r|\n")
-
     def format_robot_tidy(
         self,
         document: TextDocument,
@@ -91,28 +99,24 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         config: Optional[RoboTidyConfig] = None,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        from robotidy.version import __version__
-
         try:
             if config is None:
-                config = self.get_config(document)
-
-            robotidy_version = create_version_from_str(__version__)
+                config = self.get_tidy_config(document)
 
             model = self.parent.documents_cache.get_model(document, False)
 
-            if robotidy_version >= (3, 0):
+            if self.robotidy_version >= (3, 0):
                 from robotidy.api import get_robotidy
                 from robotidy.disablers import RegisterDisablers
 
-                if robotidy_version >= (4, 2):
+                if self.robotidy_version >= (4, 2):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
                         ignore_git_dir=config.ignore_git_dir,
                         config=config.config,
                     )
-                elif robotidy_version >= (4, 1):
+                elif self.robotidy_version >= (4, 1):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
@@ -131,14 +135,14 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                 )
                 disabler_finder.visit(model)
 
-                if robotidy_version >= (4, 11):
+                if self.robotidy_version >= (4, 11):
                     if disabler_finder.is_disabled_in_file():
                         return None
                 else:
                     if disabler_finder.file_disabled:
                         return None
 
-                if robotidy_version >= (4, 0):
+                if self.robotidy_version >= (4, 0):
                     _, _, new, _ = robot_tidy.transform_until_stable(model, disabler_finder)
                 else:
                     _, _, new = robot_tidy.transform(model, disabler_finder.disablers)
@@ -152,7 +156,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
                     robot_tidy.formatting_config.start_line = range.start.line + 1
                     robot_tidy.formatting_config.end_line = range.end.line + 1
 
-                if robotidy_version >= (2, 2):
+                if self.robotidy_version >= (2, 2):
                     from robotidy.disablers import RegisterDisablers
 
                     disabler_finder = RegisterDisablers(
@@ -186,6 +190,50 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
             self.parent.window.show_message(f"Executing `robotidy` failed: {e}", MessageType.ERROR)
         return None
 
+    def format_robocop(
+        self,
+        document: TextDocument,
+        options: FormattingOptions,
+        range: Optional[Range] = None,
+        **further_options: Any,
+    ) -> Optional[List[TextEdit]]:
+        from robocop.config import ConfigManager
+        from robocop.formatter.runner import RobocopFormatter
+
+        robocop_config = self.get_robocop_config(document)
+
+        config_manager = ConfigManager(
+            [document.uri.to_path()],
+            config=robocop_config.config_file,
+            ignore_git_dir=robocop_config.ignore_git_dir,
+            ignore_file_config=robocop_config.ignore_file_config,
+        )
+
+        config = config_manager.get_config_for_source_file(document.uri.to_path())
+
+        if range is not None:
+            config.formatter.start_line = range.start.line + 1
+            config.formatter.end_line = range.end.line + 1
+
+        runner = RobocopFormatter(config_manager)
+        runner.config = config
+
+        model = self.parent.documents_cache.get_model(document, False)
+        _, _, new, _ = runner.format_until_stable(model)
+
+        if new.text == document.text():
+            return None
+
+        return [
+            TextEdit(
+                range=Range(
+                    start=Position(line=0, character=0),
+                    end=Position(line=len(document.get_lines()), character=0),
+                ),
+                new_text=new.text,
+            )
+        ]
+
     def format_internal(
         self,
         document: TextDocument,
@@ -233,8 +281,8 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        config = self.get_config(document)
-        if config.enabled and robotidy_installed():
+        config = self.get_tidy_config(document)
+        if (config.enabled and self.robotidy_installed) or (self.robocop_installed and self.robocop_version >= (6, 0)):
             return self.format_robot_tidy(document, options, range=range, config=config, **further_options)
 
         return None

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/src/robotcode/language_server/robotframework/parts/keywords_treeview.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, List, Optional
 
 from robotcode.core.lsp.types import TextDocumentIdentifier
+from robotcode.core.uri import Uri
 from robotcode.core.utils.dataclasses import CamelSnakeMixin
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
@@ -16,6 +17,26 @@ if TYPE_CHECKING:
 @dataclass(repr=False)
 class GetDocumentImportsParams(CamelSnakeMixin):
     text_document: TextDocumentIdentifier
+    no_documentation: Optional[bool] = None
+
+
+@dataclass(repr=False)
+class GetDocumentKeywordsParams(CamelSnakeMixin):
+    text_document: TextDocumentIdentifier
+    no_documentation: Optional[bool] = None
+
+
+@dataclass(repr=False)
+class GetLibraryDocumentationParams(CamelSnakeMixin):
+    workspace_folder_uri: str
+    library_name: str
+
+
+@dataclass(repr=False)
+class GetKeywordDocumentationParams(CamelSnakeMixin):
+    workspace_folder_uri: str
+    library_name: str
+    keyword_name: str
 
 
 @dataclass(repr=False)
@@ -26,6 +47,14 @@ class Keyword(CamelSnakeMixin):
     documentation: Optional[str] = None
 
 
+@dataclass(repr=False)
+class LibraryDocumentation(CamelSnakeMixin):
+    name: str
+    documentation: Optional[str] = None
+    keywords: Optional[List[Keyword]] = None
+    initializers: Optional[List[Keyword]] = None
+
+
 @dataclass(repr=False)
 class DocumentImport(CamelSnakeMixin):
     name: str
@@ -54,6 +83,7 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
     def _get_document_imports(
         self,
         text_document: TextDocumentIdentifier,
+        no_documentation: Optional[bool] = None,
         *args: Any,
         **kwargs: Any,
     ) -> Optional[List[DocumentImport]]:
@@ -72,16 +102,18 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
                     alias=v.alias,
                     id=str(hash(v)),
                     type="library",
-                    documentation=v.library_doc.to_markdown(add_signature=False),
+                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
                     keywords=[
                         Keyword(
                             l.name,
                             str(hash(l)),
                             l.parameter_signature(),
-                            l.to_markdown(add_signature=False),
+                            l.to_markdown(add_signature=False) if not no_documentation else None,
                         )
                         for l in v.library_doc.keywords.values()
-                    ],
+                    ]
+                    if not no_documentation
+                    else None,
                 )
             )
         for _k, v in namespace.get_resources().items():
@@ -91,21 +123,29 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
                     alias=None,
                     id=str(hash(v)),
                     type="resource",
-                    documentation=v.library_doc.to_markdown(add_signature=False),
+                    documentation=v.library_doc.to_markdown(add_signature=False) if not no_documentation else None,
                     keywords=[
-                        Keyword(l.name, str(hash(l)), l.parameter_signature(), l.to_markdown(add_signature=False))
+                        Keyword(
+                            l.name,
+                            str(hash(l)),
+                            l.parameter_signature(),
+                            l.to_markdown(add_signature=False) if not no_documentation else None,
+                        )
                         for l in v.library_doc.keywords.values()
-                    ],
+                    ]
+                    if not no_documentation
+                    else None,
                 )
             )
 
         return result
 
-    @rpc_method(name="robot/keywordsview/getDocumentKeywords", param_type=GetDocumentImportsParams, threaded=True)
+    @rpc_method(name="robot/keywordsview/getDocumentKeywords", param_type=GetDocumentKeywordsParams, threaded=True)
     @_logger.call
     def _get_document_keywords(
         self,
         text_document: TextDocumentIdentifier,
+        no_documentation: Optional[bool] = None,
         *args: Any,
         **kwargs: Any,
     ) -> Optional[List[Keyword]]:
@@ -116,7 +156,12 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
         namespace = self.parent.documents_cache.get_namespace(document)
 
         return [
-            Keyword(l.name, str(hash(l)), l.parameter_signature(), l.to_markdown(add_signature=False))
+            Keyword(
+                l.name,
+                str(hash(l)),
+                l.parameter_signature(),
+                l.to_markdown(add_signature=False) if not no_documentation else None,
+            )
             for l in namespace.get_library_doc().keywords.values()
         ]
 
@@ -165,3 +210,72 @@ class RobotKeywordsTreeViewPart(RobotLanguageServerProtocolPart, ModelHelper):
             )
 
         return None
+
+    @rpc_method(
+        name="robot/keywordsview/getLibraryDocumentation", param_type=GetLibraryDocumentationParams, threaded=True
+    )
+    @_logger.call
+    def _get_library_documentation(
+        self,
+        workspace_folder_uri: str,
+        library_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[LibraryDocumentation]:
+        imports_manager = self.parent.documents_cache.get_imports_manager_for_uri(Uri(workspace_folder_uri))
+
+        libdoc = imports_manager.get_libdoc_for_library_import(library_name, (), ".")
+        if libdoc.errors:
+            raise ValueError(f"Errors while loading library documentation: {libdoc.errors}")
+
+        return LibraryDocumentation(
+            name=libdoc.name,
+            documentation=libdoc.to_markdown(),
+            keywords=[
+                Keyword(
+                    l.name,
+                    str(hash(l)),
+                    l.parameter_signature(),
+                    l.to_markdown(),
+                )
+                for l in libdoc.keywords.values()
+            ],
+            initializers=[
+                Keyword(
+                    s.name,
+                    str(hash(s)),
+                    s.parameter_signature(),
+                    s.to_markdown(),
+                )
+                for s in libdoc.inits.values()
+            ],
+        )
+
+    @rpc_method(
+        name="robot/keywordsview/getKeywordDocumentation", param_type=GetKeywordDocumentationParams, threaded=True
+    )
+    @_logger.call
+    def _get_keyword_documentation(
+        self,
+        workspace_folder_uri: str,
+        library_name: str,
+        keyword_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Optional[Keyword]:
+        imports_manager = self.parent.documents_cache.get_imports_manager_for_uri(Uri(workspace_folder_uri))
+
+        libdoc = imports_manager.get_libdoc_for_library_import(library_name, (), ".")
+        if libdoc.errors:
+            raise ValueError(f"Errors while loading library documentation: {libdoc.errors}")
+
+        kw = libdoc.keywords.get(keyword_name, None)
+        if kw is None:
+            raise ValueError(f"Keyword '{keyword_name}' not found in library '{library_name}'.")
+
+        return Keyword(
+            name=kw.name,
+            id=str(hash(kw)),
+            signature=kw.parameter_signature(),
+            documentation=kw.to_markdown(),
+        )

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/src/robotcode/language_server/robotframework/parts/project_info.py

@@ -1,3 +1,4 @@
+import sys
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -7,9 +8,9 @@ from robotcode.core.utils.dataclasses import CamelSnakeMixin
 from robotcode.core.utils.logging import LoggingDescriptor
 from robotcode.jsonrpc2.protocol import rpc_method
 
-from .formatting import robotidy_installed
+from ...__version__ import __version__ as robotcode_version
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_diagnostics import robocop_installed
+from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -20,9 +21,12 @@ class ProjectInfo(CamelSnakeMixin):
     robot_version_string: str
     robocop_version_string: Optional[str]
     tidy_version_string: Optional[str] = None
+    python_version_string: Optional[str] = None
+    python_executable: Optional[str] = None
+    robot_code_version_string: Optional[str] = None
 
 
-class ProjectInfoPart(RobotLanguageServerProtocolPart):
+class ProjectInfoPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -36,27 +40,18 @@ class ProjectInfoPart(RobotLanguageServerProtocolPart):
         **kwargs: Any,
     ) -> ProjectInfo:
         robocop_version_string = None
-        if robocop_installed():
-            try:
-                from robocop.version import __version__
-
-                robocop_version_string = __version__
-            except ImportError:
-                try:
-                    from robocop import __version__
-
-                    robocop_version_string = __version__
-                except ImportError:
-                    pass
+        if self.robocop_installed:
+            robocop_version_string = self.robocop_version_str
 
         tidy_version_string = None
-        if robotidy_installed():
-            from robotidy.version import __version__
-
-            tidy_version_string = __version__
+        if self.robotidy_installed:
+            tidy_version_string = self.robotidy_version_str
 
         return ProjectInfo(
             robot_version_string=get_version(),
             robocop_version_string=robocop_version_string,
             tidy_version_string=tidy_version_string,
+            python_version_string=sys.version,
+            python_executable=sys.executable,
+            robot_code_version_string=robotcode_version,
         )

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/src/robotcode/language_server/robotframework/parts/robocop_diagnostics.py

@@ -17,20 +17,13 @@ from robotcode.core.workspace import WorkspaceFolder
 from ...common.parts.diagnostics import DiagnosticsCollectType, DiagnosticsResult
 from ..configuration import RoboCopConfig
 from .protocol_part import RobotLanguageServerProtocolPart
+from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-def robocop_installed() -> bool:
-    try:
-        __import__("robocop")
-    except ImportError:
-        return False
-    return True
-
-
-class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
+class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -38,7 +31,7 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
 
         self.source_name = "robocop"
 
-        if robocop_installed():
+        if self.robocop_installed and self.robocop_version < (6, 0):
             parent.diagnostics.collect.add(self.collect_diagnostics)
 
     def get_config(self, document: TextDocument) -> Optional[RoboCopConfig]:

robotcode_language_server-1.3.0.dev4/src/robotcode/language_server/robotframework/parts/robocop_tidy_mixin.py

@@ -0,0 +1,49 @@
+import functools
+
+from robotcode.core.utils.version import Version, create_version_from_str
+
+
+class RoboCopTidyMixin:
+    """
+    Mixin class for handling Robocop tidy operations.
+    """
+
+    @functools.cached_property
+    def robotidy_installed(self) -> bool:
+        try:
+            __import__("robotidy")
+        except ImportError:
+            return False
+        return True
+
+    @functools.cached_property
+    def robotidy_version(self) -> Version:
+        from robotidy.version import __version__
+
+        return create_version_from_str(__version__)
+
+    @functools.cached_property
+    def robotidy_version_str(self) -> str:
+        from robotidy.version import __version__
+
+        return str(__version__)
+
+    @functools.cached_property
+    def robocop_installed(self) -> bool:
+        try:
+            __import__("robocop")
+        except ImportError:
+            return False
+        return True
+
+    @functools.cached_property
+    def robocop_version(self) -> Version:
+        from robocop import __version__
+
+        return create_version_from_str(__version__)
+
+    @functools.cached_property
+    def robocop_version_str(self) -> str:
+        from robocop import __version__
+
+        return str(__version__)

{robotcode_language_server-1.3.0.dev2 → robotcode_language_server-1.3.0.dev4}/src/robotcode/language_server/robotframework/parts/semantic_tokens.py

@@ -471,7 +471,9 @@ class RobotSemanticTokenProtocolPart(RobotLanguageServerProtocolPart):
                         sem_mod.add(RobotSemTokenModifiers.BUILTIN)
 
                 if kw_doc is not None and kw_doc.is_embedded and kw_doc.matcher.embedded_arguments:
-                    if get_robot_version() >= (6, 0):
+                    if get_robot_version() >= (7, 3):
+                        m = kw_doc.matcher.embedded_arguments.name.fullmatch(kw)
+                    elif get_robot_version() >= (6, 0):
                         m = kw_doc.matcher.embedded_arguments.match(kw)
                     else:
                         m = kw_doc.matcher.embedded_arguments.name.match(kw)

robotcode_language_server-1.3.0.dev2/src/robotcode/language_server/__version__.py

@@ -1 +0,0 @@
-__version__ = "1.3.0-dev.2"