Merge pull request microsoft#41 from pratham1002/pratham1002/gopls

feature: Go Language Support (gopls)

Author: LakshyAAAgrawal

.github/workflows/publish-to-pypi.yaml

@@ -14,6 +14,12 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.21'
+    - name: Install gopls
+      run: go install golang.org/x/tools/gopls@latest
     - name: Set up Python
       uses: actions/setup-python@v5
       with:

.github/workflows/test-workflow.yaml

@@ -13,6 +13,12 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - name: Set up Go
+      uses: actions/setup-go@v5
+      with:
+        go-version: '1.21'
+    - name: Install gopls
+      run: go install golang.org/x/tools/gopls@latest
     - name: Set up Python
       uses: actions/setup-python@v5
       with:

.gitignore

@@ -398,6 +398,7 @@ FodyWeavers.xsd
 *.sln.iml
 
 src/multilspy/language_servers/eclipse_jdtls/static/
+src/multilspy/language_servers/gopls/static/
 src/multilspy/language_servers/omnisharp/static/
 src/multilspy/language_servers/rust_analyzer/static/
 src/multilspy/language_servers/typescript_language_server/static/

src/multilspy/language_server.py

@@ -100,6 +100,10 @@ def create(cls, config: MultilspyConfig, logger: MultilspyLogger, repository_roo
                 TypeScriptLanguageServer,
             )
             return TypeScriptLanguageServer(config, logger, repository_root_path)
+        elif config.code_language == Language.GO:
+            from multilspy.language_servers.gopls.gopls import Gopls
+
+            return Gopls(config, logger, repository_root_path)
         else:
             logger.log(f"Language {config.code_language} is not supported", logging.ERROR)
             raise MultilspyException(f"Language {config.code_language} is not supported")

src/multilspy/language_servers/gopls/gopls.py

@@ -0,0 +1,151 @@
+import asyncio
+import json
+import logging
+import os
+import pathlib
+import subprocess
+from contextlib import asynccontextmanager
+from typing import AsyncIterator
+
+from multilspy.multilspy_logger import MultilspyLogger
+from multilspy.language_server import LanguageServer
+from multilspy.lsp_protocol_handler.server import ProcessLaunchInfo
+from multilspy.lsp_protocol_handler.lsp_types import InitializeParams
+from multilspy.multilspy_config import MultilspyConfig
+
+
+class Gopls(LanguageServer):
+    """
+    Provides Go specific instantiation of the LanguageServer class using gopls.
+    """
+
+    @staticmethod
+    def _get_go_version():
+        """Get the installed Go version or None if not found."""
+        try:
+            result = subprocess.run(['go', 'version'], capture_output=True, text=True)
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except FileNotFoundError:
+            return None
+        return None
+
+    @staticmethod
+    def _get_gopls_version():
+        """Get the installed gopls version or None if not found."""
+        try:
+            result = subprocess.run(['gopls', 'version'], capture_output=True, text=True)
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except FileNotFoundError:
+            return None
+        return None
+
+    @classmethod
+    def setup_runtime_dependency(cls):
+        """
+        Check if required Go runtime dependencies are available.
+        Raises RuntimeError with helpful message if dependencies are missing.
+        """
+        missing_deps = []
+        
+        # Check for Go installation
+        go_version = cls._get_go_version()
+        if not go_version:
+            missing_deps.append(("Go", "https://golang.org/doc/install"))
+        
+        # Check for gopls
+        gopls_version = cls._get_gopls_version()
+        if not gopls_version:
+            missing_deps.append(("gopls", "https://pkg.go.dev/golang.org/x/tools/gopls#section-readme"))
+        
+        if missing_deps:
+            error_msg = "Missing required dependencies:\n"
+            for dep, install_url in missing_deps:
+                error_msg += f"- {dep}: Please install from {install_url}\n"
+            raise RuntimeError(error_msg)
+        
+        return True
+
+    def __init__(self, config: MultilspyConfig, logger: MultilspyLogger, repository_root_path: str):
+        # Check runtime dependencies before initializing
+        self.setup_runtime_dependency()
+        
+        super().__init__(
+            config,
+            logger,
+            repository_root_path,
+            ProcessLaunchInfo(cmd="gopls", cwd=repository_root_path),
+            "go",
+        )
+        self.server_ready = asyncio.Event()
+        self.request_id = 0
+
+    def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
+        """
+        Returns the initialize params for the TypeScript Language Server.
+        """
+        with open(os.path.join(os.path.dirname(__file__), "initialize_params.json"), "r") as f:
+            d = json.load(f)
+
+        del d["_description"]
+
+        d["processId"] = os.getpid()
+        assert d["rootPath"] == "$rootPath"
+        d["rootPath"] = repository_absolute_path
+
+        assert d["rootUri"] == "$rootUri"
+        d["rootUri"] = pathlib.Path(repository_absolute_path).as_uri()
+
+        assert d["workspaceFolders"][0]["uri"] == "$uri"
+        d["workspaceFolders"][0]["uri"] = pathlib.Path(repository_absolute_path).as_uri()
+
+        assert d["workspaceFolders"][0]["name"] == "$name"
+        d["workspaceFolders"][0]["name"] = os.path.basename(repository_absolute_path)
+
+        return d
+
+    @asynccontextmanager
+    async def start_server(self) -> AsyncIterator["Gopls"]:
+        """Start gopls server process"""
+        async def register_capability_handler(params):
+            return
+
+        async def window_log_message(msg):
+            self.logger.log(f"LSP: window/logMessage: {msg}", logging.INFO)
+
+        async def do_nothing(params):
+            return
+
+        self.server.on_request("client/registerCapability", register_capability_handler)
+        self.server.on_notification("window/logMessage", window_log_message)
+        self.server.on_notification("$/progress", do_nothing)
+        self.server.on_notification("textDocument/publishDiagnostics", do_nothing)
+
+        async with super().start_server():
+            self.logger.log("Starting gopls server process", logging.INFO)
+            await self.server.start()
+            initialize_params = self._get_initialize_params(self.repository_root_path)
+
+            self.logger.log(
+                "Sending initialize request from LSP client to LSP server and awaiting response",
+                logging.INFO,
+            )
+            init_response = await self.server.send.initialize(initialize_params)
+            
+            # Verify server capabilities
+            assert "textDocumentSync" in init_response["capabilities"]
+            assert "completionProvider" in init_response["capabilities"]
+            assert "definitionProvider" in init_response["capabilities"]
+
+            self.server.notify.initialized({})
+            self.completions_available.set()
+
+            # gopls server is typically ready immediately after initialization
+            self.server_ready.set()
+            await self.server_ready.wait()
+
+            yield self
+
+            await self.server.shutdown()
+            await self.server.stop()

