internal/golangorgx/gopls: Get cue lsp to initialize with emacs lsp

Emacs does support workspaces, but the initialize handshake can use the
RootURI scheme. The upstream Gopls code to handle this is very simple,
and so we take the same approach here: converting the RootURI into a
workspace, if-and-only-if there are no workspaceFolders provided.

We still enforce the requirement that, for now, only one workspace
folder is supported.

With this change, Emacs finishes the initial handshake with cue lsp, and
reports no errors.

Additionally (and as a bit of a drive-by), switch a couple more "gopls"
strings to "cue lsp" as these show up in some log messages.

Signed-off-by: Matthew Sackman <[email protected]>
Change-Id: I2971ecb9b124c921b4279c94ef0509d639f1d36c
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1213346
TryBot-Result: CUEcueckoo <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>
Reviewed-by: Paul Jolly <[email protected]>

Author: cuematthew

Diff for: cmd/cue/cmd/integration/workspace/workspace_folders_test.go

@@ -17,39 +17,22 @@ func TestMain(m *testing.M) {
 	Main(m, hooks.Options)
 }
 
-// TestWorkingSimpleModule ensures that we have a successful package load for a
-// simple module rooted in the workspace folder with a single CUE file at the
-// root.
-func TestWorkingSimpleModule(t *testing.T) {
-	const files = `
+// TestWorkspaceFoldersRootURI tests that the server initialization
+// works, or fails, as expected, due to various combinations of
+// WorkspaceFolders and the RootURI being set or unset.
+func TestWorkspaceFoldersRootURI(t *testing.T) {
+	const filesOneModule = `
 -- cue.mod/module.cue --
-module: "mod.example"
-language: {
-        version: "v0.11.0"
-}
--- a.cue --
+module: "mod.example/b"
+language: version: "v0.11.0"
+
+-- a/a.cue --
 package a
 -- b/b.cue --
 package c
 `
-	WithOptions().Run(t, files, func(t *testing.T, env *Env) {
-		// Simulate a change and ensure we get diagnostics back
-		env.OpenFile("a.cue")
-		env.EditBuffer("a.cue", fake.NewEdit(1, 0, 1, 0, "\nx: 5\n"))
-		got := env.BufferText("a.cue")
-		want := "package a\n\nx: 5\n"
-		qt.Assert(t, qt.Equals(got, want))
-		env.Await(env.DoneWithChange())
-	})
-}
-
-// TestMultipleWorkspaceFolders verifies the behaviour of starting 'cue lsp'
-// with multiple WorkspaceFolders. This is currently not supported, and hence
-// the test is a negative test that asserts 'cue lsp' will fail (during the
-// Initialize phase).
-func TestMultipleWorkspaceFolders(t *testing.T) {
-	const files = `
 
+	const filesTwoModules = `
 -- a/cue.mod/module.cue --
 module: "mod.example/b"
 language: version: "v0.11.0"
@@ -65,10 +48,103 @@ language: version: "v0.11.0"
 package a
 
 `
-	WithOptions(
-		WorkspaceFolders("a", "b"),
-		InitializeError("initialize: got 2 WorkspaceFolders; expected 1"),
-	).Run(t, files, nil)
+
+	type tc struct {
+		name          string
+		opts          []RunOption
+		files         string
+		expectSuccess bool
+	}
+	tests := []tc{
+		{
+			// With no workspace folders and no rooturi, the server will
+			// return an error during initialization.
+			name: "no workspace folders, no rooturi",
+			opts: []RunOption{
+				WorkspaceFolders(),
+				InitializeError("initialize: got 0 WorkspaceFolders; expected 1"),
+			},
+			files:         filesOneModule,
+			expectSuccess: false,
+		},
+		{
+			// If no workspace folders are set, but a rooturi is set, the
+			// server will treat the rooturi as if it is a workspace
+			// folder.
+			name: "no workspace folders, rooturi set",
+			opts: []RunOption{
+				WorkspaceFolders(),
+				RootURIAsDefaultFolder(),
+			},
+			files:         filesOneModule,
+			expectSuccess: true,
+		},
+		{
+			// If both workspace folders and rooturi are provided, the
+			// rooturi is ignored, and only workspace folders are used.
+			name: "workspace folders, rooturi set",
+			opts: []RunOption{
+				WorkspaceFolders("a"),
+				RootURIAsDefaultFolder(),
+			},
+			files:         filesOneModule,
+			expectSuccess: true,
+		},
+		{
+			// By default, the test framework will set one workspace
+			// folder, and will not set the rooturi.
+			name:          "default workspace folders, no rooturi",
+			files:         filesOneModule,
+			expectSuccess: true,
+		},
+		{
+			// cue lsp does not currently support multiple workspace folders.
+			name: "multiple folders, one module",
+			opts: []RunOption{
+				WorkspaceFolders("a", "b"),
+				InitializeError("initialize: got 2 WorkspaceFolders; expected 1"),
+			},
+			files:         filesOneModule,
+			expectSuccess: false,
+		},
+		{
+			// cue lsp does not currently support multiple workspace
+			// folders, even if they correctly refer to different
+			// modules.
+			name: "multiple folders, two modules",
+			opts: []RunOption{
+				WorkspaceFolders("a", "b"),
+				InitializeError("initialize: got 2 WorkspaceFolders; expected 1"),
+			},
+			files:         filesTwoModules,
+			expectSuccess: false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			hadSuccess := false
+			WithOptions(tc.opts...).Run(t, tc.files, func(t *testing.T, env *Env) {
+				hadSuccess = true
+				if tc.expectSuccess {
+					// We do a trivial edit here, which must succeed, as a
+					// means of verifying basic plumbing is working
+					// correctly.
+					env.OpenFile("a/a.cue")
+					env.EditBuffer("a/a.cue", fake.NewEdit(1, 0, 1, 0, "\nx: 5\n"))
+					got := env.BufferText("a/a.cue")
+					want := "package a\n\nx: 5\n"
+					qt.Assert(t, qt.Equals(got, want))
+					env.Await(env.DoneWithChange())
+				}
+			})
+			if tc.expectSuccess && !hadSuccess {
+				t.Fatal("Initialisation should have succeeded, but it failed")
+			} else if !tc.expectSuccess && hadSuccess {
+				t.Fatal("Initialisation should have failed, but it succeeded")
+			}
+		})
+	}
 }
 
 // TODO(myitcv): add a test that verifies we get an error in the case that a

