Minor cleanup in LS implementations: methods not using state are static

Also reduced public interface

src/solidlsp/language_servers/clangd_language_server.py

@@ -27,7 +27,7 @@ class ClangdLanguageServer(SolidLanguageServer):
         """
         Creates a ClangdLanguageServer instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
         """
-        clangd_executable_path = self.setup_runtime_dependencies(logger, config)
+        clangd_executable_path = self._setup_runtime_dependencies(logger, config)
         super().__init__(
             config,
             logger,
@@ -40,9 +40,10 @@ class ClangdLanguageServer(SolidLanguageServer):
         self.initialize_searcher_command_available = threading.Event()
         self.resolve_main_method_available = threading.Event()
 
-    def setup_runtime_dependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
+    @staticmethod
+    def _setup_runtime_dependencies(logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
         """
-        Setup runtime dependencies for ClangdLanguageServer.
+        Setup runtime dependencies for ClangdLanguageServer and return the command to start the server.
         """
         platform_id = PlatformUtils.get_platform_id()
 
@@ -107,7 +108,8 @@ class ClangdLanguageServer(SolidLanguageServer):
 
         return clangd_executable_path
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the clangd Language Server.
         """

src/solidlsp/language_servers/clojure_lsp.py

@@ -75,7 +75,7 @@ class ClojureLSP(SolidLanguageServer):
         """
         Creates a ClojureLSP instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
         """
-        clojure_lsp_executable_path = self.setup_runtime_dependencies(logger, config)
+        clojure_lsp_executable_path = self._setup_runtime_dependencies(logger, config)
         super().__init__(
             config,
             logger,
@@ -88,12 +88,15 @@ class ClojureLSP(SolidLanguageServer):
         self.resolve_main_method_available = threading.Event()
         self.service_ready_event = threading.Event()
 
-    def setup_runtime_dependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
-        """Setup runtime dependencies for clojure-lsp."""
+    @staticmethod
+    def _setup_runtime_dependencies(logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
+        """Setup runtime dependencies for clojure-lsp and return the command to start the server."""
         verify_clojure_cli()
         platform_id = PlatformUtils.get_platform_id()
 
-        runtime_dependencies = [dependency for dependency in self.runtime_dependencies if dependency["platformId"] == platform_id.value]
+        runtime_dependencies = [
+            dependency for dependency in ClojureLSP.runtime_dependencies if dependency["platformId"] == platform_id.value
+        ]
         if len(runtime_dependencies) != 1:
             raise RuntimeError(f"Could not find a suitable clojure-lsp runtime dependency for platform {platform_id.value}.")
         dependency = runtime_dependencies[0]
@@ -109,7 +112,8 @@ class ClojureLSP(SolidLanguageServer):
         os.chmod(clojurelsp_executable_path, stat.S_IEXEC)
         return clojurelsp_executable_path
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """Returns the init params for clojure-lsp."""
         root_uri = pathlib.Path(repository_absolute_path).as_uri()
         return {  # type: ignore

src/solidlsp/language_servers/csharp_language_server.py

@@ -228,30 +228,32 @@ class CSharpLanguageServer(SolidLanguageServer):
     def is_ignored_dirname(self, dirname: str) -> bool:
         return super().is_ignored_dirname(dirname) or dirname in ["bin", "obj", "packages", ".vs"]
 
-    def _ensure_server_installed(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> tuple[str, str, Path]:
+    @staticmethod
+    def _ensure_server_installed(logger: LanguageServerLogger, config: LanguageServerConfig) -> tuple[str, str, Path]:
         """
         Ensure .NET runtime and Microsoft.CodeAnalysis.LanguageServer are available.
         Returns a tuple of (dotnet_path, language_server_dll_path, cache_dir).
         """
         # Determine platform runtime ID
-        runtime_id = self._get_runtime_id()
+        runtime_id = CSharpLanguageServer._get_runtime_id()
 
         # Set up cache directory
         cache_dir = Path.home() / ".cache" / "serena" / "language-servers" / "csharp"
         cache_dir.mkdir(parents=True, exist_ok=True)
 
         # Get runtime dependencies for this platform
-        lang_server_dep, dotnet_runtime_dep = self._get_runtime_dependencies(runtime_id)
+        lang_server_dep, dotnet_runtime_dep = CSharpLanguageServer._get_runtime_dependencies(runtime_id)
 
         # Ensure .NET runtime is available
-        dotnet_path = self._ensure_dotnet_runtime(logger, cache_dir, dotnet_runtime_dep)
+        dotnet_path = CSharpLanguageServer._ensure_dotnet_runtime(logger, cache_dir, dotnet_runtime_dep)
 
         # Ensure language server is available
-        server_dll_path = self._ensure_language_server(logger, cache_dir, lang_server_dep)
+        server_dll_path = CSharpLanguageServer._ensure_language_server(logger, cache_dir, lang_server_dep)
 
         return dotnet_path, server_dll_path, cache_dir
 
-    def _get_runtime_id(self) -> str:
+    @staticmethod
+    def _get_runtime_id() -> str:
         """Determine the runtime ID based on the platform."""
         system = platform.system().lower()
         machine = platform.machine().lower()
@@ -265,7 +267,8 @@ class CSharpLanguageServer(SolidLanguageServer):
         else:
             raise LanguageServerException(f"Unsupported platform: {system} {machine}")
 
-    def _get_runtime_dependencies(self, runtime_id: str) -> tuple[RuntimeDependency, RuntimeDependency]:
+    @staticmethod
+    def _get_runtime_dependencies(runtime_id: str) -> tuple[RuntimeDependency, RuntimeDependency]:
         """Get the language server and .NET runtime dependencies for the platform."""
         lang_server_dep = None
         dotnet_runtime_dep = None
@@ -283,7 +286,8 @@ class CSharpLanguageServer(SolidLanguageServer):
 
         return lang_server_dep, dotnet_runtime_dep
 
-    def _ensure_dotnet_runtime(self, logger: LanguageServerLogger, cache_dir: Path, runtime_dep: RuntimeDependency) -> str:
+    @staticmethod
+    def _ensure_dotnet_runtime(logger: LanguageServerLogger, cache_dir: Path, runtime_dep: RuntimeDependency) -> str:
         """Ensure .NET runtime is available and return the dotnet executable path."""
         # Check if dotnet is already available in system
         system_dotnet = shutil.which("dotnet")
@@ -300,9 +304,10 @@ class CSharpLanguageServer(SolidLanguageServer):
                 pass
 
         # Download .NET 9 runtime using config
-        return self._ensure_dotnet_runtime_from_config(logger, cache_dir, runtime_dep)
+        return CSharpLanguageServer._ensure_dotnet_runtime_from_config(logger, cache_dir, runtime_dep)
 
-    def _ensure_language_server(self, logger: LanguageServerLogger, cache_dir: Path, lang_server_dep: RuntimeDependency) -> str:
+    @staticmethod
+    def _ensure_language_server(logger: LanguageServerLogger, cache_dir: Path, lang_server_dep: RuntimeDependency) -> str:
         """Ensure language server is available and return the DLL path."""
         package_name = lang_server_dep.package_name
         package_version = lang_server_dep.package_version
@@ -316,10 +321,10 @@ class CSharpLanguageServer(SolidLanguageServer):
 
         # Download and install the language server
         logger.log(f"Downloading {package_name} version {package_version}...", logging.INFO)
-        package_path = self._download_nuget_package_direct(logger, package_name, package_version, cache_dir)
+        package_path = CSharpLanguageServer._download_nuget_package_direct(logger, package_name, package_version, cache_dir)
 
         # Extract and install
-        self._extract_language_server(lang_server_dep, package_path, server_dir)
+        CSharpLanguageServer._extract_language_server(lang_server_dep, package_path, server_dir)
 
         if not server_dll.exists():
             raise LanguageServerException("Microsoft.CodeAnalysis.LanguageServer.dll not found after extraction")
@@ -331,7 +336,8 @@ class CSharpLanguageServer(SolidLanguageServer):
         logger.log(f"Successfully installed Microsoft.CodeAnalysis.LanguageServer to {server_dll}", logging.INFO)
         return str(server_dll)
 
-    def _extract_language_server(self, lang_server_dep: RuntimeDependency, package_path: Path, server_dir: Path) -> None:
+    @staticmethod
+    def _extract_language_server(lang_server_dep: RuntimeDependency, package_path: Path, server_dir: Path) -> None:
         """Extract language server files from downloaded package."""
         extract_path = lang_server_dep.extract_path or "lib/net9.0"
         source_dir = package_path / extract_path
@@ -353,9 +359,8 @@ class CSharpLanguageServer(SolidLanguageServer):
         server_dir.mkdir(parents=True, exist_ok=True)
         shutil.copytree(source_dir, server_dir, dirs_exist_ok=True)
 
-    def _download_nuget_package_direct(
-        self, logger: LanguageServerLogger, package_name: str, package_version: str, cache_dir: Path
-    ) -> Path:
+    @staticmethod
+    def _download_nuget_package_direct(logger: LanguageServerLogger, package_name: str, package_version: str, cache_dir: Path) -> Path:
         """
         Download a NuGet package directly from the Azure NuGet feed.
         Returns the path to the extracted package directory.
@@ -411,7 +416,8 @@ class CSharpLanguageServer(SolidLanguageServer):
                 f"Failed to download package {package_name} version {package_version} from Azure NuGet feed: {e}"
             ) from e
 
-    def _ensure_dotnet_runtime_from_config(self, logger: LanguageServerLogger, cache_dir: Path, runtime_dep: RuntimeDependency) -> str:
+    @staticmethod
+    def _ensure_dotnet_runtime_from_config(logger: LanguageServerLogger, cache_dir: Path, runtime_dep: RuntimeDependency) -> str:
         """
         Ensure .NET 9 runtime is available using runtime dependency configuration.
         Returns the path to the dotnet executable.

src/solidlsp/language_servers/dart_language_server.py

@@ -18,7 +18,7 @@ class DartLanguageServer(SolidLanguageServer):
         """
         Creates a DartServer instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
         """
-        executable_path = self.setup_runtime_dependencies(logger)
+        executable_path = self._setup_runtime_dependencies(logger)
         super().__init__(
             config,
             logger,
@@ -27,7 +27,8 @@ class DartLanguageServer(SolidLanguageServer):
             "dart",
         )
 
-    def setup_runtime_dependencies(self, logger: "LanguageServerLogger") -> str:
+    @staticmethod
+    def _setup_runtime_dependencies(logger: "LanguageServerLogger") -> str:
         platform_id = PlatformUtils.get_platform_id()
 
         runtime_dependencies = [
@@ -90,7 +91,8 @@ class DartLanguageServer(SolidLanguageServer):
 
         return f"{dart_executable_path} language-server --client-id multilspy.dart --client-version 1.2"
 
-    def _get_initialize_params(self, repository_absolute_path: str):
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str):
         """
         Returns the initialize params for the Dart Language Server.
         """

src/solidlsp/language_servers/eclipse_jdtls.py

@@ -49,7 +49,7 @@ class EclipseJDTLS(SolidLanguageServer):
         Creates a new EclipseJDTLS instance initializing the language server settings appropriately.
         This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
         """
-        runtime_dependency_paths = self.setupRuntimeDependencies(logger, config)
+        runtime_dependency_paths = self._setupRuntimeDependencies(logger, config)
         self.runtime_dependency_paths = runtime_dependency_paths
 
         # ws_dir is the workspace directory for the EclipseJDTLS server
@@ -152,9 +152,10 @@ class EclipseJDTLS(SolidLanguageServer):
             "lib",  # General
         ]
 