src/multilspy/language_servers/gopls/initialize_params.json

@@ -0,0 +1,36 @@
+{
+    "_description": "The parameters sent by the client when initializing the language server with the \"initialize\" request. More details at https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#initialize",
+    "processId": "os.getpid()",
+    "locale": "en",
+    "rootPath": "$rootPath",
+    "rootUri": "$rootUri",
+    "capabilities": {
+        "textDocument": {
+            "synchronization": {
+                "didSave": true,
+                "dynamicRegistration": true
+            },
+            "completion": {
+                "dynamicRegistration": true,
+                "completionItem": {
+                    "snippetSupport": true
+                }
+            },
+            "definition": {
+                "dynamicRegistration": true
+            }
+        },
+        "workspace": {
+            "workspaceFolders": true,
+            "didChangeConfiguration": {
+                "dynamicRegistration": true
+            }
+        }
+    },
+    "workspaceFolders": [
+        {
+            "uri": "$uri",
+            "name": "$name"
+        }
+    ]
+}

src/multilspy/multilspy_config.py

@@ -16,6 +16,7 @@ class Language(str, Enum):
     JAVA = "java"
     TYPESCRIPT = "typescript"
     JAVASCRIPT = "javascript"
+    GO = "go"
 
     def __str__(self) -> str:
         return self.value

tests/multilspy/test_multilspy_go.py

@@ -0,0 +1,98 @@
+"""
+This file contains tests for running the Golang Language Server: gopls
+"""
+
+import pytest
+from multilspy import LanguageServer
+from multilspy.multilspy_config import Language
+from tests.test_utils import create_test_context
+from pathlib import PurePath
+
+pytest_plugins = ("pytest_asyncio",)
+
+@pytest.mark.asyncio
+async def test_multilspy_golang_example():
+    """
+    Test the working of multilspy with golang repository - https://github.com/golang/example
+    """
+    code_language = Language.GO
+    params = {
+        "code_language": code_language,
+        "repo_url": "https://github.com/golang/example/",
+        "repo_commit": "1bcfdd08c5584d89507e37be70af63c72eb8c16f"
+    }
+    with create_test_context(params) as context:
+        lsp = LanguageServer.create(context.config, context.logger, context.source_directory)
+
+        async with lsp.start_server():
+            # Wait for server to be fully initialized
+            await lsp.server_ready.wait()
+            
+            path = str(PurePath("hello/hello.go"))
+            
+            # Test 1: Get definition of the 'reverse' package import
+            result = await lsp.request_definition(path, 29, 8)
+            assert isinstance(result, list)
+            assert len(result) == 1
+
+            item = result[0]
+            assert "reverse" in item["relativePath"]
+            assert item["range"]["start"]["line"] == 5  # Package declaration is after license header
+
+            # Test 2: Find references to the 'name' variable
+            result = await lsp.request_references(path, 61, 5)  # Position of name declaration
+            assert isinstance(result, list)
+            assert len(result) == 5 
+
+            for item in result:
+                del item["uri"]
+                del item["absolutePath"]
+
+            assert result == [
+                {
+                    'range': {
+                        'start': {'line': 59, 'character': 2},
+                        'end': {'line': 59, 'character': 6}
+                    },
+                    'relativePath': 'hello/hello.go'
+                },
+                {
+                    'range': {
+                        'start': {'line': 61, 'character': 4},
+                        'end': {'line': 61, 'character': 8}
+                    },
+                    'relativePath': 'hello/hello.go'
+                },
+                {
+                    'range': {
+                        'start': {'line': 62, 'character': 32},
+                        'end': {'line': 62, 'character': 36}
+                    },
+                    'relativePath': 'hello/hello.go'
+                },
+                {
+                    'range': {
+                        'start': {'line': 67, 'character': 68},
+                        'end': {'line': 67, 'character': 72}
+                    },
+                    'relativePath': 'hello/hello.go'
+                },
+                {
+                    'range': {
+                        'start': {'line': 70, 'character': 36},
+                        'end': {'line': 70, 'character': 40}
+                    },
+                    'relativePath': 'hello/hello.go'
+                }
+            ]
+
+            # Test 3: Get hover information for the 'name' variable
+            result = await lsp.request_hover(path, 59, 5)  # Position of reverse.String call
+            assert result is not None
+            assert "var name string" in result["contents"]["value"]
+            # Test 4: Get document symbols
+            result = await lsp.request_document_symbols(path)
+            assert isinstance(result, tuple)
+            
+            # Check if the symbols are in the result
+            assert [symbol["name"] for symbol in result[0]] == ["usage", "greeting", "reverseFlag", "main"]