| // Copyright 2018 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Package cache implements the caching layer for gopls. |
| package cache |
| |
| import ( |
| "context" |
| "encoding/json" |
| "fmt" |
| "io" |
| "io/ioutil" |
| "os" |
| "path" |
| "path/filepath" |
| "reflect" |
| "regexp" |
| "sort" |
| "strings" |
| "sync" |
| |
| "golang.org/x/mod/modfile" |
| "golang.org/x/mod/semver" |
| exec "golang.org/x/sys/execabs" |
| "golang.org/x/tools/go/packages" |
| "golang.org/x/tools/internal/event" |
| "golang.org/x/tools/internal/gocommand" |
| "golang.org/x/tools/internal/imports" |
| "golang.org/x/tools/internal/lsp/bug" |
| "golang.org/x/tools/internal/lsp/protocol" |
| "golang.org/x/tools/internal/lsp/source" |
| "golang.org/x/tools/internal/span" |
| "golang.org/x/tools/internal/xcontext" |
| ) |
| |
| type View struct { |
| session *Session |
| id string |
| |
| optionsMu sync.Mutex |
| options *source.Options |
| |
| // mu protects most mutable state of the view. |
| mu sync.Mutex |
| |
| // baseCtx is the context handed to NewView. This is the parent of all |
| // background contexts created for this view. |
| baseCtx context.Context |
| |
| // name is the user visible name of this view. |
| name string |
| |
| // folder is the folder with which this view was constructed. |
| folder span.URI |
| |
| importsState *importsState |
| |
| // moduleUpgrades tracks known upgrades for module paths. |
| moduleUpgrades map[string]string |
| |
| // keep track of files by uri and by basename, a single file may be mapped |
| // to multiple uris, and the same basename may map to multiple files |
| filesByURI map[span.URI]*fileBase |
| filesByBase map[string][]*fileBase |
| |
| // initCancelFirstAttempt can be used to terminate the view's first |
| // attempt at initialization. |
| initCancelFirstAttempt context.CancelFunc |
| |
| // Track the latest snapshot via the snapshot field, guarded by snapshotMu. |
| // |
| // Invariant: whenever the snapshot field is overwritten, destroy(snapshot) |
| // is called on the previous (overwritten) snapshot while snapshotMu is held, |
| // incrementing snapshotWG. During shutdown the final snapshot is |
| // overwritten with nil and destroyed, guaranteeing that all observed |
| // snapshots have been destroyed via the destroy method, and snapshotWG may |
| // be waited upon to let these destroy operations complete. |
| snapshotMu sync.Mutex |
| snapshot *snapshot // latest snapshot; nil after shutdown has been called |
| releaseSnapshot func() // called when snapshot is no longer needed |
| snapshotWG sync.WaitGroup // refcount for pending destroy operations |
| |
| // initialWorkspaceLoad is closed when the first workspace initialization has |
| // completed. If we failed to load, we only retry if the go.mod file changes, |
| // to avoid too many go/packages calls. |
| initialWorkspaceLoad chan struct{} |
| |
| // initializationSema is used limit concurrent initialization of snapshots in |
| // the view. We use a channel instead of a mutex to avoid blocking when a |
| // context is canceled. |
| // |
| // This field (along with snapshot.initialized) guards against duplicate |
| // initialization of snapshots. Do not change it without adjusting snapshot |
| // accordingly. |
| 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 |
| |
| // explicitGowork is, if non-empty, the URI for the explicit go.work file |
| // provided via the users environment. |
| // |
| // TODO(rfindley): this is duplicated in the workspace type. Refactor to |
| // eliminate this duplication. |
| explicitGowork span.URI |
| |
| // workspaceInformation tracks various details about this view's |
| // environment variables, go version, and use of modules. |
| workspaceInformation |
| } |
| |
| type workspaceInformation struct { |
| // The Go version in use: X in Go 1.X. |
| goversion int |
| |
| // hasGopackagesDriver is true if the user has a value set for the |
| // GOPACKAGESDRIVER environment variable or a gopackagesdriver binary on |
| // their machine. |
| hasGopackagesDriver bool |
| |
| // `go env` variables that need to be tracked by gopls. |
| environmentVariables |
| |
| // userGo111Module is the user's value of GO111MODULE. |
| // |
| // TODO(rfindley): is there really value in memoizing this variable? It seems |
| // simpler to make this a function/method. |
| userGo111Module go111module |
| |
| // The value of GO111MODULE we want to run with. |
| effectiveGo111Module string |
| |
| // 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 |
| } |
| |
| type go111module int |
| |
| const ( |
| off = go111module(iota) |
| auto |
| on |
| ) |
| |
| type environmentVariables struct { |
| gocache, gopath, goroot, goprivate, gomodcache, go111module string |
| } |
| |
| // workspaceMode holds various flags defining how the gopls workspace should |
| // behave. They may be derived from the environment, user configuration, or |
| // depend on the Go version. |
| // |
| // TODO(rfindley): remove workspace mode, in favor of explicit checks. |
| type workspaceMode int |
| |
| const ( |
| moduleMode workspaceMode = 1 << iota |
| |
| // tempModfile indicates whether or not the -modfile flag should be used. |
| tempModfile |
| ) |
| |
| // fileBase holds the common functionality for all files. |
| // It is intended to be embedded in the file implementations |
| type fileBase struct { |
| uris []span.URI |
| fname string |
| |
| view *View |
| } |
| |
| func (f *fileBase) URI() span.URI { |
| return f.uris[0] |
| } |
| |
| func (f *fileBase) filename() string { |
| return f.fname |
| } |
| |
| func (f *fileBase) addURI(uri span.URI) int { |
| f.uris = append(f.uris, uri) |
| return len(f.uris) |
| } |
| |
| func (v *View) ID() string { return v.id } |
| |
| // tempModFile creates a temporary go.mod file based on the contents |
| // of the given go.mod file. On success, it is the caller's |
| // responsibility to call the cleanup function when the file is no |
| // longer needed. |
| func tempModFile(modFh source.FileHandle, gosum []byte) (tmpURI span.URI, cleanup func(), err error) { |
| filenameHash := source.Hashf("%s", modFh.URI().Filename()) |
| tmpMod, err := ioutil.TempFile("", fmt.Sprintf("go.%s.*.mod", filenameHash)) |
| if err != nil { |
| return "", nil, err |
| } |
| defer tmpMod.Close() |
| |
| tmpURI = span.URIFromPath(tmpMod.Name()) |
| tmpSumName := sumFilename(tmpURI) |
| |
| content, err := modFh.Read() |
| if err != nil { |
| return "", nil, err |
| } |
| |
| if _, err := tmpMod.Write(content); err != nil { |
| return "", nil, err |
| } |
| |
| // We use a distinct name here to avoid subtlety around the fact |
| // that both 'return' and 'defer' update the "cleanup" variable. |
| doCleanup := func() { |
| _ = os.Remove(tmpSumName) |
| _ = os.Remove(tmpURI.Filename()) |
| } |
| |
| // Be careful to clean up if we return an error from this function. |
| defer func() { |
| if err != nil { |
| doCleanup() |
| cleanup = nil |
| } |
| }() |
| |
| // Create an analogous go.sum, if one exists. |
| if gosum != nil { |
| if err := ioutil.WriteFile(tmpSumName, gosum, 0655); err != nil { |
| return "", nil, err |
| } |
| } |
| |
| return tmpURI, doCleanup, nil |
| } |
| |
| // Name returns the user visible name of this view. |
| func (v *View) Name() string { |
| return v.name |
| } |
| |
| // Folder returns the folder at the base of this view. |
| func (v *View) Folder() span.URI { |
| return v.folder |
| } |
| |
| func (v *View) Options() *source.Options { |
| v.optionsMu.Lock() |
| defer v.optionsMu.Unlock() |
| return v.options |
| } |
| |
| func (v *View) FileKind(fh source.FileHandle) source.FileKind { |
| if o, ok := fh.(source.Overlay); ok { |
| if o.Kind() != source.UnknownKind { |
| return o.Kind() |
| } |
| } |
| fext := filepath.Ext(fh.URI().Filename()) |
| switch fext { |
| case ".go": |
| return source.Go |
| case ".mod": |
| return source.Mod |
| case ".sum": |
| return source.Sum |
| case ".work": |
| return source.Work |
| } |
| exts := v.Options().TemplateExtensions |
| for _, ext := range exts { |
| if fext == ext || fext == "."+ext { |
| return source.Tmpl |
| } |
| } |
| // and now what? This should never happen, but it does for cgo before go1.15 |
| return source.Go |
| } |
| |
| func minorOptionsChange(a, b *source.Options) bool { |
| // Check if any of the settings that modify our understanding of files have been changed |
| if !reflect.DeepEqual(a.Env, b.Env) { |
| return false |
| } |
| if !reflect.DeepEqual(a.DirectoryFilters, b.DirectoryFilters) { |
| return false |
| } |
| if a.MemoryMode != b.MemoryMode { |
| return false |
| } |
| aBuildFlags := make([]string, len(a.BuildFlags)) |
| bBuildFlags := make([]string, len(b.BuildFlags)) |
| copy(aBuildFlags, a.BuildFlags) |
| copy(bBuildFlags, b.BuildFlags) |
| sort.Strings(aBuildFlags) |
| sort.Strings(bBuildFlags) |
| // the rest of the options are benign |
| return reflect.DeepEqual(aBuildFlags, bBuildFlags) |
| } |
| |
| func (v *View) SetOptions(ctx context.Context, options *source.Options) (source.View, error) { |
| // no need to rebuild the view if the options were not materially changed |
| v.optionsMu.Lock() |
| if minorOptionsChange(v.options, options) { |
| v.options = options |
| v.optionsMu.Unlock() |
| return v, nil |
| } |
| v.optionsMu.Unlock() |
| newView, err := v.session.updateView(ctx, v, options) |
| return newView, err |
| } |
| |
| func (v *View) Rebuild(ctx context.Context) (source.Snapshot, func(), error) { |
| newView, err := v.session.updateView(ctx, v, v.Options()) |
| if err != nil { |
| return nil, func() {}, err |
| } |
| snapshot, release := newView.Snapshot(ctx) |
| return snapshot, release, nil |
| } |
| |
| func (s *snapshot) WriteEnv(ctx context.Context, w io.Writer) error { |
| s.view.optionsMu.Lock() |
| env := s.view.options.EnvSlice() |
| buildFlags := append([]string{}, s.view.options.BuildFlags...) |
| s.view.optionsMu.Unlock() |
| |
| fullEnv := make(map[string]string) |
| for k, v := range s.view.goEnv { |
| fullEnv[k] = v |
| } |
| for _, v := range env { |
| s := strings.SplitN(v, "=", 2) |
| if len(s) != 2 { |
| continue |
| } |
| if _, ok := fullEnv[s[0]]; ok { |
| fullEnv[s[0]] = s[1] |
| } |
| } |
| goVersion, err := s.view.session.gocmdRunner.Run(ctx, gocommand.Invocation{ |
| Verb: "version", |
| Env: env, |
| WorkingDir: s.view.rootURI.Filename(), |
| }) |
| if err != nil { |
| return err |
| } |
| fmt.Fprintf(w, `go env for %v |
| (root %s) |
| (go version %s) |
| (valid build configuration = %v) |
| (build flags: %v) |
| `, |
| s.view.folder.Filename(), |
| s.view.rootURI.Filename(), |
| strings.TrimRight(goVersion.String(), "\n"), |
| s.ValidBuildConfiguration(), |
| buildFlags) |
| for k, v := range fullEnv { |
| fmt.Fprintf(w, "%s=%s\n", k, v) |
| } |
| return nil |
| } |
| |
| func (s *snapshot) RunProcessEnvFunc(ctx context.Context, fn func(*imports.Options) error) error { |
| return s.view.importsState.runProcessEnvFunc(ctx, s, fn) |
| } |
| |
| // separated out from its sole use in locateTemplateFiles for testability |
| func fileHasExtension(path string, suffixes []string) bool { |
| ext := filepath.Ext(path) |
| if ext != "" && ext[0] == '.' { |
| ext = ext[1:] |
| } |
| for _, s := range suffixes { |
| if s != "" && ext == s { |
| return true |
| } |
| } |
| return false |
| } |
| |
| func (s *snapshot) locateTemplateFiles(ctx context.Context) { |
| if len(s.view.Options().TemplateExtensions) == 0 { |
| return |
| } |
| suffixes := s.view.Options().TemplateExtensions |
| |
| // The workspace root may have been expanded to a module, but we should apply |
| // directory filters based on the configured workspace folder. |
| // |
| // TODO(rfindley): we should be more principled about paths outside of the |
| // workspace folder: do we even consider them? Do we support absolute |
| // exclusions? Relative exclusions starting with ..? |
| dir := s.workspace.root.Filename() |
| relativeTo := s.view.folder.Filename() |
| |
| searched := 0 |
| filterer := buildFilterer(dir, s.view.gomodcache, s.view.Options()) |
| // Change to WalkDir when we move up to 1.16 |
| err := filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error { |
| if err != nil { |
| return err |
| } |
| relpath := strings.TrimPrefix(path, relativeTo) |
| excluded := pathExcludedByFilter(relpath, filterer) |
| if fileHasExtension(path, suffixes) && !excluded && !fi.IsDir() { |
| k := span.URIFromPath(path) |
| _, err := s.GetVersionedFile(ctx, k) |
| if err != nil { |
| return nil |
| } |
| } |
| searched++ |
| if fileLimit > 0 && searched > fileLimit { |
| return errExhausted |
| } |
| return nil |
| }) |
| if err != nil { |
| event.Error(ctx, "searching for template files failed", err) |
| } |
| } |
| |
| func (v *View) contains(uri span.URI) bool { |
| // TODO(rfindley): should we ignore the root here? It is not provided by the |
| // user, and is undefined when go.work is outside the workspace. It would be |
| // better to explicitly consider the set of active modules wherever relevant. |
| inRoot := source.InDir(v.rootURI.Filename(), uri.Filename()) |
| inFolder := source.InDir(v.folder.Filename(), uri.Filename()) |
| |
| if !inRoot && !inFolder { |
| return false |
| } |
| |
| return !v.filterFunc()(uri) |
| } |
| |
| // filterFunc returns a func that reports whether uri is filtered by the currently configured |
| // directoryFilters. |
| func (v *View) filterFunc() func(span.URI) bool { |
| filterer := buildFilterer(v.rootURI.Filename(), v.gomodcache, v.Options()) |
| return func(uri span.URI) bool { |
| // Only filter relative to the configured root directory. |
| if source.InDirLex(v.folder.Filename(), uri.Filename()) { |
| return pathExcludedByFilter(strings.TrimPrefix(uri.Filename(), v.folder.Filename()), filterer) |
| } |
| return false |
| } |
| } |
| |
| func (v *View) mapFile(uri span.URI, f *fileBase) { |
| v.filesByURI[uri] = f |
| if f.addURI(uri) == 1 { |
| basename := basename(f.filename()) |
| v.filesByBase[basename] = append(v.filesByBase[basename], f) |
| } |
| } |
| |
| func basename(filename string) string { |
| return strings.ToLower(filepath.Base(filename)) |
| } |
| |
| func (v *View) relevantChange(c source.FileModification) bool { |
| // If the file is known to the view, the change is relevant. |
| if v.knownFile(c.URI) { |
| return true |
| } |
| // The go.work/gopls.mod may not be "known" because we first access it |
| // through the session. As a result, treat changes to the view's go.work or |
| // gopls.mod file as always relevant, even if they are only on-disk |
| // changes. |
| // TODO(rstambler): Make sure the go.work/gopls.mod files are always known |
| // to the view. |
| for _, src := range []workspaceSource{goWorkWorkspace, goplsModWorkspace} { |
| if c.URI == uriForSource(v.rootURI, v.explicitGowork, src) { |
| return true |
| } |
| } |
| // If the file is not known to the view, and the change is only on-disk, |
| // we should not invalidate the snapshot. This is necessary because Emacs |
| // sends didChangeWatchedFiles events for temp files. |
| if c.OnDisk && (c.Action == source.Change || c.Action == source.Delete) { |
| return false |
| } |
| return v.contains(c.URI) |
| } |
| |
| func (v *View) knownFile(uri span.URI) bool { |
| v.mu.Lock() |
| defer v.mu.Unlock() |
| |
| f, err := v.findFile(uri) |
| return f != nil && err == nil |
| } |
| |
| // getFile returns a file for the given URI. |
| func (v *View) getFile(uri span.URI) *fileBase { |
| v.mu.Lock() |
| defer v.mu.Unlock() |
| |
| f, _ := v.findFile(uri) |
| if f != nil { |
| return f |
| } |
| f = &fileBase{ |
| view: v, |
| fname: uri.Filename(), |
| } |
| v.mapFile(uri, f) |
| return f |
| } |
| |
| // findFile checks the cache for any file matching the given uri. |
| // |
| // An error is only returned for an irreparable failure, for example, if the |
| // filename in question does not exist. |
| func (v *View) findFile(uri span.URI) (*fileBase, error) { |
| if f := v.filesByURI[uri]; f != nil { |
| // a perfect match |
| return f, nil |
| } |
| // no exact match stored, time to do some real work |
| // check for any files with the same basename |
| fname := uri.Filename() |
| basename := basename(fname) |
| if candidates := v.filesByBase[basename]; candidates != nil { |
| pathStat, err := os.Stat(fname) |
| if os.IsNotExist(err) { |
| return nil, err |
| } |
| if err != nil { |
| return nil, nil // the file may exist, return without an error |
| } |
| for _, c := range candidates { |
| if cStat, err := os.Stat(c.filename()); err == nil { |
| if os.SameFile(pathStat, cStat) { |
| // same file, map it |
| v.mapFile(uri, c) |
| return c, nil |
| } |
| } |
| } |
| } |
| // no file with a matching name was found, it wasn't in our cache |
| return nil, nil |
| } |
| |
| func (v *View) Shutdown(ctx context.Context) { |
| v.session.removeView(ctx, v) |
| } |
| |
| // shutdown releases resources associated with the view, and waits for ongoing |
| // work to complete. |
| // |
| // TODO(rFindley): probably some of this should also be one in View.Shutdown |
| // above? |
| func (v *View) shutdown(ctx context.Context) { |
| // Cancel the initial workspace load if it is still running. |
| v.initCancelFirstAttempt() |
| |
| v.snapshotMu.Lock() |
| if v.snapshot != nil { |
| v.releaseSnapshot() |
| v.destroy(v.snapshot, "View.shutdown") |
| v.snapshot = nil |
| v.releaseSnapshot = nil |
| } |
| v.snapshotMu.Unlock() |
| |
| v.importsState.destroy() |
| v.snapshotWG.Wait() |
| } |
| |
| func (v *View) Session() *Session { |
| return v.session |
| } |
| |
| func (s *snapshot) IgnoredFile(uri span.URI) bool { |
| filename := uri.Filename() |
| var prefixes []string |
| if len(s.workspace.getActiveModFiles()) == 0 { |
| for _, entry := range filepath.SplitList(s.view.gopath) { |
| prefixes = append(prefixes, filepath.Join(entry, "src")) |
| } |
| } else { |
| prefixes = append(prefixes, s.view.gomodcache) |
| for m := range s.workspace.getActiveModFiles() { |
| prefixes = append(prefixes, dirURI(m).Filename()) |
| } |
| } |
| for _, prefix := range prefixes { |
| if strings.HasPrefix(filename, prefix) { |
| return checkIgnored(filename[len(prefix):]) |
| } |
| } |
| return false |
| } |
| |
| // checkIgnored implements go list's exclusion rules. |
| // Quoting “go help list”: |
| // |
| // Directory and file names that begin with "." or "_" are ignored |
| // by the go tool, as are directories named "testdata". |
| func checkIgnored(suffix string) bool { |
| for _, component := range strings.Split(suffix, string(filepath.Separator)) { |
| if len(component) == 0 { |
| continue |
| } |
| if component[0] == '.' || component[0] == '_' || component == "testdata" { |
| return true |
| } |
| } |
| return false |
| } |
| |
| func (v *View) Snapshot(ctx context.Context) (source.Snapshot, func()) { |
| return v.getSnapshot() |
| } |
| |
| func (v *View) getSnapshot() (*snapshot, func()) { |
| v.snapshotMu.Lock() |
| defer v.snapshotMu.Unlock() |
| if v.snapshot == nil { |
| panic("getSnapshot called after shutdown") |
| } |
| return v.snapshot, v.snapshot.Acquire() |
| } |
| |
| func (s *snapshot) initialize(ctx context.Context, firstAttempt bool) { |
| select { |
| case <-ctx.Done(): |
| return |
| case s.view.initializationSema <- struct{}{}: |
| } |
| |
| defer func() { |
| <-s.view.initializationSema |
| }() |
| |
| s.mu.Lock() |
| initialized := s.initialized |
| s.mu.Unlock() |
| |
| if initialized { |
| return |
| } |
| |
| s.loadWorkspace(ctx, firstAttempt) |
| s.collectAllKnownSubdirs(ctx) |
| } |
| |
| func (s *snapshot) loadWorkspace(ctx context.Context, firstAttempt bool) { |
| defer func() { |
| s.mu.Lock() |
| s.initialized = true |
| s.mu.Unlock() |
| if firstAttempt { |
| close(s.view.initialWorkspaceLoad) |
| } |
| }() |
| |
| // TODO(rFindley): we should only locate template files on the first attempt, |
| // or guard it via a different mechanism. |
| s.locateTemplateFiles(ctx) |
| |
| // Collect module paths to load by parsing go.mod files. If a module fails to |
| // parse, capture the parsing failure as a critical diagnostic. |
| var scopes []interface{} // scopes to load |
| var modDiagnostics []*source.Diagnostic // diagnostics for broken go.mod files |
| addError := func(uri span.URI, err error) { |
| modDiagnostics = append(modDiagnostics, &source.Diagnostic{ |
| URI: uri, |
| Severity: protocol.SeverityError, |
| Source: source.ListError, |
| Message: err.Error(), |
| }) |
| } |
| |
| if len(s.workspace.getActiveModFiles()) > 0 { |
| for modURI := range s.workspace.getActiveModFiles() { |
| // Be careful not to add context cancellation errors as critical module |
| // errors. |
| fh, err := s.GetFile(ctx, modURI) |
| if err != nil { |
| if ctx.Err() == nil { |
| addError(modURI, err) |
| } |
| continue |
| } |
| parsed, err := s.ParseMod(ctx, fh) |
| if err != nil { |
| if ctx.Err() == nil { |
| addError(modURI, err) |
| } |
| continue |
| } |
| if parsed.File == nil || parsed.File.Module == nil { |
| addError(modURI, fmt.Errorf("no module path for %s", modURI)) |
| continue |
| } |
| path := parsed.File.Module.Mod.Path |
| scopes = append(scopes, moduleLoadScope(path)) |
| } |
| } else { |
| scopes = append(scopes, viewLoadScope("LOAD_VIEW")) |
| } |
| |
| // If we're loading anything, ensure we also load builtin. |
| // TODO(rstambler): explain the rationale for this. |
| if len(scopes) > 0 { |
| scopes = append(scopes, PackagePath("builtin")) |
| } |
| err := s.load(ctx, true, scopes...) |
| |
| // If the context is canceled on the first attempt, loading has failed |
| // because the go command has timed out--that should be a critical error. |
| if err != nil && !firstAttempt && ctx.Err() != nil { |
| return |
| } |
| |
| var criticalErr *source.CriticalError |
| switch { |
| case err != nil && ctx.Err() != nil: |
| event.Error(ctx, fmt.Sprintf("initial workspace load: %v", err), err) |
| criticalErr = &source.CriticalError{ |
| MainError: err, |
| } |
| case err != nil: |
| event.Error(ctx, "initial workspace load failed", err) |
| extractedDiags := s.extractGoCommandErrors(ctx, err) |
| criticalErr = &source.CriticalError{ |
| MainError: err, |
| Diagnostics: append(modDiagnostics, extractedDiags...), |
| } |
| case len(modDiagnostics) == 1: |
| criticalErr = &source.CriticalError{ |
| MainError: fmt.Errorf(modDiagnostics[0].Message), |
| Diagnostics: modDiagnostics, |
| } |
| case len(modDiagnostics) > 1: |
| criticalErr = &source.CriticalError{ |
| MainError: fmt.Errorf("error loading module names"), |
| Diagnostics: modDiagnostics, |
| } |
| } |
| |
| // Lock the snapshot when setting the initialized error. |
| s.mu.Lock() |
| defer s.mu.Unlock() |
| s.initializedErr = criticalErr |
| } |
| |
| // invalidateContent invalidates the content of a Go file, |
| // including any position and type information that depends on it. |
| // |
| // invalidateContent returns a non-nil snapshot for the new content, along with |
| // a callback which the caller must invoke to release that snapshot. |
| func (v *View) invalidateContent(ctx context.Context, changes map[span.URI]*fileChange, forceReloadMetadata bool) (*snapshot, func()) { |
| // Detach the context so that content invalidation cannot be canceled. |
| ctx = xcontext.Detach(ctx) |
| |
| // This should be the only time we hold the view's snapshot lock for any period of time. |
| v.snapshotMu.Lock() |
| defer v.snapshotMu.Unlock() |
| |
| prevSnapshot, prevReleaseSnapshot := v.snapshot, v.releaseSnapshot |
| |
| if prevSnapshot == nil { |
| panic("invalidateContent called after shutdown") |
| } |
| |
| // Cancel all still-running previous requests, since they would be |
| // operating on stale data. |
| prevSnapshot.cancel() |
| |
| // Do not clone a snapshot until its view has finished initializing. |
| prevSnapshot.AwaitInitialized(ctx) |
| |
| // Save one lease of the cloned snapshot in the view. |
| v.snapshot, v.releaseSnapshot = prevSnapshot.clone(ctx, v.baseCtx, changes, forceReloadMetadata) |
| |
| prevReleaseSnapshot() |
| v.destroy(prevSnapshot, "View.invalidateContent") |
| |
| // Return a second lease to the caller. |
| return v.snapshot, v.snapshot.Acquire() |
| } |
| |
| func (s *Session) getWorkspaceInformation(ctx context.Context, folder span.URI, options *source.Options) (*workspaceInformation, error) { |
| if err := checkPathCase(folder.Filename()); err != nil { |
| return nil, fmt.Errorf("invalid workspace folder path: %w; check that the casing of the configured workspace folder path agrees with the casing reported by the operating system", err) |
| } |
| var err error |
| inv := gocommand.Invocation{ |
| WorkingDir: folder.Filename(), |
| Env: options.EnvSlice(), |
| } |
| goversion, err := gocommand.GoVersion(ctx, inv, s.gocmdRunner) |
| if err != nil { |
| return nil, err |
| } |
| |
| go111module := os.Getenv("GO111MODULE") |
| if v, ok := options.Env["GO111MODULE"]; ok { |
| go111module = v |
| } |
| // Make sure to get the `go env` before continuing with initialization. |
| envVars, env, err := s.getGoEnv(ctx, folder.Filename(), goversion, go111module, options.EnvSlice()) |
| if err != nil { |
| return nil, err |
| } |
| // If using 1.16, change the default back to auto. The primary effect of |
| // GO111MODULE=on is to break GOPATH, which we aren't too interested in. |
| if goversion >= 16 && go111module == "" { |
| go111module = "auto" |
| } |
| // The value of GOPACKAGESDRIVER is not returned through the go command. |
| gopackagesdriver := os.Getenv("GOPACKAGESDRIVER") |
| // TODO(rfindley): this looks wrong, or at least overly defensive. If the |
| // value of GOPACKAGESDRIVER is not returned from the go command... why do we |
| // look it up here? |
| for _, s := range env { |
| split := strings.SplitN(s, "=", 2) |
| if split[0] == "GOPACKAGESDRIVER" { |
| bug.Reportf("found GOPACKAGESDRIVER from the go command") // see note above |
| gopackagesdriver = split[1] |
| } |
| } |
| |
| // A user may also have a gopackagesdriver binary on their machine, which |
| // works the same way as setting GOPACKAGESDRIVER. |
| tool, _ := exec.LookPath("gopackagesdriver") |
| hasGopackagesDriver := gopackagesdriver != "off" && (gopackagesdriver != "" || tool != "") |
| |
| return &workspaceInformation{ |
| hasGopackagesDriver: hasGopackagesDriver, |
| effectiveGo111Module: go111module, |
| userGo111Module: go111moduleForVersion(go111module, goversion), |
| goversion: goversion, |
| environmentVariables: envVars, |
| goEnv: env, |
| }, nil |
| } |
| |
| func go111moduleForVersion(go111module string, goversion int) go111module { |
| // Off by default until Go 1.12. |
| if go111module == "off" || (goversion < 12 && go111module == "") { |
| return off |
| } |
| // On by default as of Go 1.16. |
| if go111module == "on" || (goversion >= 16 && go111module == "") { |
| return on |
| } |
| return auto |
| } |
| |
| // 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, excludePath func(string) bool, experimental bool) (span.URI, error) { |
| patterns := []string{"go.work", "go.mod"} |
| if experimental { |
| patterns = []string{"go.work", "gopls.mod", "go.mod"} |
| } |
| for _, basename := range patterns { |
| dir, err := findRootPattern(ctx, folder, basename, fs) |
| if err != nil { |
| return "", fmt.Errorf("finding %s: %w", basename, err) |
| } |
| if dir != "" { |
| return dir, 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. |
| all, err := findModules(folder, excludePath, 2) |
| 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", fileLimit)) |
| 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) { |
| dir := folder.Filename() |
| for dir != "" { |
| target := filepath.Join(dir, basename) |
| exists, err := fileExists(ctx, span.URIFromPath(target), fs) |
| if err != nil { |
| return "", err |
| } |
| if exists { |
| return span.URIFromPath(dir), nil |
| } |
| // Trailing separators must be trimmed, otherwise filepath.Split is a noop. |
| next, _ := filepath.Split(strings.TrimRight(dir, string(filepath.Separator))) |
| if next == dir { |
| break |
| } |
| dir = next |
| } |
| return "", nil |
| } |
| |
| // OS-specific path case check, for case-insensitive filesystems. |
| var checkPathCase = defaultCheckPathCase |
| |
| func defaultCheckPathCase(path string) error { |
| return nil |
| } |
| |
| // getGoEnv gets the view's various GO* values. |
| func (s *Session) getGoEnv(ctx context.Context, folder string, goversion int, go111module string, configEnv []string) (environmentVariables, map[string]string, error) { |
| envVars := environmentVariables{} |
| vars := map[string]*string{ |
| "GOCACHE": &envVars.gocache, |
| "GOPATH": &envVars.gopath, |
| "GOROOT": &envVars.goroot, |
| "GOPRIVATE": &envVars.goprivate, |
| "GOMODCACHE": &envVars.gomodcache, |
| "GO111MODULE": &envVars.go111module, |
| } |
| |
| // We can save ~200 ms by requesting only the variables we care about. |
| args := append([]string{"-json"}, imports.RequiredGoEnvVars...) |
| for k := range vars { |
| args = append(args, k) |
| } |
| // TODO(rfindley): GOWORK is not a property of the session. It may change |
| // when a workfile is added or removed. |
| // |
| // We need to distinguish between GOWORK values that are set by the GOWORK |
| // environment variable, and GOWORK values that are computed based on the |
| // location of a go.work file in the directory hierarchy. |
| args = append(args, "GOWORK") |
| |
| inv := gocommand.Invocation{ |
| Verb: "env", |
| Args: args, |
| Env: configEnv, |
| WorkingDir: folder, |
| } |
| // Don't go through runGoCommand, as we don't need a temporary -modfile to |
| // run `go env`. |
| stdout, err := s.gocmdRunner.Run(ctx, inv) |
| if err != nil { |
| return environmentVariables{}, nil, err |
| } |
| env := make(map[string]string) |
| if err := json.Unmarshal(stdout.Bytes(), &env); err != nil { |
| return environmentVariables{}, nil, err |
| } |
| |
| for key, ptr := range vars { |
| *ptr = env[key] |
| } |
| |
| // Old versions of Go don't have GOMODCACHE, so emulate it. |
| if envVars.gomodcache == "" && envVars.gopath != "" { |
| envVars.gomodcache = filepath.Join(filepath.SplitList(envVars.gopath)[0], "pkg/mod") |
| } |
| // GO111MODULE does not appear in `go env` output until Go 1.13. |
| if goversion < 13 { |
| envVars.go111module = go111module |
| } |
| return envVars, env, err |
| } |
| |
| func (v *View) IsGoPrivatePath(target string) bool { |
| return globsMatchPath(v.goprivate, target) |
| } |
| |
| func (v *View) ModuleUpgrades() map[string]string { |
| v.mu.Lock() |
| defer v.mu.Unlock() |
| |
| upgrades := map[string]string{} |
| for mod, ver := range v.moduleUpgrades { |
| upgrades[mod] = ver |
| } |
| return upgrades |
| } |
| |
| func (v *View) RegisterModuleUpgrades(upgrades map[string]string) { |
| v.mu.Lock() |
| defer v.mu.Unlock() |
| |
| for mod, ver := range upgrades { |
| v.moduleUpgrades[mod] = ver |
| } |
| } |
| |
| // Copied from |
| // https://cs.opensource.google/go/go/+/master:src/cmd/go/internal/str/path.go;l=58;drc=2910c5b4a01a573ebc97744890a07c1a3122c67a |
| func globsMatchPath(globs, target string) bool { |
| for globs != "" { |
| // Extract next non-empty glob in comma-separated list. |
| var glob string |
| if i := strings.Index(globs, ","); i >= 0 { |
| glob, globs = globs[:i], globs[i+1:] |
| } else { |
| glob, globs = globs, "" |
| } |
| if glob == "" { |
| continue |
| } |
| |
| // A glob with N+1 path elements (N slashes) needs to be matched |
| // against the first N+1 path elements of target, |
| // which end just before the N+1'th slash. |
| n := strings.Count(glob, "/") |
| prefix := target |
| // Walk target, counting slashes, truncating at the N+1'th slash. |
| for i := 0; i < len(target); i++ { |
| if target[i] == '/' { |
| if n == 0 { |
| prefix = target[:i] |
| break |
| } |
| n-- |
| } |
| } |
| if n > 0 { |
| // Not enough prefix elements. |
| continue |
| } |
| matched, _ := path.Match(glob, prefix) |
| if matched { |
| return true |
| } |
| } |
| return false |
| } |
| |
| var modFlagRegexp = regexp.MustCompile(`-mod[ =](\w+)`) |
| |
| // TODO(rstambler): Consolidate modURI and modContent back into a FileHandle |
| // after we have a version of the workspace go.mod file on disk. Getting a |
| // FileHandle from the cache for temporary files is problematic, since we |
| // cannot delete it. |
| func (s *snapshot) vendorEnabled(ctx context.Context, modURI span.URI, modContent []byte) (bool, error) { |
| if s.workspaceMode()&moduleMode == 0 { |
| return false, nil |
| } |
| matches := modFlagRegexp.FindStringSubmatch(s.view.goEnv["GOFLAGS"]) |
| var modFlag string |
| if len(matches) != 0 { |
| modFlag = matches[1] |
| } |
| if modFlag != "" { |
| // Don't override an explicit '-mod=vendor' argument. |
| // We do want to override '-mod=readonly': it would break various module code lenses, |
| // and on 1.16 we know -modfile is available, so we won't mess with go.mod anyway. |
| return modFlag == "vendor", nil |
| } |
| |
| modFile, err := modfile.Parse(modURI.Filename(), modContent, nil) |
| if err != nil { |
| return false, err |
| } |
| if fi, err := os.Stat(filepath.Join(s.view.rootURI.Filename(), "vendor")); err != nil || !fi.IsDir() { |
| return false, nil |
| } |
| vendorEnabled := modFile.Go != nil && modFile.Go.Version != "" && semver.Compare("v"+modFile.Go.Version, "v1.14") >= 0 |
| return vendorEnabled, nil |
| } |
| |
| func (v *View) allFilesExcluded(pkg *packages.Package, filterer *source.Filterer) bool { |
| folder := filepath.ToSlash(v.folder.Filename()) |
| for _, f := range pkg.GoFiles { |
| f = filepath.ToSlash(f) |
| if !strings.HasPrefix(f, folder) { |
| return false |
| } |
| if !pathExcludedByFilter(strings.TrimPrefix(f, folder), filterer) { |
| return false |
| } |
| } |
| return true |
| } |
| |
| func pathExcludedByFilterFunc(root, gomodcache string, opts *source.Options) func(string) bool { |
| filterer := buildFilterer(root, gomodcache, opts) |
| return func(path string) bool { |
| return pathExcludedByFilter(path, filterer) |
| } |
| } |
| |
| // pathExcludedByFilter reports whether the path (relative to the workspace |
| // folder) should be excluded by the configured directory filters. |
| // |
| // TODO(rfindley): passing root and gomodcache here makes it confusing whether |
| // path should be absolute or relative, and has already caused at least one |
| // bug. |
| func pathExcludedByFilter(path string, filterer *source.Filterer) bool { |
| path = strings.TrimPrefix(filepath.ToSlash(path), "/") |
| return filterer.Disallow(path) |
| } |
| |
| func buildFilterer(root, gomodcache string, opts *source.Options) *source.Filterer { |
| // TODO(rfindley): this looks wrong. If gomodcache isn't actually nested |
| // under root, this will do the wrong thing. |
| gomodcache = strings.TrimPrefix(filepath.ToSlash(strings.TrimPrefix(gomodcache, root)), "/") |
| filters := opts.DirectoryFilters |
| if gomodcache != "" { |
| filters = append(filters, "-"+gomodcache) |
| } |
| return source.NewFilterer(filters) |
| } |