gopls/internal/lsp/cache: clean up view workspace information

Tracking of workspace information in the View contained several
inconsistencies and redundancies. Clean this up, with the following
changes:

- eliminate the View.rootURI, opting to derive it instead
- eliminate the View.explicitGowork field, instead using the view.gowork
  field and checking if it is outside of the workspace.
- eliminate many places where directory filters were interpreted
  relative to the rootURI. This is wrong: directory filters are
  expressed relative to the workspace folder.
- remove special handling of GOMODCACHE, now that we're on Go 1.16+
- rewrite the locateTemplateFiles function to use view.filterFunc and
  filepath.WalkDir (now that we're on Go 1.16+).
- don't request goimports env vars when loading environment variables
  for the view. They weren't being propagated to goimports anyway, and
  goimports will load them as needed.

For golang/go#55331

Change-Id: I5e7f7e77e86d9ae425d2feaff31030278fed8240
Reviewed-on: https://go-review.googlesource.com/c/tools/+/459789
Reviewed-by: Alan Donovan <[email protected]>
gopls-CI: kokoro <[email protected]>
Run-TryBot: Robert Findley <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: findleyr

gopls/internal/lsp/cache/imports.go

@@ -138,7 +138,7 @@ func (s *importsState) populateProcessEnv(ctx context.Context, snapshot *snapsho
 	// and has led to memory leaks in the past, when the snapshot was
 	// unintentionally held past its lifetime.
 	_, inv, cleanupInvocation, err := snapshot.goCommandInvocation(ctx, source.LoadWorkspace, &gocommand.Invocation{
-		WorkingDir: snapshot.view.rootURI.Filename(),
+		WorkingDir: snapshot.view.workingDir().Filename(),
 	})
 	if err != nil {
 		return nil, err
@@ -175,7 +175,7 @@ func (s *importsState) populateProcessEnv(ctx context.Context, snapshot *snapsho
 			os.RemoveAll(tmpDir) // ignore error
 		}
 	} else {
-		pe.WorkingDir = snapshot.view.rootURI.Filename()
+		pe.WorkingDir = snapshot.view.workingDir().Filename()
 	}
 
 	return cleanup, nil

gopls/internal/lsp/cache/load.go

@@ -113,7 +113,7 @@ func (s *snapshot) load(ctx context.Context, allowNetwork bool, scopes ...loadSc
 		flags |= source.AllowNetwork
 	}
 	_, inv, cleanup, err := s.goCommandInvocation(ctx, flags, &gocommand.Invocation{
-		WorkingDir: s.view.rootURI.Filename(),
+		WorkingDir: s.view.workingDir().Filename(),
 	})
 	if err != nil {
 		return err
@@ -152,7 +152,7 @@ func (s *snapshot) load(ctx context.Context, allowNetwork bool, scopes ...loadSc
 	}
 
 	moduleErrs := make(map[string][]packages.Error) // module path -> errors
-	filterer := buildFilterer(s.view.rootURI.Filename(), s.view.gomodcache, s.view.Options())
+	filterFunc := s.view.filterFunc()
 	newMetadata := make(map[PackageID]*source.Metadata)
 	for _, pkg := range pkgs {
 		// The Go command returns synthetic list results for module queries that
@@ -199,7 +199,8 @@ func (s *snapshot) load(ctx context.Context, allowNetwork bool, scopes ...loadSc
 		//
 		// TODO(rfindley): why exclude metadata arbitrarily here? It should be safe
 		// to capture all metadata.
-		if s.view.allFilesExcluded(pkg, filterer) {
+		// TODO(rfindley): what about compiled go files?
+		if allFilesExcluded(pkg.GoFiles, filterFunc) {
 			continue
 		}
 		if err := buildMetadata(ctx, pkg, cfg, query, newMetadata, nil); err != nil {

gopls/internal/lsp/cache/session.go

@@ -7,7 +7,6 @@ package cache
 import (
 	"context"
 	"fmt"
-	"os"
 	"strconv"
 	"strings"
 	"sync"
@@ -180,6 +179,8 @@ func (s *Session) NewView(ctx context.Context, name string, folder span.URI, opt
 	return view, snapshot, release, nil
 }
 
+// TODO(rfindley): clarify that createView can never be cancelled (with the
+// possible exception of server shutdown).
 func (s *Session) createView(ctx context.Context, name string, folder span.URI, options *source.Options, seqID uint64) (*View, *snapshot, func(), error) {
 	index := atomic.AddInt64(&viewIndex, 1)
 
@@ -188,15 +189,15 @@ func (s *Session) createView(ctx context.Context, name string, folder span.URI,
 	// TODO(rfindley): this info isn't actually immutable. For example, GOWORK
 	// could be changed, or a user's environment could be modified.
 	// We need a mechanism to invalidate it.
-	wsInfo, err := s.getWorkspaceInformation(ctx, folder, options)
+	info, err := s.getWorkspaceInformation(ctx, folder, options)
 	if err != nil {
 		return nil, nil, func() {}, err
 	}
 
 	root := folder
 	// filterFunc is the path filter function for this workspace folder. Notably,
 	// it is relative to folder (which is specified by the user), not root.
-	filterFunc := pathExcludedByFilterFunc(folder.Filename(), wsInfo.gomodcache, options)
+	filterFunc := pathExcludedByFilterFunc(folder.Filename(), info.gomodcache, options)
 	rootSrc, err := findWorkspaceModuleSource(ctx, root, s, filterFunc, options.ExperimentalWorkspaceModule)
 	if err != nil {
 		return nil, nil, func() {}, err
@@ -205,14 +206,8 @@ func (s *Session) createView(ctx context.Context, name string, folder span.URI,
 		root = span.Dir(rootSrc)
 	}
 
-	explicitGowork := os.Getenv("GOWORK")
-	if v, ok := options.Env["GOWORK"]; ok {
-		explicitGowork = v
-	}
-	goworkURI := span.URIFromPath(explicitGowork)
-
 	// Build the gopls workspace, collecting active modules in the view.
-	workspace, err := newWorkspace(ctx, root, goworkURI, s, filterFunc, wsInfo.effectiveGO111MODULE() == off, options.ExperimentalWorkspaceModule)
+	workspace, err := newWorkspace(ctx, root, info.effectiveGOWORK(), s, filterFunc, info.effectiveGO111MODULE() == off, options.ExperimentalWorkspaceModule)
 	if err != nil {
 		return nil, nil, func() {}, err
 	}
@@ -236,10 +231,8 @@ func (s *Session) createView(ctx context.Context, name string, folder span.URI,
 		vulns:                map[span.URI]*govulncheck.Result{},
 		filesByURI:           make(map[span.URI]span.URI),
 		filesByBase:          make(map[string][]canonicalURI),
-		rootURI:              root,
 		rootSrc:              rootSrc,
-		explicitGowork:       goworkURI,
-		workspaceInformation: *wsInfo,
+		workspaceInformation: info,
 	}
 	v.importsState = &importsState{
 		ctx: backgroundCtx,
@@ -506,11 +499,12 @@ func (s *Session) DidModifyFiles(ctx context.Context, changes []source.FileModif
 	// Re-create views whose root may have changed.
 	//
 	// checkRoots controls whether to re-evaluate view definitions when
-	// collecting views below. Any change to a go.mod or go.work file may have
-	// affected the definition of the view.
+	// collecting views below. Any addition or deletion of a go.mod or go.work
+	// file may have affected the definition of the view.
 	checkRoots := false
 	for _, c := range changes {
 		if isGoMod(c.URI) || isGoWork(c.URI) {
+			// TODO(rfindley): only consider additions or deletions here.
 			checkRoots = true
 			break
 		}

gopls/internal/lsp/cache/snapshot.go

@@ -302,7 +302,7 @@ func (s *snapshot) ValidBuildConfiguration() bool {
 	// Check if the workspace is within any of them.
 	// TODO(rfindley): this should probably be subject to "if GO111MODULES = off {...}".
 	for _, gp := range filepath.SplitList(s.view.gopath) {
-		if source.InDir(filepath.Join(gp, "src"), s.view.rootURI.Filename()) {
+		if source.InDir(filepath.Join(gp, "src"), s.view.folder.Filename()) {
 			return true
 		}
 	}
@@ -820,8 +820,10 @@ func (s *snapshot) fileWatchingGlobPatterns(ctx context.Context) map[string]stru
 		fmt.Sprintf("**/*.{%s}", extensions): {},
 	}
 
-	if s.view.explicitGowork != "" {
-		patterns[s.view.explicitGowork.Filename()] = struct{}{}
+	// If GOWORK is outside the folder, ensure we are watching it.
+	gowork := s.view.effectiveGOWORK()
+	if gowork != "" && !source.InDir(s.view.folder.Filename(), gowork.Filename()) {
+		patterns[gowork.Filename()] = struct{}{}
 	}
 
 	// Add a pattern for each Go module in the workspace that is not within the view.
@@ -2178,7 +2180,7 @@ func (s *snapshot) setBuiltin(path string) {
 // BuildGoplsMod generates a go.mod file for all modules in the workspace. It
 // bypasses any existing gopls.mod.
 func (s *snapshot) BuildGoplsMod(ctx context.Context) (*modfile.File, error) {
-	allModules, err := findModules(s.view.folder, pathExcludedByFilterFunc(s.view.rootURI.Filename(), s.view.gomodcache, s.View().Options()), 0)
+	allModules, err := findModules(s.view.folder, pathExcludedByFilterFunc(s.view.folder.Filename(), s.view.gomodcache, s.View().Options()), 0)
 	if err != nil {
 		return nil, err
 	}