blob: de36da69b91d77f132e206e7696c13e882d336dc [file] [log] [blame]
// Copyright 2020 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
import (
"context"
"errors"
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"golang.org/x/mod/modfile"
"golang.org/x/tools/gopls/internal/lsp/source"
"golang.org/x/tools/gopls/internal/span"
)
// TODO(rfindley): now that experimentalWorkspaceModule is gone, this file can
// be massively cleaned up and/or removed.
// computeWorkspaceModFiles computes the set of workspace mod files based on the
// value of go.mod, go.work, and GO111MODULE.
func computeWorkspaceModFiles(ctx context.Context, gomod, gowork span.URI, go111module go111module, fs source.FileSource) (map[span.URI]struct{}, error) {
if go111module == off {
return nil, nil
}
if gowork != "" {
fh, err := fs.ReadFile(ctx, gowork)
if err != nil {
return nil, err
}
content, err := fh.Content()
if err != nil {
return nil, err
}
filename := gowork.Filename()
dir := filepath.Dir(filename)
workFile, err := modfile.ParseWork(filename, content, nil)
if err != nil {
return nil, fmt.Errorf("parsing go.work: %w", err)
}
modFiles := make(map[span.URI]struct{})
for _, use := range workFile.Use {
modDir := filepath.FromSlash(use.Path)
if !filepath.IsAbs(modDir) {
modDir = filepath.Join(dir, modDir)
}
modURI := span.URIFromPath(filepath.Join(modDir, "go.mod"))
modFiles[modURI] = struct{}{}
}
return modFiles, nil
}
if gomod != "" {
return map[span.URI]struct{}{gomod: {}}, nil
}
return nil, nil
}
// dirs returns the workspace directories for the loaded modules.
//
// A workspace directory is, roughly speaking, a directory for which we care
// about file changes. This is used for the purpose of registering file
// watching patterns, and expanding directory modifications to their adjacent
// files.
//
// TODO(rfindley): move this to snapshot.go.
// TODO(rfindley): can we make this abstraction simpler and/or more accurate?
func (s *snapshot) dirs(ctx context.Context) []span.URI {
dirSet := make(map[span.URI]struct{})
// Dirs should, at the very least, contain the working directory and folder.
dirSet[s.view.workingDir()] = struct{}{}
dirSet[s.view.folder] = struct{}{}
// Additionally, if e.g. go.work indicates other workspace modules, we should
// include their directories too.
if s.workspaceModFilesErr == nil {
for modFile := range s.workspaceModFiles {
dir := filepath.Dir(modFile.Filename())
dirSet[span.URIFromPath(dir)] = struct{}{}
}
}
var dirs []span.URI
for d := range dirSet {
dirs = append(dirs, d)
}
sort.Slice(dirs, func(i, j int) bool { return dirs[i] < dirs[j] })
return dirs
}
// isGoMod reports if uri is a go.mod file.
func isGoMod(uri span.URI) bool {
return filepath.Base(uri.Filename()) == "go.mod"
}
// isGoWork reports if uri is a go.work file.
func isGoWork(uri span.URI) bool {
return filepath.Base(uri.Filename()) == "go.work"
}
// fileExists reports if the file uri exists within source.
func fileExists(ctx context.Context, uri span.URI, source source.FileSource) (bool, error) {
fh, err := source.ReadFile(ctx, uri)
if err != nil {
return false, err
}
return fileHandleExists(fh)
}
// fileHandleExists reports if the file underlying fh actually exists.
func fileHandleExists(fh source.FileHandle) (bool, error) {
_, err := fh.Content()
if err == nil {
return true, nil
}
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
// errExhausted is returned by findModules if the file scan limit is reached.
var errExhausted = errors.New("exhausted")
// Limit go.mod search to 1 million files. As a point of reference,
// Kubernetes has 22K files (as of 2020-11-24).
const fileLimit = 1000000
// 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.
//
// TODO(rfindley): consider overlays.
func findModules(root span.URI, excludePath func(string) bool, modLimit int) (map[span.URI]struct{}, error) {
// Walk the view's folder to find all modules in the view.
modFiles := make(map[span.URI]struct{})
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
}
// For any path that is not the workspace folder, check if the path
// would be ignored by the go command. Vendor directories also do not
// contain workspace modules.
if info.IsDir() && path != root.Filename() {
suffix := strings.TrimPrefix(path, root.Filename())
switch {
case checkIgnored(suffix),
strings.Contains(filepath.ToSlash(suffix), "/vendor/"),
excludePath(suffix):
return filepath.SkipDir
}
}
// We're only interested in go.mod files.
uri := span.URIFromPath(path)
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
}