Diff for: internal/golangorgx/gopls/cmd/serve.go

@@ -132,8 +132,8 @@ func (s *Serve) Run(ctx context.Context, args ...string) error {
 		addr = fmt.Sprintf(":%v", s.Port)
 	}
 	if addr != "" {
-		log.Printf("Gopls daemon: listening on %s network, address %s...", network, addr)
-		defer log.Printf("Gopls daemon: exiting")
+		log.Printf("cue lsp daemon: listening on %s network, address %s...", network, addr)
+		defer log.Printf("cue lsp daemon: exiting")
 		return jsonrpc2.ListenAndServe(ctx, network, addr, ss, s.IdleTimeout)
 	}
 	stream := jsonrpc2.NewHeaderStream(fakenet.NewConn("stdio", os.Stdin, os.Stdout))

Diff for: internal/golangorgx/gopls/debug/info.go

@@ -47,7 +47,7 @@ func VersionInfo() *ServerVersion {
 	return &ServerVersion{
 		Version: version.Version(),
 		BuildInfo: &debug.BuildInfo{
-			Path:      "gopls, built in GOPATH mode",
+			Path:      "cue lsp, built in GOPATH mode",
 			GoVersion: runtime.Version(),
 		},
 	}

Diff for: internal/golangorgx/gopls/server/general.go

@@ -79,14 +79,20 @@ func (s *server) Initialize(ctx context.Context, params *protocol.ParamInitializ
 	// prioritise work to support different clients etc based on bug reports.
 	//
 	// Ensure this logic is consistent with [server.DidChangeWorkspaceFolders].
-	//
-	// Note that (for now) we do not support a fallback to params.RootURI. We
-	// might do this in the future.
-	if l := len(params.WorkspaceFolders); l != 1 {
+	folders := params.WorkspaceFolders
+	if len(folders) == 0 {
+		if params.RootURI != "" {
+			folders = []protocol.WorkspaceFolder{{
+				URI:  string(params.RootURI),
+				Name: path.Base(params.RootURI.Path()),
+			}}
+		}
+	}
+
+	if l := len(folders); l != 1 {
 		return nil, fmt.Errorf("got %d WorkspaceFolders; expected 1", l)
 	}
 
-	folders := params.WorkspaceFolders
 	for _, folder := range folders {
 		if folder.URI == "" {
 			return nil, fmt.Errorf("empty WorkspaceFolder.URI")

Diff for: internal/golangorgx/gopls/test/integration/fake/editor.go

@@ -98,6 +98,10 @@ type EditorConfig struct {
 	// To explicitly send no workspace folders, use an empty (non-nil) slice.
 	WorkspaceFolders []string
 
+	// RootURIAsDefaultFolder configures the RootURI initialization
+	// parameter to be set to the default workdir root.
+	RootURIAsDefaultFolder bool
+
 	// Whether to edit files with windows line endings.
 	WindowsLineEndings bool
 
@@ -291,6 +295,9 @@ func (e *Editor) initialize(ctx context.Context) error {
 	}
 	params.InitializationOptions = makeSettings(e.sandbox, config, nil)
 	params.WorkspaceFolders = makeWorkspaceFolders(e.sandbox, config.WorkspaceFolders)
+	if config.RootURIAsDefaultFolder {
+		params.RootURI = e.sandbox.Workdir.URI(string(e.sandbox.Workdir.RelativeTo))
+	}
 
 	capabilities, err := clientCapabilities(config)
 	if err != nil {
@@ -391,7 +398,7 @@ func (e *Editor) HasCommand(id string) bool {
 // makeWorkspaceFolders creates a slice of workspace folders to use for
 // this editing session, based on the editor configuration.
 func makeWorkspaceFolders(sandbox *Sandbox, paths []string) (folders []protocol.WorkspaceFolder) {
-	if len(paths) == 0 {
+	if paths == nil {
 		paths = []string{string(sandbox.Workdir.RelativeTo)}
 	}
 

Diff for: internal/golangorgx/gopls/test/integration/options.go

@@ -117,6 +117,15 @@ func WorkspaceFolders(relFolders ...string) RunOption {
 	})
 }
 
+// RootURIAsDefaultFolder configures the RootURI initialization
+// parameter to be set to the default workdir root. This is sent to the
+// LSP server as part of initialization.
+func RootURIAsDefaultFolder() RunOption {
+	return optionSetter(func(opts *runConfig) {
+		opts.editor.RootURIAsDefaultFolder = true
+	})
+}
+
 // The InitializeError RunOption establishes the expectation that creating a
 // new fake editor (happens as part of Run) will fail with the non-empty error
 // string err.