internal/lsp: nest the workspace root if there is only one module

If the user opens a parent directory of a single module, we can load
their workspace without using some of the workarounds of experimental
workspace mode, simply by narrowing the workspace to this nested
subdirectory.

Do this by extending findAllModules to support a limit on the number of
modules and files to search.

Updates golang/go#41558
Fixes golang/go#42108

Change-Id: Idba800a0deaeee5137d46f16a30b2012ff902a36
Reviewed-on: https://go-review.googlesource.com/c/tools/+/268877
Run-TryBot: Robert Findley <rfindley@google.com>
gopls-CI: kokoro <noreply+kokoro@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Rebecca Stambler <rstambler@golang.org>
Reviewed-by: Heschi Kreinick <heschi@google.com>
Trust: Robert Findley <rfindley@google.com>

Author: findleyr

gopls/doc/settings.md

@@ -249,9 +249,12 @@ semantic tokens to the client.
 
 Default: `false`.
 ### **expandWorkspaceToModule** *bool*
-expandWorkspaceToModule instructs `gopls` to expand the scope of the workspace to include the
-modules containing the workspace folders. Set this to false to avoid loading
-your entire module. This is particularly useful for those working in a monorepo.
+expandWorkspaceToModule instructs `gopls` to adjust the scope of the
+workspace to find the best available module root. `gopls` first looks for
+a go.mod file in any parent directory of the workspace folder, expanding
+the scope to that directory if it exists. If no viable parent directory is
+found, gopls will check if there is exactly one child directory containing
+a go.mod file, narrowing the scope to that directory if it exists.
 
 
 Default: `true`.

gopls/internal/regtest/modfile_test.go

@@ -38,7 +38,7 @@ func runModfileTest(t *testing.T, files, proxy string, f TestFunc) {
 		withOptions(WithProxyFiles(proxy)).run(t, files, f)
 	})
 	t.Run("nested", func(t *testing.T) {
-		withOptions(WithProxyFiles(proxy), NestWorkdir(), WithModes(Experimental)).run(t, files, f)
+		withOptions(WithProxyFiles(proxy), NestWorkdir(), WithModes(Singleton|Experimental)).run(t, files, f)
 	})
 }
 

internal/lsp/cache/session.go