-    def setupRuntimeDependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> RuntimeDependencyPaths:
+    @staticmethod
+    def _setupRuntimeDependencies(logger: LanguageServerLogger, config: LanguageServerConfig) -> RuntimeDependencyPaths:
         """
-        Setup runtime dependencies for EclipseJDTLS.
+        Setup runtime dependencies for EclipseJDTLS and return the paths.
         """
         platformId = PlatformUtils.get_platform_id()
 

src/solidlsp/language_servers/gopls.py

@@ -48,19 +48,19 @@ class Gopls(SolidLanguageServer):
             return None
         return None
 
-    @classmethod
-    def setup_runtime_dependency(cls):
+    @staticmethod
+    def _setup_runtime_dependency():
         """
         Check if required Go runtime dependencies are available.
         Raises RuntimeError with helpful message if dependencies are missing.
         """
-        go_version = cls._get_go_version()
+        go_version = Gopls._get_go_version()
         if not go_version:
             raise RuntimeError(
                 "Go is not installed. Please install Go from https://golang.org/doc/install and make sure it is added to your PATH."
             )
 
-        gopls_version = cls._get_gopls_version()
+        gopls_version = Gopls._get_gopls_version()
         if not gopls_version:
             raise RuntimeError(
                 "Found a Go version but gopls is not installed.\n"
@@ -71,7 +71,7 @@ class Gopls(SolidLanguageServer):
         return True
 
     def __init__(self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str):
-        self.setup_runtime_dependency()
+        self._setup_runtime_dependency()
 
         super().__init__(
             config,
@@ -83,9 +83,10 @@ class Gopls(SolidLanguageServer):
         self.server_ready = threading.Event()
         self.request_id = 0
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
-        Returns the initialize params for the TypeScript Language Server.
+        Returns the initialize params for the Go Language Server.
         """
         root_uri = pathlib.Path(repository_absolute_path).as_uri()
         initialize_params = {

src/solidlsp/language_servers/intelephense.py

@@ -32,9 +32,10 @@ class Intelephense(SolidLanguageServer):
         # - cache: commonly used for caching
         return super().is_ignored_dirname(dirname) or dirname in ["node_modules", "vendor", "cache"]
 
-    def setup_runtime_dependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
+    @staticmethod
+    def _setup_runtime_dependencies(logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
         """
-        Setup runtime dependencies for Intelephense.
+        Setup runtime dependencies for Intelephense and return the command to start the server.
         """
         platform_id = PlatformUtils.get_platform_id()
 
@@ -95,12 +96,13 @@ class Intelephense(SolidLanguageServer):
 
     def __init__(self, config: LanguageServerConfig, logger: LanguageServerLogger, repository_root_path: str):
         # Setup runtime dependencies before initializing
-        intelephense_cmd = self.setup_runtime_dependencies(logger, config)
+        intelephense_cmd = self._setup_runtime_dependencies(logger, config)
 
         super().__init__(config, logger, repository_root_path, ProcessLaunchInfo(cmd=intelephense_cmd, cwd=repository_root_path), "php")
         self.request_id = 0
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the TypeScript Language Server.
         """

src/solidlsp/language_servers/kotlin_language_server.py

@@ -36,7 +36,7 @@ class KotlinLanguageServer(SolidLanguageServer):
         """
         Creates a Kotlin Language Server instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
         """
-        runtime_dependency_paths = self.setup_runtime_dependencies(logger, config)
+        runtime_dependency_paths = self._setup_runtime_dependencies(logger, config)
         self.runtime_dependency_paths = runtime_dependency_paths
 
         # Create command to execute the Kotlin Language Server script
@@ -53,9 +53,10 @@ class KotlinLanguageServer(SolidLanguageServer):
             "kotlin",
         )
 
-    def setup_runtime_dependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> KotlinRuntimeDependencyPaths:
+    @staticmethod
+    def _setup_runtime_dependencies(logger: LanguageServerLogger, config: LanguageServerConfig) -> KotlinRuntimeDependencyPaths:
         """
-        Setup runtime dependencies for Kotlin Language Server.
+        Setup runtime dependencies for Kotlin Language Server and return the paths.
         """
         platform_id = PlatformUtils.get_platform_id()
 
@@ -161,7 +162,8 @@ class KotlinLanguageServer(SolidLanguageServer):
             java_path=java_path, java_home_path=java_home_path, kotlin_executable_path=kotlin_executable_path
         )
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the Kotlin Language Server.
         """

src/solidlsp/language_servers/pyright_server.py

@@ -46,7 +46,8 @@ class PyrightServer(SolidLanguageServer):
     def is_ignored_dirname(self, dirname: str) -> bool:
         return super().is_ignored_dirname(dirname) or dirname in ["venv", "__pycache__"]
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the Pyright Language Server.
         """

