robotcode-language-server 1.3.0.dev6__tar.gz → 1.5.0__tar.gz

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotcode-language-server
-Version: 1.3.0.dev6
+Version: 1.5.0
 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.6
-Requires-Dist: robotcode-jsonrpc2==1.3.0-dev.6
-Requires-Dist: robotcode-robot==1.3.0-dev.6
-Requires-Dist: robotcode==1.3.0-dev.6
+Requires-Dist: robotcode-analyze==1.5.0
+Requires-Dist: robotcode-jsonrpc2==1.5.0
+Requires-Dist: robotcode-robot==1.5.0
+Requires-Dist: robotcode==1.5.0
 Requires-Dist: robotframework>=4.1.0
 Description-Content-Type: text/markdown
 

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/pyproject.toml

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

robotcode_language_server-1.5.0/src/robotcode/language_server/__version__.py

@@ -0,0 +1 @@
+__version__ = "1.5.0"

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/common/parts/diagnostics.py

@@ -1,7 +1,6 @@
 import concurrent.futures
 import functools
 import itertools
-import logging
 import time
 import uuid
 from concurrent.futures import CancelledError
@@ -361,7 +360,6 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
                 with self._logger.measure_time(
                     lambda: f"analyzing workspace for {len(documents)} documents",
                     context_name="workspace_diagnostics",
-                    level=logging.CRITICAL,
                 ):
                     self.on_workspace_diagnostics_analyze(self)
 
@@ -444,7 +442,6 @@ class DiagnosticsProtocolPart(LanguageServerProtocolPart):
                 with self._logger.measure_time(
                     lambda: f"collect workspace diagnostic for {len(documents_to_collect)} documents",
                     context_name="collect_workspace_diagnostics",
-                    level=logging.CRITICAL,
                 ):
                     breaked = False
                     for document in set(documents) - set(documents_to_collect):

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/common/parts/documents.py

@@ -47,10 +47,6 @@ class LanguageServerDocumentError(JsonRPCException):
     pass
 
 
-class CantReadDocumentError(Exception):
-    pass
-
-
 class TextDocumentProtocolPart(LanguageServerProtocolPart, DocumentsManager):
     __logger: Final = LoggingDescriptor()
 

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/common/parts/rename.py

@@ -46,12 +46,7 @@ class RenameProtocolPart(LanguageServerProtocolPart):
             )
 
     @event
-    def collect(
-        sender,
-        document: TextDocument,
-        position: Position,
-        new_name: str,
-    ) -> Optional[WorkspaceEdit]: ...
+    def collect(sender, document: TextDocument, position: Position, new_name: str) -> Optional[WorkspaceEdit]: ...
 
     @event
     def collect_prepare(sender, document: TextDocument, position: Position) -> Optional[PrepareRenameResult]: ...
@@ -81,6 +76,9 @@ class RenameProtocolPart(LanguageServerProtocolPart):
             check_current_task_canceled()
 
             if isinstance(result, BaseException):
+                if isinstance(result, CantRenameError):
+                    raise JsonRPCErrorException(ErrorCodes.INVALID_PARAMS, str(result))
+
                 if not isinstance(result, CancelledError):
                     self._logger.exception(result, exc_info=result)
             else:

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/common/parts/workspace.py

@@ -315,7 +315,7 @@ class Workspace(LanguageServerProtocolPart, CoreWorkspace, FileWatcherManagerBas
                 List[Any],
             )
 
-        result = self.settings
+        result: Any = self.settings
         for sub_key in str(section).split("."):
             if sub_key in result:
                 result = result.get(sub_key, None)

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/common/protocol.py

@@ -98,15 +98,6 @@ class LanguageServerLogHandler(logging.Handler):
             if self.trace != TraceValues.OFF:
                 self.protocol.log_trace(record.getMessage())
 
-        type = self.MAPPING.get(record.levelno, None)
-        if type is None:
-            type = MessageType.LOG
-
-        self.protocol.window_log_message(
-            type=type,
-            message=record.getMessage(),
-        )
-
 
 class LanguageServerProtocol(JsonRPCProtocol):
     __logger = LoggingDescriptor()

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/robotframework/parts/formatting.py

@@ -17,13 +17,12 @@ from robotcode.robot.utils import get_robot_version
 
 from ..configuration import RoboCopConfig, RoboTidyConfig
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
+class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -31,7 +30,9 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
 
         parent.formatting.format.add(self.format)
 
