Unique command names

internal/context/context.go

@@ -35,6 +35,7 @@ var (
 	ctxRootModuleLoader  = &contextKey{"root module loader"}
 	ctxRootDir           = &contextKey{"root directory"}
 	ctxDiags             = &contextKey{"diagnostics"}
+	ctxServerID          = &contextKey{"server id"}
 )
 
 func missingContextErr(ctxKey *contextKey) *MissingContextErr {
@@ -190,6 +191,28 @@ func RootDirectory(ctx context.Context) (string, bool) {
 	return *rootDir, true
 }
 
+func WithServerID(ctx context.Context, id *string) context.Context {
+	return context.WithValue(ctx, ctxServerID, id)
+}
+
+func SetServerID(ctx context.Context, id string) error {
+	serverID, ok := ctx.Value(ctxServerID).(*string)
+	if !ok {
+		return missingContextErr(ctxServerID)
+	}
+
+	*serverID = id
+	return nil
+}
+
+func ServerID(ctx context.Context) (string, bool) {
+	serverID, ok := ctx.Value(ctxServerID).(*string)
+	if !ok {
+		return "", false
+	}
+	return *serverID, true
+}
+
 func WithRootModuleWalker(ctx context.Context, w *rootmodule.Walker) context.Context {
 	return context.WithValue(ctx, ctxRootModuleWalker, w)
 }

internal/settings/settings.go

@@ -2,13 +2,15 @@ package settings
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/mapstructure"
 )
 
 type Options struct {
 	// RootModulePaths describes a list of absolute paths to root modules
 	RootModulePaths    []string `mapstructure:"rootModulePaths"`
 	ExcludeModulePaths []string `mapstructure:"excludeModulePaths"`
+	ID                 string   `mapstructure:"id"`
 
 	// TODO: Need to check for conflict with CLI flags
 	// TerraformExecPath string

langserver/handlers/execute_command.go

@@ -7,26 +7,35 @@ import (
 	"strings"
 
 	"github.com/creachadair/jrpc2/code"
+	lsctx "github.com/hashicorp/terraform-ls/internal/context"
 	lsp "github.com/sourcegraph/go-lsp"
 )
 
+const commandPrefix = "terraform-ls."
+
 type executeCommandHandler func(context.Context, commandArgs) (interface{}, error)
 type executeCommandHandlers map[string]executeCommandHandler
 
 var handlers = executeCommandHandlers{
 	"rootmodules": executeCommandRootModulesHandler,
 }
 
-func (h executeCommandHandlers) Names() []string {
-	var names []string
+func (h executeCommandHandlers) Names(suffix string) []string {
+	if suffix != "" && !strings.HasPrefix(suffix, ".") {
+		suffix = "." + suffix
+	}
+	var fullnames []string
 	for name := range h {
-		names = append(names, name)
+		fullnames = append(fullnames, commandPrefix+name+suffix)
 	}
-	return names
+	return fullnames
 }
 
 func (lh *logHandler) WorkspaceExecuteCommand(ctx context.Context, params lsp.ExecuteCommandParams) (interface{}, error) {
-	handler, ok := handlers[params.Command]
+	serverID, _ := lsctx.ServerID(ctx)
+	name := strings.TrimPrefix(params.Command, commandPrefix)
+	name = strings.TrimSuffix(name, "."+serverID)
+	handler, ok := handlers[name]
 	if !ok {
 		return nil, fmt.Errorf("%w: command handler not found for %q", code.MethodNotFound.Err(), params.Command)
 	}

langserver/handlers/execute_command_rootmodules_test.go

@@ -31,7 +31,10 @@ func TestLangServer_workspaceExecuteCommand_rootmodules_argumentError(t *testing
 		ReqParams: fmt.Sprintf(`{
 	    "capabilities": {},
 	    "rootUri": %q,
-	    "processId": 12345
+		"processId": 12345,
+		"initializationOptions": {
+			"id": "1"
+		}
 	}`, tmpDir.URI())})
 	ls.Notify(t, &langserver.CallRequest{
 		Method:    "initialized",
@@ -50,9 +53,9 @@ func TestLangServer_workspaceExecuteCommand_rootmodules_argumentError(t *testing
 
 	ls.CallAndExpectError(t, &langserver.CallRequest{
 		Method: "workspace/executeCommand",
-		ReqParams: `{
-		"command": "rootmodules"
-	}`}, code.InvalidParams.Err())
+		ReqParams: fmt.Sprintf(`{
+		"command": "terraform-ls.rootmodules.1"
+	}`)}, code.InvalidParams.Err())
 }
 
 func TestLangServer_workspaceExecuteCommand_rootmodules_basic(t *testing.T) {
@@ -75,7 +78,10 @@ func TestLangServer_workspaceExecuteCommand_rootmodules_basic(t *testing.T) {
 		ReqParams: fmt.Sprintf(`{
 	    "capabilities": {},
 	    "rootUri": %q,
-	    "processId": 12345
+		"processId": 12345,
+		"initializationOptions": {
+			"id": "1"
+		}
 	}`, tmpDir.URI())})
 	ls.Notify(t, &langserver.CallRequest{
 		Method:    "initialized",
@@ -95,7 +101,7 @@ func TestLangServer_workspaceExecuteCommand_rootmodules_basic(t *testing.T) {
 	ls.CallAndExpectResponse(t, &langserver.CallRequest{
 		Method: "workspace/executeCommand",
 		ReqParams: fmt.Sprintf(`{
-		"command": "rootmodules",
+		"command": "terraform-ls.rootmodules.1",
 		"arguments": ["uri=%s"] 
 	}`, testFileURI)}, fmt.Sprintf(`{
 		"jsonrpc": "2.0",
@@ -146,7 +152,10 @@ func TestLangServer_workspaceExecuteCommand_rootmodules_multiple(t *testing.T) {
 		ReqParams: fmt.Sprintf(`{
 	    "capabilities": {},
 	    "rootUri": %q,
-	    "processId": 12345
+		"processId": 12345,
+		"initializationOptions": {
+			"id": "1"
+		}
 	}`, root.URI())})
 	ls.Notify(t, &langserver.CallRequest{
 		Method:    "initialized",
@@ -158,7 +167,7 @@ func TestLangServer_workspaceExecuteCommand_rootmodules_multiple(t *testing.T) {
 	ls.CallAndExpectResponse(t, &langserver.CallRequest{
 		Method: "workspace/executeCommand",
 		ReqParams: fmt.Sprintf(`{
-		"command": "rootmodules",
+		"command": "terraform-ls.rootmodules.1",
 		"arguments": ["uri=%s"] 
 	}`, module.URI())}, fmt.Sprintf(`{
 		"jsonrpc": "2.0",

langserver/handlers/handlers_test.go

@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -16,29 +17,38 @@ import (
 	"github.com/stretchr/testify/mock"
 )
 
-const initializeResponse = `{
-	"jsonrpc": "2.0",
-	"id": 1,
-	"result": {
-		"capabilities": {
-			"textDocumentSync": {
-				"openClose": true,
-				"change": 2
-			},
-			"completionProvider": {},
-			"documentSymbolProvider":true,
-			"documentFormattingProvider":true,
-			"executeCommandProvider": {
-				"commands": ["rootmodules"]
+func initializeResponse(t *testing.T, commandSuffix string) string {
+	jsonArray, err := json.Marshal(handlers.Names("." + commandSuffix))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return fmt.Sprintf(`{
+		"jsonrpc": "2.0",
+		"id": 1,
+		"result": {
+			"capabilities": {
+				"textDocumentSync": {
+					"openClose": true,
+					"change": 2
+				},
+				"completionProvider": {},
+				"documentSymbolProvider":true,
+				"documentFormattingProvider":true,
+				"executeCommandProvider": {
+					"commands": %s
+				}
 			}
 		}
-	}
-}`
+	}`, string(jsonArray))
+}
 
 func TestInitalizeAndShutdown(t *testing.T) {
+	tmpDir := TempDir(t)
+
 	ls := langserver.NewLangServerMock(t, NewMockSession(&MockSessionInput{
 		RootModules: map[string]*rootmodule.RootModuleMock{
-			TempDir(t).Dir(): {TfExecFactory: validTfMockCalls()},
+			tmpDir.Dir(): {TfExecFactory: validTfMockCalls()},
 		}}))
 	stop := ls.Start(t)
 	defer stop()
@@ -48,8 +58,11 @@ func TestInitalizeAndShutdown(t *testing.T) {
 		ReqParams: fmt.Sprintf(`{
 	    "capabilities": {},
 	    "rootUri": %q,
-	    "processId": 12345
-	}`, TempDir(t).URI())}, initializeResponse)
+		"processId": 12345,
+		"initializationOptions": {
+			"id": "1"
+		}
+	}`, tmpDir.URI())}, initializeResponse(t, "1"))
 	ls.CallAndExpectResponse(t, &langserver.CallRequest{
 		Method: "shutdown", ReqParams: `{}`},
 		`{
@@ -60,6 +73,8 @@ func TestInitalizeAndShutdown(t *testing.T) {
 }
 
 func TestEOF(t *testing.T) {
+	tmpDir := TempDir(t)
+
 	ms := newMockSession(&MockSessionInput{
 		RootModules: map[string]*rootmodule.RootModuleMock{
 			TempDir(t).Dir(): {TfExecFactory: validTfMockCalls()},
@@ -73,8 +88,11 @@ func TestEOF(t *testing.T) {
 		ReqParams: fmt.Sprintf(`{
 	    "capabilities": {},
 	    "rootUri": %q,
-	    "processId": 12345
-	}`, TempDir(t).URI())}, initializeResponse)
+		"processId": 12345,
+		"initializationOptions": {
+			"id": "1"
+		}
+	}`, tmpDir.URI())}, initializeResponse(t, "1"))
 
 	ls.CloseClientStdout(t)
 

langserver/handlers/initialize.go

@@ -28,9 +28,6 @@ func (lh *logHandler) Initialize(ctx context.Context, params lsp.InitializeParam
 			},
 			DocumentFormattingProvider: true,
 			DocumentSymbolProvider:     true,
-			ExecuteCommandProvider: &lsp.ExecuteCommandOptions{
-				Commands: handlers.Names(),
-			},
 		},
 	}
 
@@ -77,6 +74,16 @@ func (lh *logHandler) Initialize(ctx context.Context, params lsp.InitializeParam
 	if err != nil {
 		return serverCaps, err
 	}
+
+	// set server ID
+	err = lsctx.SetServerID(ctx, out.Options.ID)
+	if err != nil {
+		return serverCaps, err
+	}
+	// apply suffix to executeCommand handler names
+	serverCaps.Capabilities.ExecuteCommandProvider = &lsp.ExecuteCommandOptions{
+		Commands: handlers.Names(out.Options.ID),
+	}
 	if len(out.UnusedKeys) > 0 {
 		jrpc2.PushNotify(ctx, "window/showMessage", &lsp.ShowMessageParams{
 			Type:    lsp.MTWarning,

langserver/handlers/service.go

@@ -145,6 +145,7 @@ func (svc *service) Assigner() (jrpc2.Assigner, error) {
 	diags := diagnostics.NewNotifier(svc.sessCtx, svc.logger)
 
 	rootDir := ""
+	serverID := ""
 
 	m := map[string]rpch.Func{
 		"initialize": func(ctx context.Context, req *jrpc2.Request) (interface{}, error) {
@@ -157,6 +158,7 @@ func (svc *service) Assigner() (jrpc2.Assigner, error) {
 			ctx = lsctx.WithWatcher(ctx, ww)
 			ctx = lsctx.WithRootModuleWalker(ctx, svc.walker)
 			ctx = lsctx.WithRootDirectory(ctx, &rootDir)
+			ctx = lsctx.WithServerID(ctx, &serverID)
 			ctx = lsctx.WithRootModuleManager(ctx, svc.modMgr)
 			ctx = lsctx.WithRootModuleLoader(ctx, rmLoader)
 
@@ -240,7 +242,7 @@ func (svc *service) Assigner() (jrpc2.Assigner, error) {
 				return nil, err
 			}
 
-			ctx = lsctx.WithRootDirectory(ctx, &rootDir)
+			ctx = lsctx.WithServerID(ctx, &serverID)
 			ctx = lsctx.WithRootModuleCandidateFinder(ctx, svc.modMgr)
 			ctx = lsctx.WithRootModuleWalker(ctx, svc.walker)