src/solidlsp/language_servers/rust_analyzer.py

@@ -27,7 +27,7 @@ class RustAnalyzer(SolidLanguageServer):
         """
         Creates a RustAnalyzer instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
         """
-        rustanalyzer_executable_path = self.setup_runtime_dependencies(logger, config)
+        rustanalyzer_executable_path = self._setup_runtime_dependencies(logger, config)
         super().__init__(
             config,
             logger,
@@ -44,9 +44,10 @@ class RustAnalyzer(SolidLanguageServer):
     def is_ignored_dirname(self, dirname: str) -> bool:
         return super().is_ignored_dirname(dirname) or dirname in ["target"]
 
-    def setup_runtime_dependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
+    @staticmethod
+    def _setup_runtime_dependencies(logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
         """
-        Setup runtime dependencies for rust_analyzer.
+        Setup runtime dependencies for rust_analyzer and return the command to start the server.
         """
         platform_id = PlatformUtils.get_platform_id()
 
@@ -99,7 +100,8 @@ class RustAnalyzer(SolidLanguageServer):
 
         return rustanalyzer_executable_path
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the Rust Analyzer Language Server.
         """

src/solidlsp/language_servers/solargraph.py

@@ -31,7 +31,7 @@ class Solargraph(SolidLanguageServer):
         Creates a Solargraph instance. This class is not meant to be instantiated directly.
         Use LanguageServer.create() instead.
         """
-        solargraph_executable_path = self.setup_runtime_dependencies(logger, config, repository_root_path)
+        solargraph_executable_path = self._setup_runtime_dependencies(logger, config, repository_root_path)
         super().__init__(
             config,
             logger,
@@ -48,9 +48,10 @@ class Solargraph(SolidLanguageServer):
     def is_ignored_dirname(self, dirname: str) -> bool:
         return super().is_ignored_dirname(dirname) or dirname in ["vendor"]
 
-    def setup_runtime_dependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig, repository_root_path: str) -> str:
+    @staticmethod
+    def _setup_runtime_dependencies(logger: LanguageServerLogger, config: LanguageServerConfig, repository_root_path: str) -> str:
         """
-        Setup runtime dependencies for Solargraph.
+        Setup runtime dependencies for Solargraph and return the command to start the server.
         """
         runtime_dependencies = [
             {
@@ -98,7 +99,8 @@ class Solargraph(SolidLanguageServer):
         except subprocess.CalledProcessError as e:
             raise RuntimeError(f"Failed to check or install Solargraph. {e.stderr}") from e
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the Solargraph Language Server.
         """

src/solidlsp/language_servers/typescript_language_server.py

@@ -44,7 +44,7 @@ class TypeScriptLanguageServer(SolidLanguageServer):
         """
         Creates a TypeScriptLanguageServer instance. This class is not meant to be instantiated directly. Use LanguageServer.create() instead.
         """
-        ts_lsp_executable_path = self.setup_runtime_dependencies(logger, config)
+        ts_lsp_executable_path = self._setup_runtime_dependencies(logger, config)
         super().__init__(
             config,
             logger,
@@ -64,9 +64,10 @@ class TypeScriptLanguageServer(SolidLanguageServer):
             "coverage",
         ]
 
-    def setup_runtime_dependencies(self, logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
+    @staticmethod
+    def _setup_runtime_dependencies(logger: LanguageServerLogger, config: LanguageServerConfig) -> str:
         """
-        Setup runtime dependencies for TypeScript Language Server.
+        Setup runtime dependencies for TypeScript Language Server and return the command to start the server.
         """
         platform_id = PlatformUtils.get_platform_id()
 
@@ -136,7 +137,8 @@ class TypeScriptLanguageServer(SolidLanguageServer):
         ), "typescript-language-server executable not found. Please install typescript-language-server and try again."
         return f"{tsserver_executable_path} --stdio"
 
-    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+    @staticmethod
+    def _get_initialize_params(repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialize params for the TypeScript Language Server.
         """