-        if self.robotidy_installed or (self.robocop_installed and self.robocop_version >= (6, 0)):
+        if self.parent.robocop_helper.robotidy_installed or (
+            self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.robocop_version >= (6, 0)
+        ):
             parent.formatting.format_range.add(self.format_range)
 
         self.space_count = 4
@@ -64,8 +65,8 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
         options: FormattingOptions,
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
-        if self.robocop_installed and self.robocop_version >= (6, 0):
-            if not self.is_robocop_notification_shown and self.robotidy_installed:
+        if self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.robocop_version >= (6, 0):
+            if not self.is_robocop_notification_shown and self.parent.robocop_helper.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"
@@ -78,7 +79,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
             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:
+        if (tidy_config.enabled or get_robot_version() >= (5, 0)) and self.parent.robocop_helper.robotidy_installed:
             return self.format_robot_tidy(document, options, config=tidy_config, **further_options)
 
         if get_robot_version() < (5, 0):
@@ -105,18 +106,18 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
 
             model = self.parent.documents_cache.get_model(document, False)
 
-            if self.robotidy_version >= (3, 0):
+            if self.parent.robocop_helper.robotidy_version >= (3, 0):
                 from robotidy.api import get_robotidy
                 from robotidy.disablers import RegisterDisablers
 
-                if self.robotidy_version >= (4, 2):
+                if self.parent.robocop_helper.robotidy_version >= (4, 2):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
                         ignore_git_dir=config.ignore_git_dir,
                         config=config.config,
                     )
-                elif self.robotidy_version >= (4, 1):
+                elif self.parent.robocop_helper.robotidy_version >= (4, 1):
                     robot_tidy = get_robotidy(
                         document.uri.to_path(),
                         None,
@@ -135,14 +136,14 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
                 )
                 disabler_finder.visit(model)
 
-                if self.robotidy_version >= (4, 11):
+                if self.parent.robocop_helper.robotidy_version >= (4, 11):
                     if disabler_finder.is_disabled_in_file():
                         return None
                 else:
                     if disabler_finder.file_disabled:
                         return None
 
-                if self.robotidy_version >= (4, 0):
+                if self.parent.robocop_helper.robotidy_version >= (4, 0):
                     _, _, new, _ = robot_tidy.transform_until_stable(model, disabler_finder)
                 else:
                     _, _, new = robot_tidy.transform(model, disabler_finder.disablers)
@@ -156,7 +157,7 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
                     robot_tidy.formatting_config.start_line = range.start.line + 1
                     robot_tidy.formatting_config.end_line = range.end.line + 1
 
-                if self.robotidy_version >= (2, 2):
+                if self.parent.robocop_helper.robotidy_version >= (2, 2):
                     from robotidy.disablers import RegisterDisablers
 
                     disabler_finder = RegisterDisablers(
@@ -197,19 +198,13 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
         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)
         workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
+        if workspace_folder is None:
+            return None
 
-        config_manager = ConfigManager(
-            [document.uri.to_path()],
-            root=workspace_folder.uri.to_path() if workspace_folder else None,
-            config=robocop_config.config_file,
-            ignore_git_dir=robocop_config.ignore_git_dir,
-            ignore_file_config=robocop_config.ignore_file_config,
-        )
+        config_manager = self.parent.robocop_helper.get_config_manager(workspace_folder)
 
         config = config_manager.get_config_for_source_file(document.uri.to_path())
 
@@ -284,7 +279,9 @@ class RobotFormattingProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMi
         **further_options: Any,
     ) -> Optional[List[TextEdit]]:
         config = self.get_tidy_config(document)
-        if (config.enabled and self.robotidy_installed) or (self.robocop_installed and self.robocop_version >= (6, 0)):
+        if (config.enabled and self.parent.robocop_helper.robotidy_installed) or (
+            self.parent.robocop_helper.robocop_installed and self.parent.robocop_helper.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.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/robotframework/parts/hover.py

@@ -73,7 +73,7 @@ class RobotHoverProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         for base in cls.__bases__:
             method = self._find_method(base)
             if method:
-                return cast(_HoverMethod, method)
+                return method
 
         return None
 

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/robotframework/parts/inlay_hint.py

@@ -61,7 +61,7 @@ class RobotInlayHintProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         for base in cls.__bases__:
             method = self._find_method(base)
             if method:
-                return cast(_HandlerMethod, method)
+                return method
 
         return None
 

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/robotframework/parts/project_info.py

@@ -10,7 +10,6 @@ from robotcode.jsonrpc2.protocol import rpc_method
 
 from ...__version__ import __version__ as robotcode_version
 from .protocol_part import RobotLanguageServerProtocolPart
-from .robocop_tidy_mixin import RoboCopTidyMixin
 
 if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
@@ -26,7 +25,7 @@ class ProjectInfo(CamelSnakeMixin):
     robot_code_version_string: Optional[str] = None
 
 
-class ProjectInfoPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
+class ProjectInfoPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -40,12 +39,12 @@ class ProjectInfoPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
         **kwargs: Any,
     ) -> ProjectInfo:
         robocop_version_string = None