@@ -173,9 +173,16 @@ func (s *Session) createView(ctx context.Context, name string, folder, tempWorks
 	if err != nil {
 		return nil, nil, func() {}, err
 	}
+	root := folder
+	if options.ExpandWorkspaceToModule {
+		root, err = findWorkspaceRoot(ctx, root, s, options.ExperimentalWorkspaceModule)
+		if err != nil {
+			return nil, nil, func() {}, err
+		}
+	}
 
 	// Build the gopls workspace, collecting active modules in the view.
-	workspace, err := newWorkspace(ctx, ws.rootURI, s, options.ExperimentalWorkspaceModule)
+	workspace, err := newWorkspace(ctx, root, s, options.ExperimentalWorkspaceModule)
 	if err != nil {
 		return nil, nil, func() {}, err
 	}
@@ -198,6 +205,7 @@ func (s *Session) createView(ctx context.Context, name string, folder, tempWorks
 		folder:               folder,
 		filesByURI:           make(map[span.URI]*fileBase),
 		filesByBase:          make(map[string][]*fileBase),
+		rootURI:              root,
 		workspaceInformation: *ws,
 		tempWorkspace:        tempWorkspace,
 	}

internal/lsp/cache/snapshot.go

@@ -1561,7 +1561,7 @@ func (s *snapshot) buildBuiltinPackage(ctx context.Context, goFiles []string) er
 // BuildGoplsMod generates a go.mod file for all modules in the workspace. It
 // bypasses any existing gopls.mod.
 func BuildGoplsMod(ctx context.Context, root span.URI, fs source.FileSource) (*modfile.File, error) {
-	allModules, err := findAllModules(ctx, root)
+	allModules, err := findModules(ctx, root, 0, 0)
 	if err != nil {
 		return nil, err
 	}

internal/lsp/cache/view.go

@@ -85,6 +85,10 @@ type View struct {
 	// context is canceled.
 	initializationSema chan struct{}
 
+	// rootURI is the rootURI directory of this view. If we are in GOPATH mode, this
+	// is just the folder. If we are in module mode, this is the module rootURI.
+	rootURI span.URI
+
 	// workspaceInformation tracks various details about this view's
 	// environment variables, go version, and use of modules.
 	workspaceInformation
@@ -112,10 +116,6 @@ type workspaceInformation struct {
 	// goEnv is the `go env` output collected when a view is created.
 	// It includes the values of the environment variables above.
 	goEnv map[string]string
-
-	// rootURI is the rootURI directory of this view. If we are in GOPATH mode, this
-	// is just the folder. If we are in module mode, this is the module rootURI.
-	rootURI span.URI
 }
 
 type environmentVariables struct {
@@ -316,7 +316,7 @@ func (s *snapshot) RunProcessEnvFunc(ctx context.Context, fn func(*imports.Optio
 }
 
 func (v *View) contains(uri span.URI) bool {
-	return strings.HasPrefix(string(uri), string(v.rootURI))
+	return source.InDir(v.rootURI.Filename(), uri.Filename()) || source.InDir(v.folder.Filename(), uri.Filename())
 }
 
 func (v *View) mapFile(uri span.URI, f *fileBase) {
@@ -673,28 +673,31 @@ func (s *Session) getWorkspaceInformation(ctx context.Context, folder span.URI,
 	tool, _ := exec.LookPath("gopackagesdriver")
 	hasGopackagesDriver := gopackagesdriver != "off" && (gopackagesdriver != "" || tool != "")
 
-	root := folder
-	if options.ExpandWorkspaceToModule {
-		wsRoot, err := findWorkspaceRoot(ctx, root, s)
-		if err != nil {
-			return nil, err
-		}
-		if wsRoot != "" {
-			root = wsRoot
-		}
-	}
 	return &workspaceInformation{
 		hasGopackagesDriver:  hasGopackagesDriver,
 		go111module:          go111module,
 		goversion:            goversion,
-		rootURI:              root,
 		environmentVariables: envVars,
 		goEnv:                env,
 	}, nil
 }
 
-func findWorkspaceRoot(ctx context.Context, folder span.URI, fs source.FileSource) (span.URI, error) {
-	for _, basename := range []string{"gopls.mod", "go.mod"} {
+// findWorkspaceRoot searches for the best workspace root according to the
+// following heuristics:
+//   - First, look for a parent directory containing a gopls.mod file
+//     (experimental only).
+//   - Then, a parent directory containing a go.mod file.
+//   - Then, a child directory containing a go.mod file, if there is exactly
+//     one (non-experimental only).
+// Otherwise, it returns folder.
+// TODO (rFindley): move this to workspace.go
+// TODO (rFindley): simplify this once workspace modules are enabled by default.
+func findWorkspaceRoot(ctx context.Context, folder span.URI, fs source.FileSource, experimental bool) (span.URI, error) {
+	patterns := []string{"go.mod"}
+	if experimental {
+		patterns = []string{"gopls.mod", "go.mod"}
+	}
+	for _, basename := range patterns {
 		dir, err := findRootPattern(ctx, folder, basename, fs)
 		if err != nil {
 			return "", errors.Errorf("finding %s: %w", basename, err)
@@ -703,7 +706,31 @@ func findWorkspaceRoot(ctx context.Context, folder span.URI, fs source.FileSourc
 			return dir, nil
 		}
 	}
-	return "", nil
+
+	// The experimental workspace can handle nested modules at this point...
+	if experimental {
+		return folder, nil
+	}
+
+	// ...else we should check if there's exactly one nested module.
+	const filesToSearch = 10000
+	all, err := findModules(ctx, folder, 2, filesToSearch)
+	if err == errExhausted {
+		// Fall-back behavior: if we don't find any modules after searching 10000
+		// files, assume there are none.
+		event.Log(ctx, fmt.Sprintf("stopped searching for modules after %d files", filesToSearch))
+		return folder, nil
+	}
+	if err != nil {
+		return "", err
+	}
+	if len(all) == 1 {
+		// range to access first element.
+		for uri := range all {
+			return dirURI(uri), nil
+		}
+	}
+	return folder, nil
 }
 
 func findRootPattern(ctx context.Context, folder span.URI, basename string, fs source.FileSource) (span.URI, error) {

internal/lsp/cache/view_test.go

@@ -60,8 +60,10 @@ module b
 module bc
 -- d/gopls.mod --
 module d-goplsworkspace
--- d/e/go.mod
+-- d/e/go.mod --
 module de
+-- f/g/go.mod --
+module fg
 `
 	dir, err := fake.Tempdir(workspace)
 	if err != nil {
@@ -71,26 +73,30 @@ module de
 
 	tests := []struct {
 		folder, want string
+		experimental bool
 	}{
-		// no module at root.
-		{"", ""},
-		{"a", "a"},
-		{"a/x", "a"},
-		{"b/c", "b/c"},
-		{"d", "d"},
-		{"d/e", "d"},
+		{"", "", false}, // no module at root, and more than one nested module
+		{"a", "a", false},
+		{"a/x", "a", false},
+		{"b/c", "b/c", false},
+		{"d", "d/e", false},
+		{"d", "d", true},
+		{"d/e", "d/e", false},
+		{"d/e", "d", true},
+		{"f", "f/g", false},
+		{"f", "f", true},
 	}
 
 	for _, test := range tests {
 		ctx := context.Background()
 		rel := fake.RelativeTo(dir)
 		folderURI := span.URIFromPath(rel.AbsPath(test.folder))
-		got, err := findWorkspaceRoot(ctx, folderURI, osFileSource{})
+		got, err := findWorkspaceRoot(ctx, folderURI, osFileSource{}, test.experimental)
 		if err != nil {
 			t.Fatal(err)
 		}
-		if rel.RelPath(got.Filename()) != test.want {
-			t.Errorf("fileWorkspaceRoot(%q) = %q, want %q", test.folder, got, test.want)
+		if gotf, wantf := filepath.Clean(got.Filename()), rel.AbsPath(test.want); gotf != wantf {
+			t.Errorf("findWorkspaceRoot(%q, %t) = %q, want %q", test.folder, test.experimental, gotf, wantf)
 		}
 	}
 }

internal/lsp/cache/workspace.go

@@ -101,7 +101,7 @@ func newWorkspace(ctx context.Context, root span.URI, fs source.FileSource, expe
 			moduleSource: goplsModWorkspace,
 		}, nil
 	}
-	modFiles, err := findAllModules(ctx, root)
+	modFiles, err := findModules(ctx, root, 0, 0)
 	if err != nil {
 		return nil, err
 	}
@@ -234,7 +234,7 @@ func (wm *workspace) invalidate(ctx context.Context, changes map[span.URI]*fileC
 			} else {
 				// gopls.mod is deleted. search for modules again.
 				moduleSource = fileSystemWorkspace
-				modFiles, err = findAllModules(ctx, wm.root)
+				modFiles, err = findModules(ctx, wm.root, 0, 0)
 				// the modFile is no longer valid.
 				if err != nil {
 					event.Error(ctx, "finding file system modules", err)
@@ -372,13 +372,21 @@ func parseGoplsMod(root, uri span.URI, contents []byte) (*modfile.File, map[span
 	return modFile, modFiles, nil
 }
 
-// findAllModules recursively walks the root directory looking for go.mod
-// files, returning the set of modules it discovers.
+// errExhausted is returned by findModules if the file scan limit is reached.
+var errExhausted = errors.New("exhausted")
+
+// findModules recursively walks the root directory looking for go.mod files,
+// returning the set of modules it discovers. If modLimit is non-zero,
+// searching stops once modLimit modules have been found. If fileLimit is
+// non-zero, searching stops once fileLimit files have been checked.
 // TODO(rfindley): consider overlays.
-func findAllModules(ctx context.Context, root span.URI) (map[span.URI]struct{}, error) {
+func findModules(ctx context.Context, root span.URI, modLimit, fileLimit int) (map[span.URI]struct{}, error) {
 	// Walk the view's folder to find all modules in the view.
 	modFiles := make(map[span.URI]struct{})
-	return modFiles, filepath.Walk(root.Filename(), func(path string, info os.FileInfo, err error) error {
+	searched := 0
+
+	errDone := errors.New("done")
+	err := filepath.Walk(root.Filename(), func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			// Probably a permission error. Keep looking.
 			return filepath.SkipDir
@@ -399,6 +407,17 @@ func findAllModules(ctx context.Context, root span.URI) (map[span.URI]struct{},
 		if isGoMod(uri) {
 			modFiles[uri] = struct{}{}
 		}
+		if modLimit > 0 && len(modFiles) >= modLimit {
+			return errDone
+		}
+		searched++
+		if fileLimit > 0 && searched >= fileLimit {
+			return errExhausted
+		}
 		return nil
 	})
+	if err == errDone {
+		return modFiles, nil
+	}
+	return modFiles, err
 }