hack/update-vendor.sh

vendor/golang.org/x/tools/go/analysis/analysis.go

@@ -128,11 +128,13 @@ type Pass struct {
 	// See comments for ExportObjectFact.
 	ExportPackageFact func(fact Fact)
 
-	// AllPackageFacts returns a new slice containing all package facts in unspecified order.
+	// AllPackageFacts returns a new slice containing all package facts of the analysis's FactTypes
+	// in unspecified order.
 	// WARNING: This is an experimental API and may change in the future.
 	AllPackageFacts func() []PackageFact
 
-	// AllObjectFacts returns a new slice containing all object facts in unspecified order.
+	// AllObjectFacts returns a new slice containing all object facts of the analysis's FactTypes
+	// in unspecified order.
 	// WARNING: This is an experimental API and may change in the future.
 	AllObjectFacts func() []ObjectFact
 

vendor/golang.org/x/tools/go/analysis/diagnostic.go

@@ -1,5 +1,3 @@
-// +build !experimental
-
 package analysis
 
 import "go/token"
@@ -17,4 +15,34 @@ type Diagnostic struct {
 	End      token.Pos // optional
 	Category string    // optional
 	Message  string
+
+	// SuggestedFixes contains suggested fixes for a diagnostic which can be used to perform
+	// edits to a file that address the diagnostic.
+	// TODO(matloob): Should multiple SuggestedFixes be allowed for a diagnostic?
+	// Diagnostics should not contain SuggestedFixes that overlap.
+	// Experimental: This API is experimental and may change in the future.
+	SuggestedFixes []SuggestedFix // optional
+}
+
+// A SuggestedFix is a code change associated with a Diagnostic that a user can choose
+// to apply to their code. Usually the SuggestedFix is meant to fix the issue flagged
+// by the diagnostic.
+// TextEdits for a SuggestedFix should not overlap. TextEdits for a SuggestedFix
+// should not contain edits for other packages.
+// Experimental: This API is experimental and may change in the future.
+type SuggestedFix struct {
+	// A description for this suggested fix to be shown to a user deciding
+	// whether to accept it.
+	Message   string
+	TextEdits []TextEdit
+}
+
+// A TextEdit represents the replacement of the code between Pos and End with the new text.
+// Each TextEdit should apply to a single file. End should not be earlier in the file than Pos.
+// Experimental: This API is experimental and may change in the future.
+type TextEdit struct {
+	// For a pure insertion, End can either be set to Pos or token.NoPos.
+	Pos     token.Pos
+	End     token.Pos
+	NewText []byte
 }

vendor/golang.org/x/tools/go/analysis/diagnostic_experimental.go

@@ -1,41 +0,0 @@
-// +build experimental
-
-package analysis
-
-import "go/token"
-
-// A Diagnostic is a message associated with a source location or range.
-//
-// An Analyzer may return a variety of diagnostics; the optional Category,
-// which should be a constant, may be used to classify them.
-// It is primarily intended to make it easy to look up documentation.
-//
-// If End is provided, the diagnostic is specified to apply to the range between
-// Pos and End.
-type Diagnostic struct {
-	Pos      token.Pos
-	End      token.Pos // optional
-	Category string    // optional
-	Message  string
-
-	// TODO(matloob): Should multiple SuggestedFixes be allowed for a diagnostic?
-	SuggestedFixes []SuggestedFix // optional
-}
-
-// A SuggestedFix is a code change associated with a Diagnostic that a user can choose
-// to apply to their code. Usually the SuggestedFix is meant to fix the issue flagged
-// by the diagnostic.
-type SuggestedFix struct {
-	// A description for this suggested fix to be shown to a user deciding
-	// whether to accept it.
-	Message   string
-	TextEdits []TextEdit
-}
-
-// A TextEdit represents the replacement of the code between Pos and End with the new text.
-type TextEdit struct {
-	// For a pure insertion, End can either be set to Pos or token.NoPos.
-	Pos     token.Pos
-	End     token.Pos
-	NewText []byte
-}

vendor/golang.org/x/tools/go/gcexportdata/main.go

@@ -1,99 +0,0 @@
-// Copyright 2017 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.
-
-// +build ignore
-
-// The gcexportdata command is a diagnostic tool that displays the
-// contents of gc export data files.
-package main
-
-import (
-	"flag"
-	"fmt"
-	"go/token"
-	"go/types"
-	"log"
-	"os"
-
-	"golang.org/x/tools/go/gcexportdata"
-	"golang.org/x/tools/go/types/typeutil"
-)
-
-var packageFlag = flag.String("package", "", "alternative package to print")
-
-func main() {
-	log.SetPrefix("gcexportdata: ")
-	log.SetFlags(0)
-	flag.Usage = func() {
-		fmt.Fprintln(os.Stderr, "usage: gcexportdata [-package path] file.a")
-	}
-	flag.Parse()
-	if flag.NArg() != 1 {
-		flag.Usage()
-		os.Exit(2)
-	}
-	filename := flag.Args()[0]
-
-	f, err := os.Open(filename)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	r, err := gcexportdata.NewReader(f)
-	if err != nil {
-		log.Fatalf("%s: %s", filename, err)
-	}
-
-	// Decode the package.
-	const primary = "<primary>"
-	imports := make(map[string]*types.Package)
-	fset := token.NewFileSet()
-	pkg, err := gcexportdata.Read(r, fset, imports, primary)
-	if err != nil {
-		log.Fatalf("%s: %s", filename, err)
-	}
-
-	// Optionally select an indirectly mentioned package.
-	if *packageFlag != "" {
-		pkg = imports[*packageFlag]
-		if pkg == nil {
-			fmt.Fprintf(os.Stderr, "export data file %s does not mention %s; has:\n",
-				filename, *packageFlag)
-			for p := range imports {
-				if p != primary {
-					fmt.Fprintf(os.Stderr, "\t%s\n", p)
-				}
-			}
-			os.Exit(1)
-		}
-	}
-
-	// Print all package-level declarations, including non-exported ones.
-	fmt.Printf("package %s\n", pkg.Name())
-	for _, imp := range pkg.Imports() {
-		fmt.Printf("import %q\n", imp.Path())
-	}
-	qual := func(p *types.Package) string {
-		if pkg == p {
-			return ""
-		}
-		return p.Name()
-	}
-	scope := pkg.Scope()
-	for _, name := range scope.Names() {
-		obj := scope.Lookup(name)
-		fmt.Printf("%s: %s\n",
-			fset.Position(obj.Pos()),
-			types.ObjectString(obj, qual))
-
-		// For types, print each method.
-		if _, ok := obj.(*types.TypeName); ok {
-			for _, method := range typeutil.IntuitiveMethodSet(obj.Type(), nil) {
-				fmt.Printf("%s: %s\n",
-					fset.Position(method.Obj().Pos()),
-					types.SelectionString(method, qual))
-			}
-		}
-	}
-}

vendor/golang.org/x/tools/go/internal/packagesdriver/sizes.go

@@ -82,15 +82,28 @@ func GetSizesGolist(ctx context.Context, buildFlags, env []string, dir string, u
 	args = append(args, buildFlags...)
 	args = append(args, "--", "unsafe")
 	stdout, err := InvokeGo(ctx, env, dir, usesExportData, args...)
+	var goarch, compiler string
 	if err != nil {
-		return nil, err
+		if strings.Contains(err.Error(), "cannot find main module") {
+			// User's running outside of a module. All bets are off. Get GOARCH and guess compiler is gc.
+			// TODO(matloob): Is this a problem in practice?
+			envout, enverr := InvokeGo(ctx, env, dir, usesExportData, "env", "GOARCH")
+			if enverr != nil {
+				return nil, err
+			}
+			goarch = strings.TrimSpace(envout.String())
+			compiler = "gc"
+		} else {
+			return nil, err
+		}
+	} else {
+		fields := strings.Fields(stdout.String())
+		if len(fields) < 2 {
+			return nil, fmt.Errorf("could not determine GOARCH and Go compiler")
+		}
+		goarch = fields[0]
+		compiler = fields[1]
 	}
-	fields := strings.Fields(stdout.String())
-	if len(fields) < 2 {
-		return nil, fmt.Errorf("could not determine GOARCH and Go compiler")
-	}
-	goarch := fields[0]
-	compiler := fields[1]
 	return types.SizesFor(compiler, goarch), nil
 }
 

vendor/golang.org/x/tools/go/packages/external.go

@@ -16,14 +16,29 @@ import (
 	"strings"
 )
 
-// Driver
+// The Driver Protocol
+//
+// The driver, given the inputs to a call to Load, returns metadata about the packages specified.
+// This allows for different build systems to support go/packages by telling go/packages how the
+// packages' source is organized.
+// The driver is a binary, either specified by the GOPACKAGESDRIVER environment variable or in
+// the path as gopackagesdriver. It's given the inputs to load in its argv. See the package
+// documentation in doc.go for the full description of the patterns that need to be supported.
+// A driver receives as a JSON-serialized driverRequest struct in standard input and will
+// produce a JSON-serialized driverResponse (see definition in packages.go) in its standard output.
+
+// driverRequest is used to provide the portion of Load's Config that is needed by a driver.
 type driverRequest struct {
-	Command    string            `json:"command"`
-	Mode       LoadMode          `json:"mode"`
-	Env        []string          `json:"env"`
-	BuildFlags []string          `json:"build_flags"`
-	Tests      bool              `json:"tests"`
-	Overlay    map[string][]byte `json:"overlay"`
+	Mode LoadMode `json:"mode"`
+	// Env specifies the environment the underlying build system should be run in.
+	Env []string `json:"env"`
+	// BuildFlags are flags that should be passed to the underlying build system.
+	BuildFlags []string `json:"build_flags"`
+	// Tests specifies whether the patterns should also return test packages.
+	Tests bool `json:"tests"`
+	// Overlay maps file paths (relative to the driver's working directory) to the byte contents
+	// of overlay files.
+	Overlay map[string][]byte `json:"overlay"`
 }
 
 // findExternalDriver returns the file path of a tool that supplies

vendor/golang.org/x/tools/go/packages/golist.go

@@ -13,6 +13,7 @@ import (
 	"log"
 	"os"
 	"os/exec"
+	"path"
 	"path/filepath"
 	"reflect"
 	"regexp"
@@ -71,6 +72,28 @@ func (r *responseDeduper) addRoot(id string) {
 	r.dr.Roots = append(r.dr.Roots, id)
 }
 
+// goInfo contains global information from the go tool.
+type goInfo struct {
+	rootDirs map[string]string
+	env      goEnv
+}
+
+type goEnv struct {
+	modulesOn bool
+}
+
+func determineEnv(cfg *Config) goEnv {
+	buf, err := invokeGo(cfg, "env", "GOMOD")
+	if err != nil {
+		return goEnv{}
+	}
+	gomod := bytes.TrimSpace(buf.Bytes())
+
+	env := goEnv{}
+	env.modulesOn = len(gomod) > 0
+	return env
+}
+
 // goListDriver uses the go list command to interpret the patterns and produce
 // the build system package structure.
 // See driver for more details.
@@ -86,6 +109,28 @@ func goListDriver(cfg *Config, patterns ...string) (*driverResponse, error) {
 		}()
 	}
 
+	// start fetching rootDirs
+	var info goInfo
+	var rootDirsReady, envReady = make(chan struct{}), make(chan struct{})
+	go func() {
+		info.rootDirs = determineRootDirs(cfg)
+		close(rootDirsReady)
+	}()
+	go func() {
+		info.env = determineEnv(cfg)
+		close(envReady)
+	}()
+	getGoInfo := func() *goInfo {
+		<-rootDirsReady
+		<-envReady
+		return &info
+	}
+
+	// always pass getGoInfo to golistDriver
+	golistDriver := func(cfg *Config, patterns ...string) (*driverResponse, error) {
+		return golistDriver(cfg, getGoInfo, patterns...)
+	}
+
 	// Determine files requested in contains patterns
 	var containFiles []string
 	var packagesNamed []string
@@ -147,7 +192,7 @@ extractQueries:
 	var containsCandidates []string
 
 	if len(containFiles) != 0 {
-		if err := runContainsQueries(cfg, golistDriver, response, containFiles); err != nil {
+		if err := runContainsQueries(cfg, golistDriver, response, containFiles, getGoInfo); err != nil {
 			return nil, err
 		}
 	}
@@ -158,7 +203,7 @@ extractQueries:
 		}
 	}
 