-        if self.robocop_installed:
-            robocop_version_string = self.robocop_version_str
+        if self.parent.robocop_helper.robocop_installed:
+            robocop_version_string = self.parent.robocop_helper.robocop_version_str
 
         tidy_version_string = None
-        if self.robotidy_installed:
-            tidy_version_string = self.robotidy_version_str
+        if self.parent.robocop_helper.robotidy_installed:
+            tidy_version_string = self.parent.robocop_helper.robotidy_version_str
 
         return ProjectInfo(
             robot_version_string=get_version(),

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/robotframework/parts/references.py

@@ -113,7 +113,7 @@ class RobotReferencesProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
         for base in cls.__bases__:
             method = self._find_method(base)
             if method:
-                return cast(_ReferencesMethod, method)
+                return method
         return None
 
     @language_id("robotframework")

robotcode_language_server-1.5.0/src/robotcode/language_server/robotframework/parts/rename.py

@@ -0,0 +1,260 @@
+import ast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    List,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from robotcode.core.concurrent import check_current_task_canceled
+from robotcode.core.language import language_id
+from robotcode.core.lsp.types import (
+    AnnotatedTextEdit,
+    ChangeAnnotation,
+    CreateFile,
+    DeleteFile,
+    OptionalVersionedTextDocumentIdentifier,
+    Position,
+    PrepareRenameResult,
+    PrepareRenameResultType1,
+    Range,
+    RenameFile,
+    TextDocumentEdit,
+    WorkspaceEdit,
+)
+from robotcode.core.text_document import TextDocument
+from robotcode.core.utils.logging import LoggingDescriptor
+from robotcode.robot.diagnostics.entities import (
+    VariableDefinition,
+    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
+
+if TYPE_CHECKING:
+    from ..protocol import RobotLanguageServerProtocol
+
+
+_RenameMethod = Callable[[ast.AST, TextDocument, Position, str], Optional[WorkspaceEdit]]
+_PrepareRenameMethod = Callable[[ast.AST, TextDocument, Position], Optional[PrepareRenameResult]]
+
+_T = TypeVar("_T", bound=Callable[..., Any])
+
+
+class RobotRenameProtocolPart(RobotLanguageServerProtocolPart, ModelHelper):
+    _logger = LoggingDescriptor()
+
+    def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
+        super().__init__(parent)
+
+        parent.rename.collect.add(self.collect)
+        parent.rename.collect_prepare.add(self.collect_prepare)
+
+    @language_id("robotframework")
+    @_logger.call
+    def collect(
+        self, sender: Any, document: TextDocument, position: Position, new_name: str
+    ) -> Optional[WorkspaceEdit]:
+        result = self._rename_variable(document, position, new_name)
+        if result:
+            return result
+
+        result = self._rename_keyword(document, position, new_name)
+        if result:
+            return result
+
+        return None
+
+    @language_id("robotframework")
+    @_logger.call
+    def collect_prepare(self, sender: Any, document: TextDocument, position: Position) -> Optional[PrepareRenameResult]:
+        result = self._prepare_rename_variable(document, position)
+        if result:
+            return result
+
+        result = self._prepare_rename_keyword(document, position)
+        if result:
+            return result
+
+        return None
+
+    def _prepare_rename_variable(self, document: TextDocument, position: Position) -> Optional[PrepareRenameResult]:
+        result = self._find_variable_definition_on_pos(document, position)
+        if result is not None:
+            var, found_range = result
+
+            if var.type == VariableDefinitionType.BUILTIN_VARIABLE:
+                self.parent.window.show_message("You cannot rename a builtin variable, only references are renamed.")
+
+            elif var.type == VariableDefinitionType.IMPORTED_VARIABLE:
+                self.parent.window.show_message(
+                    "You are about to rename an imported variable. "
+                    "Only references are renamed and you have to rename the variable definition yourself."
+                )
+            elif var.type == VariableDefinitionType.COMMAND_LINE_VARIABLE:
+                self.parent.window.show_message(
+                    "You are about to rename a variable defined at commandline. "
+                    "Only references are renamed and you have to rename the variable definition yourself."
+                )
+            elif var.type == VariableDefinitionType.ENVIRONMENT_VARIABLE:
+                self.parent.window.show_message(
+                    "You are about to rename an environment variable. "
+                    "Only references are renamed and you have to rename the variable definition yourself."
+                )
+
+            return PrepareRenameResultType1(found_range, document.get_text(found_range))
+
+        return None
+
+    def _rename_variable(self, document: TextDocument, position: Position, new_name: str) -> Optional[WorkspaceEdit]:
+        if "  " in new_name or "\t" in new_name:
+            raise CantRenameError(
+                "Variable names cannot contain more then one spaces or tabs. "
+                "Please use only one space or underscores instead.",
+            )
+
+        result = self._find_variable_definition_on_pos(document, position)
+
+        if result is not None:
+            var, _ = result
+
+            references = self.parent.robot_references.find_variable_references(
+                document,
+                var,
+                include_declaration=var.type
+                in [
+                    VariableDefinitionType.VARIABLE,
+                    VariableDefinitionType.ARGUMENT,
+                    VariableDefinitionType.LOCAL_VARIABLE,
+                ],
+            )
+            changes: List[Union[TextDocumentEdit, CreateFile, RenameFile, DeleteFile]] = []
+
+            for reference in references:
+                changes.append(
+                    TextDocumentEdit(
+                        OptionalVersionedTextDocumentIdentifier(reference.uri, None),
+                        [AnnotatedTextEdit("rename_variable", reference.range, new_name)],
+                    )
+                )
+
+            return WorkspaceEdit(
+                document_changes=changes,
+                change_annotations={"rename_variable": ChangeAnnotation("Rename Variable", False)},
+            )
+
+        return None
+
+    def _find_variable_definition_on_pos(
+        self, document: TextDocument, position: Position
+    ) -> Optional[Tuple[VariableDefinition, Range]]:
+        namespace = self.parent.documents_cache.get_namespace(document)
+
+        all_variable_refs = namespace.get_variable_references()
+        if all_variable_refs:
+            for variable, var_refs in all_variable_refs.items():
+                check_current_task_canceled()
+
+                found_range = (
+                    variable.name_range
+                    if variable.source == namespace.source and position.is_in_range(variable.name_range, False)
+                    else cast(
+                        Optional[Range],
+                        next(
+                            (r.range for r in var_refs if position.is_in_range(r.range)),
+                            None,
+                        ),
+                    )
+                )
+
+                if found_range is not None:
+                    return variable, found_range
+        return None
+
+    def _prepare_rename_keyword(self, document: TextDocument, position: Position) -> Optional[PrepareRenameResult]:
+        result = self._find_keyword_definition_on_pos(document, position)
+        if result is not None:
+            kw_doc, found_range = result
+
+            if kw_doc.is_embedded:
+                raise CantRenameError("Renaming of keywords with embedded parameters is not supported.")
+
+            if kw_doc.is_library_keyword:
+                self.parent.window.show_message(
+                    "You are about to rename a library keyword. "
+                    "Only references are renamed and you have to rename the keyword definition yourself."
+                )
+
+            return PrepareRenameResultType1(found_range, document.get_text(found_range))
+
+        return None
+
+    def _rename_keyword(self, document: TextDocument, position: Position, new_name: str) -> Optional[WorkspaceEdit]:
+        if "  " in new_name or "\t" in new_name:
+            raise CantRenameError(
+                "Keyword names cannot contain more then one spaces or tabs. "
+                "Please use only one space or underscores instead.",
+            )
+
+        result = self._find_keyword_definition_on_pos(document, position)
+        if result is not None:
+            kw_doc, _ = result
+
+            references = self.parent.robot_references.find_keyword_references(
+                document,
+                kw_doc,
+                include_declaration=kw_doc.is_resource_keyword,
+            )
+            changes: List[Union[TextDocumentEdit, CreateFile, RenameFile, DeleteFile]] = []
+
+            for reference in references:
+                changes.append(
+                    TextDocumentEdit(
+                        OptionalVersionedTextDocumentIdentifier(reference.uri, None),
+                        [AnnotatedTextEdit("rename_keyword", reference.range, new_name)],
+                    )
+                )
+
+            return WorkspaceEdit(
+                document_changes=changes,
+                change_annotations={"rename_keyword": ChangeAnnotation("Rename Keyword", False)},
+            )
+
+        return None
+
+    def _find_keyword_definition_on_pos(
+        self, document: TextDocument, position: Position
+    ) -> Optional[Tuple[KeywordDoc, Range]]:
+        namespace = self.parent.documents_cache.get_namespace(document)
+
+        all_refs = namespace.get_keyword_references()
+        if all_refs:
+            for keyword, kw_refs in all_refs.items():
+                check_current_task_canceled()
+
+                found_range = (
+                    keyword.name_range
+                    if keyword.source == namespace.source and position.is_in_range(keyword.name_range, False)
+                    else cast(
+                        Optional[Range],
+                        next(
+                            (r.range for r in kw_refs if position.is_in_range(r.range)),
+                            None,
+                        ),
+                    )
+                )
+
+                if found_range is not None:
+                    return keyword, found_range
+        return None
+
+    # TODO: rename tags
+    # TODO: rename resource files and libraries

{robotcode_language_server-1.3.0.dev6 → robotcode_language_server-1.5.0}/src/robotcode/language_server/robotframework/parts/robocop_diagnostics.py

@@ -18,7 +18,6 @@ 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 robocop.linter.runner import RobocopLinter
@@ -26,7 +25,7 @@ if TYPE_CHECKING:
     from ..protocol import RobotLanguageServerProtocol
 
 
-class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboCopTidyMixin):
+class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart):
     _logger = LoggingDescriptor()
 
     def __init__(self, parent: "RobotLanguageServerProtocol") -> None:
@@ -35,7 +34,7 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboC
         self.source_name = "robocop"
         self._robocop_linters: WeakKeyDictionary[WorkspaceFolder, "RobocopLinter"] = WeakKeyDictionary()
 
-        if self.robocop_installed:
+        if self.parent.robocop_helper.robocop_installed:
             parent.diagnostics.collect.add(self.collect_diagnostics)
 
     def get_config(self, document: TextDocument) -> Optional[RoboCopConfig]:
@@ -50,18 +49,15 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboC
     def collect_diagnostics(
         self, sender: Any, document: TextDocument, diagnostics_type: DiagnosticsCollectType
     ) -> Optional[DiagnosticsResult]:
-        if self.robocop_installed:
+        if self.parent.robocop_helper.robocop_installed:
             workspace_folder = self.parent.workspace.get_workspace_folder(document.uri)
             if workspace_folder is not None:
                 config = self.get_config(document)
 
                 if config is not None and config.enabled:
-                    if self.robocop_version >= (6, 0):
+                    if self.parent.robocop_helper.robocop_version >= (6, 0):
                         # In Robocop 6.0, the diagnostics are collected in a different way
-                        return DiagnosticsResult(
-                            self.collect_diagnostics,
-                            self.collect(document, workspace_folder, config),
-                        )
+                        return DiagnosticsResult(self.collect_diagnostics, self.collect(document, workspace_folder))
 
                     return DiagnosticsResult(
                         self.collect_diagnostics,
@@ -71,26 +67,17 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboC
         return None
 
     @_logger.call
-    def collect(
-        self,
-        document: TextDocument,
-        workspace_folder: WorkspaceFolder,
-        extension_config: RoboCopConfig,
-    ) -> List[Diagnostic]:
-        from robocop.config import ConfigManager
+    def collect(self, document: TextDocument, workspace_folder: WorkspaceFolder) -> List[Diagnostic]:
         from robocop.linter.rules import RuleSeverity
         from robocop.linter.runner import RobocopLinter
 
         linter = self._robocop_linters.get(workspace_folder, None)
 
         if linter is None:
-            config_manager = ConfigManager(
-                [],
-                root=workspace_folder.uri.to_path(),
-                config=extension_config.config_file,
-                ignore_git_dir=extension_config.ignore_git_dir,
-                ignore_file_config=extension_config.ignore_file_config,
-            )
+            config_manager = self.parent.robocop_helper.get_config_manager(workspace_folder)
+
+            config = config_manager.get_config_for_source_file(document.uri.to_path())
+
             linter = RobocopLinter(config_manager)
             self._robocop_linters[workspace_folder] = linter
 
@@ -128,7 +115,7 @@ class RobotRoboCopDiagnosticsProtocolPart(RobotLanguageServerProtocolPart, RoboC
                 ),
                 source=self.source_name,
                 code=f"{diagnostic.rule.rule_id}-{diagnostic.rule.name}",
-                code_description=self.get_code_description(self.robocop_version, diagnostic),
+                code_description=self.get_code_description(self.parent.robocop_helper.robocop_version, diagnostic),
             )
             for diagnostic in diagnostics
         ]