-	modifiedPkgs, needPkgs, err := processGolistOverlay(cfg, response)
+	modifiedPkgs, needPkgs, err := processGolistOverlay(cfg, response, getGoInfo)
 	if err != nil {
 		return nil, err
 	}
@@ -166,7 +211,7 @@ extractQueries:
 		containsCandidates = append(containsCandidates, modifiedPkgs...)
 		containsCandidates = append(containsCandidates, needPkgs...)
 	}
-	if err := addNeededOverlayPackages(cfg, golistDriver, response, needPkgs); err != nil {
+	if err := addNeededOverlayPackages(cfg, golistDriver, response, needPkgs, getGoInfo); err != nil {
 		return nil, err
 	}
 	// Check candidate packages for containFiles.
@@ -198,26 +243,33 @@ extractQueries:
 	return response.dr, nil
 }
 
-func addNeededOverlayPackages(cfg *Config, driver driver, response *responseDeduper, pkgs []string) error {
+func addNeededOverlayPackages(cfg *Config, driver driver, response *responseDeduper, pkgs []string, getGoInfo func() *goInfo) error {
 	if len(pkgs) == 0 {
 		return nil
 	}
-	dr, err := driver(cfg, pkgs...)
+	drivercfg := *cfg
+	if getGoInfo().env.modulesOn {
+		drivercfg.BuildFlags = append(drivercfg.BuildFlags, "-mod=readonly")
+	}
+	dr, err := driver(&drivercfg, pkgs...)
+
 	if err != nil {
 		return err
 	}
 	for _, pkg := range dr.Packages {
 		response.addPackage(pkg)
 	}
-	_, needPkgs, err := processGolistOverlay(cfg, response)
+	_, needPkgs, err := processGolistOverlay(cfg, response, getGoInfo)
 	if err != nil {
 		return err
 	}
-	addNeededOverlayPackages(cfg, driver, response, needPkgs)
+	if err := addNeededOverlayPackages(cfg, driver, response, needPkgs, getGoInfo); err != nil {
+		return err
+	}
 	return nil
 }
 
-func runContainsQueries(cfg *Config, driver driver, response *responseDeduper, queries []string) error {
+func runContainsQueries(cfg *Config, driver driver, response *responseDeduper, queries []string, goInfo func() *goInfo) error {
 	for _, query := range queries {
 		// TODO(matloob): Do only one query per directory.
 		fdir := filepath.Dir(query)
@@ -228,14 +280,31 @@ func runContainsQueries(cfg *Config, driver driver, response *responseDeduper, q
 			return fmt.Errorf("could not determine absolute path of file= query path %q: %v", query, err)
 		}
 		dirResponse, err := driver(cfg, pattern)
-		if err != nil {
-			// Couldn't find a package for the directory. Try to load the file as an ad-hoc package.
+		if err != nil || (len(dirResponse.Packages) == 1 && len(dirResponse.Packages[0].Errors) == 1) {
+			// There was an error loading the package. Try to load the file as an ad-hoc package.
+			// Usually the error will appear in a returned package, but may not if we're in modules mode
+			// and the ad-hoc is located outside a module.
 			var queryErr error
-			dirResponse, err = driver(cfg, query)
+			dirResponse, queryErr = driver(cfg, query)
 			if queryErr != nil {
 				// Return the original error if the attempt to fall back failed.
 				return err
 			}
+			// Special case to handle issue #33482:
+			// If this is a file= query for ad-hoc packages where the file only exists on an overlay,
+			// and exists outside of a module, add the file in for the package.
+			if len(dirResponse.Packages) == 1 && len(dirResponse.Packages) == 1 &&
+				dirResponse.Packages[0].ID == "command-line-arguments" && len(dirResponse.Packages[0].GoFiles) == 0 {
+				filename := filepath.Join(pattern, filepath.Base(query)) // avoid recomputing abspath
+				// TODO(matloob): check if the file is outside of a root dir?
+				for path := range cfg.Overlay {
+					if path == filename {
+						dirResponse.Packages[0].Errors = nil
+						dirResponse.Packages[0].GoFiles = []string{path}
+						dirResponse.Packages[0].CompiledGoFiles = []string{path}
+					}
+				}
+			}
 		}
 		isRoot := make(map[string]bool, len(dirResponse.Roots))
 		for _, root := range dirResponse.Roots {
@@ -312,9 +381,7 @@ func runNamedQueries(cfg *Config, driver driver, response *responseDeduper, quer
 
 	startWalk := time.Now()
 	gopathwalk.Walk(roots, add, gopathwalk.Options{ModulesEnabled: modRoot != "", Debug: debug})
-	if debug {
-		log.Printf("%v for walk", time.Since(startWalk))
-	}
+	cfg.Logf("%v for walk", time.Since(startWalk))
 
 	// Weird special case: the top-level package in a module will be in
 	// whatever directory the user checked the repository out into. It's
@@ -565,7 +632,7 @@ func otherFiles(p *jsonPackage) [][]string {
 // golistDriver uses the "go list" command to expand the pattern
 // words and return metadata for the specified packages. dir may be
 // "" and env may be nil, as per os/exec.Command.
-func golistDriver(cfg *Config, words ...string) (*driverResponse, error) {
+func golistDriver(cfg *Config, rootsDirs func() *goInfo, words ...string) (*driverResponse, error) {
 	// go list uses the following identifiers in ImportPath and Imports:
 	//
 	// 	"p"			-- importable package or main (command)
@@ -606,6 +673,20 @@ func golistDriver(cfg *Config, words ...string) (*driverResponse, error) {
 			return nil, fmt.Errorf("package missing import path: %+v", p)
 		}
 
+		// Work around https://golang.org/issue/33157:
+		// go list -e, when given an absolute path, will find the package contained at
+		// that directory. But when no package exists there, it will return a fake package
+		// with an error and the ImportPath set to the absolute path provided to go list.
+		// Try toto convert that absolute path to what its package path would be if it's
+		// contained in a known module or GOPATH entry. This will allow the package to be
+		// properly "reclaimed" when overlays are processed.
+		if filepath.IsAbs(p.ImportPath) && p.Error != nil {
+			pkgPath, ok := getPkgPath(p.ImportPath, rootsDirs)
+			if ok {
+				p.ImportPath = pkgPath
+			}
+		}
+
 		if old, found := seen[p.ImportPath]; found {
 			if !reflect.DeepEqual(p, old) {
 				return nil, fmt.Errorf("internal error: go list gives conflicting information for package %v", p.ImportPath)
@@ -709,6 +790,27 @@ func golistDriver(cfg *Config, words ...string) (*driverResponse, error) {
 	return &response, nil
 }
 
+// getPkgPath finds the package path of a directory if it's relative to a root directory.
+func getPkgPath(dir string, goInfo func() *goInfo) (string, bool) {
+	for rdir, rpath := range goInfo().rootDirs {
+		// TODO(matloob): This doesn't properly handle symlinks.
+		r, err := filepath.Rel(rdir, dir)
+		if err != nil {
+			continue
+		}
+		if rpath != "" {
+			// We choose only ore root even though the directory even it can belong in multiple modules
+			// or GOPATH entries. This is okay because we only need to work with absolute dirs when a
+			// file is missing from disk, for instance when gopls calls go/packages in an overlay.
+			// Once the file is saved, gopls, or the next invocation of the tool will get the correct
+			// result straight from golist.
+			// TODO(matloob): Implement module tiebreaking?
+			return path.Join(rpath, filepath.ToSlash(r)), true
+		}
+	}
+	return "", false
+}
+
 // absJoin absolutizes and flattens the lists of files.
 func absJoin(dir string, fileses ...[]string) (res []string) {
 	for _, files := range fileses {
@@ -755,11 +857,9 @@ func invokeGo(cfg *Config, args ...string) (*bytes.Buffer, error) {
 	cmd.Dir = cfg.Dir
 	cmd.Stdout = stdout
 	cmd.Stderr = stderr
-	if debug {
-		defer func(start time.Time) {
-			log.Printf("%s for %v, stderr: <<%s>>\n", time.Since(start), cmdDebugStr(cmd, args...), stderr)
-		}(time.Now())
-	}
+	defer func(start time.Time) {
+		cfg.Logf("%s for %v, stderr: <<%s>>\n", time.Since(start), cmdDebugStr(cmd, args...), stderr)
+	}(time.Now())
 
 	if err := cmd.Run(); err != nil {
 		// Check for 'go' executable not being found.
@@ -779,6 +879,17 @@ func invokeGo(cfg *Config, args ...string) (*bytes.Buffer, error) {
 			return nil, goTooOldError{fmt.Errorf("unsupported version of go: %s: %s", exitErr, stderr)}
 		}
 
+		// Related to #24854
+		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "unexpected directory layout") {
+			return nil, fmt.Errorf("%s", stderr.String())
+		}
+
+		// Is there an error running the C compiler in cgo? This will be reported in the "Error" field
+		// and should be suppressed by go list -e.
+		if len(stderr.String()) > 0 && strings.HasPrefix(stderr.String(), "# runtime/cgo\n") && strings.Count(stderr.String(), "\n") == 2 {
+			return stdout, nil
+		}
+
 		// This error only appears in stderr. See golang.org/cl/166398 for a fix in go list to show
 		// the error in the Err section of stdout in case -e option is provided.
 		// This fix is provided for backwards compatibility.
@@ -788,7 +899,27 @@ func invokeGo(cfg *Config, args ...string) (*bytes.Buffer, error) {
 			return bytes.NewBufferString(output), nil
 		}
 
+		// Similar to the previous error, but currently lacks a fix in Go.
+		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "named files must all be in one directory") {
+			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+				strings.Trim(stderr.String(), "\n"))
+			return bytes.NewBufferString(output), nil
+		}
+
+		// Backwards compatibility for Go 1.11 because 1.12 and 1.13 put the directory in the ImportPath.
+		// If the package doesn't exist, put the absolute path of the directory into the error message,
+		// as Go 1.13 list does.
+		const noSuchDirectory = "no such directory"
+		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), noSuchDirectory) {
+			errstr := stderr.String()
+			abspath := strings.TrimSpace(errstr[strings.Index(errstr, noSuchDirectory)+len(noSuchDirectory):])
+			output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+				abspath, strings.Trim(stderr.String(), "\n"))
+			return bytes.NewBufferString(output), nil
+		}
+
 		// Workaround for #29280: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
+		// Note that the error message we look for in this case is different that the one looked for above.
 		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no such file or directory") {
 			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
 				strings.Trim(stderr.String(), "\n"))

vendor/golang.org/x/tools/go/packages/golist_overlay.go

@@ -10,7 +10,6 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"sync"
 )
 
 // processGolistOverlay provides rudimentary support for adding
@@ -18,7 +17,7 @@ import (
 // sometimes incorrect.
 // TODO(matloob): Handle unsupported cases, including the following:
 // - determining the correct package to add given a new import path
-func processGolistOverlay(cfg *Config, response *responseDeduper) (modifiedPkgs, needPkgs []string, err error) {
+func processGolistOverlay(cfg *Config, response *responseDeduper, rootDirs func() *goInfo) (modifiedPkgs, needPkgs []string, err error) {
 	havePkgs := make(map[string]string) // importPath -> non-test package ID
 	needPkgsSet := make(map[string]bool)
 	modifiedPkgsSet := make(map[string]bool)
@@ -29,8 +28,12 @@ func processGolistOverlay(cfg *Config, response *responseDeduper) (modifiedPkgs,
 		havePkgs[pkg.PkgPath] = pkg.ID
 	}
 
-	var rootDirs map[string]string
-	var onceGetRootDirs sync.Once
+	// If no new imports are added, it is safe to avoid loading any needPkgs.
+	// Otherwise, it's hard to tell which package is actually being loaded
+	// (due to vendoring) and whether any modified package will show up
+	// in the transitive set of dependencies (because new imports are added,
+	// potentially modifying the transitive set of dependencies).
+	var overlayAddsImports bool
 
 	for opath, contents := range cfg.Overlay {
 		base := filepath.Base(opath)
@@ -47,7 +50,7 @@ func processGolistOverlay(cfg *Config, response *responseDeduper) (modifiedPkgs,
 		}
 	nextPackage:
 		for _, p := range response.dr.Packages {
-			if pkgName != p.Name {
+			if pkgName != p.Name && p.ID != "command-line-arguments" {
 				continue
 			}
 			for _, f := range p.GoFiles {
@@ -69,13 +72,10 @@ func processGolistOverlay(cfg *Config, response *responseDeduper) (modifiedPkgs,
 		}
 		// The overlay could have included an entirely new package.
 		if pkg == nil {
-			onceGetRootDirs.Do(func() {
-				rootDirs = determineRootDirs(cfg)
-			})
 			// Try to find the module or gopath dir the file is contained in.
 			// Then for modules, add the module opath to the beginning.
 			var pkgPath string
-			for rdir, rpath := range rootDirs {
+			for rdir, rpath := range rootDirs().rootDirs {
 				// TODO(matloob): This doesn't properly handle symlinks.
 				r, err := filepath.Rel(rdir, dir)
 				if err != nil {
@@ -136,6 +136,7 @@ func processGolistOverlay(cfg *Config, response *responseDeduper) (modifiedPkgs,
 		for _, imp := range imports {
 			_, found := pkg.Imports[imp]
 			if !found {
+				overlayAddsImports = true
 				// TODO(matloob): Handle cases when the following block isn't correct.
 				// These include imports of test variants, imports of vendored packages, etc.
 				id, ok := havePkgs[imp]
@@ -171,9 +172,11 @@ func processGolistOverlay(cfg *Config, response *responseDeduper) (modifiedPkgs,
 		}
 	}
 
-	needPkgs = make([]string, 0, len(needPkgsSet))
-	for pkg := range needPkgsSet {
-		needPkgs = append(needPkgs, pkg)
+	if overlayAddsImports {
+		needPkgs = make([]string, 0, len(needPkgsSet))
+		for pkg := range needPkgsSet {
+			needPkgs = append(needPkgs, pkg)
+		}
 	}
 	modifiedPkgs = make([]string, 0, len(modifiedPkgsSet))
 	for pkg := range modifiedPkgsSet {

vendor/golang.org/x/tools/go/packages/packages.go

@@ -103,6 +103,12 @@ type Config struct {
 	// If Context is nil, the load cannot be cancelled.
 	Context context.Context
 
+	// Logf is the logger for the config.
+	// If the user provides a logger, debug logging is enabled.
+	// If the GOPACKAGESDEBUG environment variable is set to true,
+	// but the logger is nil, default to log.Printf.
+	Logf func(format string, args ...interface{})
+
 	// Dir is the directory in which to run the build system's query tool
 	// that provides information about the packages.
 	// If Dir is empty, the tool is run in the current directory.
@@ -429,6 +435,17 @@ func newLoader(cfg *Config) *loader {
 	}
 	if cfg != nil {
 		ld.Config = *cfg
+		// If the user has provided a logger, use it.
+		ld.Config.Logf = cfg.Logf
+	}
+	if ld.Config.Logf == nil {
+		// If the GOPACKAGESDEBUG environment variable is set to true,
+		// but the user has not provided a logger, default to log.Printf.
+		if debug {
+			ld.Config.Logf = log.Printf
+		} else {
+			ld.Config.Logf = func(format string, args ...interface{}) {}
+		}
 	}
 	if ld.Config.Mode == 0 {
 		ld.Config.Mode = NeedName | NeedFiles | NeedCompiledGoFiles // Preserve zero behavior of Mode for backwards compatibility.
@@ -527,28 +544,32 @@ func (ld *loader) refine(roots []string, list ...*Package) ([]*Package, error) {
 		lpkg.color = grey
 		stack = append(stack, lpkg) // push
 		stubs := lpkg.Imports       // the structure form has only stubs with the ID in the Imports
-		lpkg.Imports = make(map[string]*Package, len(stubs))
-		for importPath, ipkg := range stubs {
-			var importErr error
-			imp := ld.pkgs[ipkg.ID]
-			if imp == nil {
-				// (includes package "C" when DisableCgo)
-				importErr = fmt.Errorf("missing package: %q", ipkg.ID)
-			} else if imp.color == grey {
-				importErr = fmt.Errorf("import cycle: %s", stack)
-			}
-			if importErr != nil {
-				if lpkg.importErrors == nil {
-					lpkg.importErrors = make(map[string]error)
+		// If NeedImports isn't set, the imports fields will all be zeroed out.
+		// If NeedDeps isn't also set we want to keep the stubs.
+		if ld.Mode&NeedImports != 0 && ld.Mode&NeedDeps != 0 {
+			lpkg.Imports = make(map[string]*Package, len(stubs))
+			for importPath, ipkg := range stubs {
+				var importErr error
+				imp := ld.pkgs[ipkg.ID]
+				if imp == nil {
+					// (includes package "C" when DisableCgo)
+					importErr = fmt.Errorf("missing package: %q", ipkg.ID)
+				} else if imp.color == grey {
+					importErr = fmt.Errorf("import cycle: %s", stack)
+				}
+				if importErr != nil {
+					if lpkg.importErrors == nil {
+						lpkg.importErrors = make(map[string]error)
+					}
+					lpkg.importErrors[importPath] = importErr
+					continue
 				}
-				lpkg.importErrors[importPath] = importErr
-				continue
-			}
 
-			if visit(imp) {
-				lpkg.needsrc = true
+				if visit(imp) {
+					lpkg.needsrc = true
+				}
+				lpkg.Imports[importPath] = imp.Package
 			}
-			lpkg.Imports[importPath] = imp.Package
 		}
 		if lpkg.needsrc {
 			srcPkgs = append(srcPkgs, lpkg)