diff --git a/vendor/cmd/go/internal/modfetch/coderepo.go b/vendor/cmd/go/internal/modfetch/coderepo.go
index 357fb68..daaea9f 100644
--- a/vendor/cmd/go/internal/modfetch/coderepo.go
+++ b/vendor/cmd/go/internal/modfetch/coderepo.go
@@ -140,7 +140,6 @@
 }
 
 func (r *codeRepo) convert(info *codehost.RevInfo, statVers string) (*RevInfo, error) {
-
 	info2 := &RevInfo{
 		Name:  info.Name,
 		Short: info.Short,
@@ -184,6 +183,17 @@
 		}
 	}
 
+	// Do not allow a successful stat of a pseudo-version for a subdirectory
+	// unless the subdirectory actually does have a go.mod.
+	if IsPseudoVersion(info2.Version) && r.codeDir != "" {
+		_, _, _, err := r.findDir(info2.Version)
+		if err != nil {
+			// TODO: It would be nice to return an error like "not a module".
+			// Right now we return "missing go.mod", which is a little confusing.
+			return nil, err
+		}
+	}
+
 	return info2, nil
 }
 
diff --git a/vendor/cmd/go/internal/modfetch/coderepo_test.go b/vendor/cmd/go/internal/modfetch/coderepo_test.go
index f8ad9e7..fcf849b 100644
--- a/vendor/cmd/go/internal/modfetch/coderepo_test.go
+++ b/vendor/cmd/go/internal/modfetch/coderepo_test.go
@@ -259,13 +259,10 @@
 	},
 	{
 		// package in subdirectory - github
-		path:     "github.com/rsc/quote/buggy",
-		rev:      "c4d4236f",
-		version:  "v0.0.0-20180214154420-c4d4236f9242",
-		name:     "c4d4236f92427c64bfbcf1cc3f8142ab18f30b22",
-		short:    "c4d4236f9242",
-		time:     time.Date(2018, 2, 14, 15, 44, 20, 0, time.UTC),
-		gomoderr: "missing go.mod",
+		// Because it's a package, Stat should fail entirely.
+		path: "github.com/rsc/quote/buggy",
+		rev:  "c4d4236f",
+		err:  "missing go.mod",
 	},
 	{
 		path:    "gopkg.in/yaml.v2",
@@ -600,6 +597,10 @@
 		version: "v0.0.0-20180219223237-a08abb797a67",
 	},
 	{
+		path: "github.com/rsc/vgotest1/subdir",
+		err:  "missing go.mod",
+	},
+	{
 		path:    "swtch.com/testmod",
 		version: "v1.1.1",
 	},
@@ -630,6 +631,9 @@
 				}
 				t.Fatalf("Latest(): %v", err)
 			}
+			if tt.err != "" {
+				t.Fatalf("Latest() = %v, want error %q", info.Version, tt.err)
+			}
 			if info.Version != tt.version {
 				t.Fatalf("Latest() = %v, want %v", info.Version, tt.version)
 			}
diff --git a/vendor/cmd/go/internal/modfetch/repo.go b/vendor/cmd/go/internal/modfetch/repo.go
index 48cb56b..5be9184 100644
--- a/vendor/cmd/go/internal/modfetch/repo.go
+++ b/vendor/cmd/go/internal/modfetch/repo.go
@@ -269,6 +269,8 @@
 		// source code and check that it actually contains code for the
 		// target import path. To do that efficiently we will need to move
 		// the unzipped code cache out of ../modload into this package.
+		// TODO(rsc): When this happens, look carefully at the use of
+		// modfetch.Import in modget.getQuery.
 		return r, info, nil
 	}
 
diff --git a/vendor/cmd/go/internal/modget/get.go b/vendor/cmd/go/internal/modget/get.go
index d2d7791..c394417 100644
--- a/vendor/cmd/go/internal/modget/get.go
+++ b/vendor/cmd/go/internal/modget/get.go
@@ -7,25 +7,33 @@
 
 import (
 	"cmd/go/internal/base"
+	"cmd/go/internal/cfg"
 	"cmd/go/internal/get"
 	"cmd/go/internal/load"
 	"cmd/go/internal/modfetch"
 	"cmd/go/internal/modload"
 	"cmd/go/internal/module"
 	"cmd/go/internal/mvs"
+	"cmd/go/internal/par"
+	"cmd/go/internal/search"
 	"cmd/go/internal/semver"
+	"cmd/go/internal/str"
 	"cmd/go/internal/work"
+	"fmt"
+	"os"
+	pathpkg "path"
+	"path/filepath"
 	"strings"
 )
 
 var CmdGet = &base.Command{
 	// Note: -d -m -u are listed explicitly because they are the most common get flags.
 	// Do not send CLs removing them because they're covered by [get flags].
-	UsageLine: "get [-d] [-m] [-p] [-u] [-v] [-insecure] [build flags] [packages]",
+	UsageLine: "get [-d] [-m] [-u] [-v] [-insecure] [build flags] [packages]",
 	Short:     "add dependencies to current module and install them",
 	Long: `
 Get resolves and adds dependencies to the current development module
-and then optionally downloads, builds, and installs them.
+and then builds and installs them.
 
 The first step is to resolve which dependencies to add. 
 
@@ -60,12 +68,12 @@
 those requirements by taking the maximum requested version.)
 
 The -u flag instructs get to update dependencies to use newer minor or
-point releases when available. Continuing the previous example,
+patch releases when available. Continuing the previous example,
 'go get -u A' will use the latest A with B v1.3.1 (not B v1.2.3).
 
-The -u=point flag instructs get to update dependencies to use newer
-point releases when available. Continuing the previous example,
-'go get -u=point A' will use the latest A with B v1.2.4 (not B v1.2.3).
+The -u=patch flag (not -u patch) instructs get to update dependencies
+to use newer patch releases when available. Continuing the previous example,
+'go get -u=patch A' will use the latest A with B v1.2.4 (not B v1.2.3).
 
 In general, adding a new dependency may require upgrading
 existing dependencies to keep a working build, and 'go get' does
@@ -73,24 +81,16 @@
 require downgrading other dependenceis, and 'go get' does
 this automatically as well.
 
-The second step is to download source code for dependencies.
-This step is usually skipped, deferring the download until the code
-is first needed by a build (at which point it is cached for future use),
-so that building one package in a module does not incur the cost of
-downloading dependencies for other packages in the module.
-
-The -d flag instructs get to download the source code for all added
-modules, including their dependencies, recursively, so that the first
-build that needs the code won't have to download it.
+The -m flag instructs get to stop here, after resolving, upgrading,
+and downgrading modules and updating go.mod. When using -m,
+each specified package path must be a module path as well,
+not the import path of a package below the module root.
 
 The -insecure flag permits fetching from repositories and resolving
 custom domains using insecure schemes such as HTTP. Use with caution.
 
-The -m flag instructs get to stop here, after resolving, adding, and
-possibly downloading the modules, without building and installing
-any named packages.
-
-The third and final step is to build and install the named packages.
+The second step is to download (if needed), build, and install
+the named packages.
 
 If an argument names a module but not a package (because there is no
 Go source code in the module's root directory), then the install step
@@ -103,20 +103,24 @@
 adds the latest golang.org/x/perf and then installs the commands in that
 latest version.
 
-If 'go get' has no package arguments, then it applies to the current
-development module: the -d flag downloads all dependencies of the
-current module, and the -u and -u=point flags update all dependencies
-of the current module. If there is a Go package in the current directory,
-the build and install step applies to that package.
+The -d flag instructs get to download the source code needed to build
+the named packages, including downloading necessary dependencies,
+but not to build and install them.
+
+With no package arguments, 'go get' applies to the main module,
+and to the Go package in the current directory, if any. In particular,
+'go get -u' and 'go get -u=patch' update all the dependencies of the
+main module. With no package arguments and also without -u,
+'go get' is not much more than 'go install', and 'go get -d' not much
+more than 'go list'.
 
 For more about modules, see 'go help modules'.
 
 For more about specifying packages, see 'go help packages'.
 
-This text describes the behavior of get using modules to manage
-source code and dependencies.
-If instead the go command is running in legacy GOPATH mode,
-the details of get's flags and effects change, as does 'go help get'.
+This text describes the behavior of get using modules to manage source
+code and dependencies. If instead the go command is running in GOPATH
+mode, the details of get's flags and effects change, as does 'go help get'.
 See 'go help modules' and 'go help gopath-get'.
 
 See also: go build, go install, go clean, go mod.
@@ -146,141 +150,459 @@
 	getFix = CmdGet.Flag.Bool("fix", false, "")
 	getM   = CmdGet.Flag.Bool("m", false, "")
 	getT   = CmdGet.Flag.Bool("t", false, "")
-
+	getU   upgradeFlag
 	// -insecure is get.Insecure
-	// -u is modload.GetU
 	// -v is cfg.BuildV
 )
 
+// upgradeFlag is a custom flag.Value for -u.
+type upgradeFlag string
+
+func (*upgradeFlag) IsBoolFlag() bool { return true } // allow -u
+
+func (v *upgradeFlag) Set(s string) error {
+	if s == "false" {
+		s = ""
+	}
+	*v = upgradeFlag(s)
+	return nil
+}
+
+func (v *upgradeFlag) String() string { return "" }
+
 func init() {
 	work.AddBuildFlags(CmdGet)
 	CmdGet.Run = runGet // break init loop
 	CmdGet.Flag.BoolVar(&get.Insecure, "insecure", get.Insecure, "")
-	CmdGet.Flag.BoolVar(&modload.GetU, "u", modload.GetU, "")
+	CmdGet.Flag.Var(&getU, "u", "")
+}
+
+type Pkg struct {
+	Arg  string
+	Path string
+	Vers string
 }
 
 func runGet(cmd *base.Command, args []string) {
-	if modload.GetU && len(args) > 0 {
-		base.Fatalf("go get: -u not supported with argument list")
+	switch getU {
+	case "", "patch", "true":
+		// ok
+	default:
+		base.Fatalf("go get: unknown upgrade flag -u=%s", getU)
 	}
-	if !modload.GetU && len(args) == 0 {
-		base.Fatalf("go get: need arguments or -u")
+	if *getF {
+		fmt.Fprintf(os.Stderr, "go get: -f flag is a no-op when using modules\n")
+	}
+	if *getFix {
+		fmt.Fprintf(os.Stderr, "go get: -fix flag is a no-op when using modules\n")
+	}
+	if *getT {
+		fmt.Fprintf(os.Stderr, "go get: -t flag is a no-op when using modules\n")
 	}
 
-	if modload.GetU {
-		modload.LoadBuildList()
-		return
+	if cfg.BuildGetmode == "vendor" {
+		base.Fatalf("go get: disabled by -getmode=vendor")
 	}
 
-	modload.Init()
-	modload.InitMod()
-	var upgrade []module.Version
-	var downgrade []module.Version
-	var newPkgs []string
-	for _, pkg := range args {
-		var path, vers string
-		/* OLD CODE
-		if n := strings.Count(pkg, "(") + strings.Count(pkg, ")"); n > 0 {
-			i := strings.Index(pkg, "(")
-			j := strings.Index(pkg, ")")
-			if n != 2 || i < 0 || j <= i+1 || j != len(pkg)-1 && pkg[j+1] != '/' {
-				base.Errorf("go get: invalid module version syntax: %s", pkg)
-				continue
-			}
-			path, vers = pkg[:i], pkg[i+1:j]
-			pkg = pkg[:i] + pkg[j+1:]
-		*/
-		if i := strings.Index(pkg, "@"); i >= 0 {
-			path, pkg, vers = pkg[:i], pkg[:i], pkg[i+1:]
-			if strings.Contains(vers, "@") {
-				base.Errorf("go get: invalid module version syntax: %s", pkg)
-				continue
-			}
-		} else {
-			path = pkg
-			vers = "latest"
-		}
-		if vers == "none" {
-			downgrade = append(downgrade, module.Version{Path: path, Version: ""})
-		} else {
-			info, err := modfetch.Query(path, vers, modload.Allowed)
-			if err != nil {
-				base.Errorf("go get %v: %v", pkg, err)
-				continue
-			}
-			upgrade = append(upgrade, module.Version{Path: path, Version: info.Version})
-			newPkgs = append(newPkgs, pkg)
-		}
-	}
-	args = newPkgs
-
-	// Upgrade.
-	var err error
-	list, err := mvs.Upgrade(modload.Target, modload.Reqs(), upgrade...)
-	if err != nil {
-		base.Fatalf("go get: %v", err)
-	}
-	modload.SetBuildList(list)
-
 	modload.LoadBuildList()
 
-	// Downgrade anything that went too far.
-	version := make(map[string]string)
-	for _, mod := range modload.BuildList() {
-		version[mod.Path] = mod.Version
-	}
-	for _, mod := range upgrade {
-		if semver.Compare(mod.Version, version[mod.Path]) < 0 {
-			downgrade = append(downgrade, mod)
-		}
+	// A task holds the state for processing a single get argument (path@vers).
+	type task struct {
+		arg             string           // original argument
+		path            string           // package path part of arg
+		forceModulePath bool             // path must be interpreted as a module path
+		vers            string           // version part of arg
+		m               module.Version   // module version indicated by argument
+		req             []module.Version // m's requirement list (not upgraded)
 	}
 
-	if len(downgrade) > 0 {
-		list, err := mvs.Downgrade(modload.Target, modload.Reqs(), downgrade...)
+	// Build task and install lists.
+	// The command-line arguments are of the form path@version
+	// or simply path, with implicit @latest. path@none is "downgrade away".
+	// At the end of the loop, we've resolved the list of arguments into
+	// a list of tasks (a path@vers that needs further processing)
+	// and a list of install targets (for the "go install" at the end).
+	var tasks []*task
+	var install []string
+	for _, arg := range search.CleanImportPaths(args) {
+		// Argument is module query path@vers, or else path with implicit @latest.
+		path := arg
+		vers := ""
+		if i := strings.Index(arg, "@"); i >= 0 {
+			path, vers = arg[:i], arg[i+1:]
+		}
+		if strings.Contains(vers, "@") || arg != path && vers == "" {
+			base.Errorf("go get %s: invalid module version syntax", arg)
+			continue
+		}
+		if vers != "none" {
+			install = append(install, path)
+		}
+
+		// Deciding which module to upgrade/downgrade for a particular argument is difficult.
+		// Patterns only make it more difficult.
+		// We impose restrictions to avoid needing to interlace pattern expansion,
+		// like in in modload.ImportPaths.
+		// Specifically, these patterns are supported:
+		//
+		//	- Relative paths like ../../foo or ../../foo... are restricted to matching directories
+		//	  in the current module and therefore map to the current module.
+		//	  It's possible that the pattern matches no packages, but we will still treat it
+		//	  as mapping to the current module.
+		//	  TODO: In followup, could just expand the full list and remove the discrepancy.
+		//	- The pattern "all" has its usual package meaning and maps to the list of modules
+		//	  from which the matched packages are drawn. This is potentially a subset of the
+		//	  module pattern "all". If module A requires B requires C but A does not import
+		//	  the parts of B that import C, the packages matched by "all" are only from A and B,
+		//	  so only A and B end up on the tasks list.
+		//	  TODO: Even in -m mode?
+		//	- The patterns "std" and "cmd" expand to packages in the standard library,
+		//	  which aren't upgradable, so we skip over those.
+		//	  In -m mode they expand to non-module-paths, so they are disallowed.
+		//	- Import path patterns like foo/bar... are matched against the module list,
+		//	  assuming any package match would imply a module pattern match.
+		//	  TODO: What about -m mode?
+		//	- Import paths without patterns are left as is, for resolution by getQuery (eventually modload.Import).
+		//
+		if search.IsRelativePath(path) {
+			// Check that this relative pattern only matches directories in the current module,
+			// and then record the current module as the target.
+			dir := path
+			if i := strings.Index(path, "..."); i >= 0 {
+				dir, _ = pathpkg.Split(path[:i])
+			}
+			abs, err := filepath.Abs(dir)
+			if err != nil {
+				base.Errorf("go get %s: %v", arg, err)
+				continue
+			}
+			if !str.HasFilePathPrefix(abs, modload.ModRoot) {
+				base.Errorf("go get %s: directory %s is outside module root %s", arg, abs, modload.ModRoot)
+				continue
+			}
+			// TODO: Check if abs is inside a nested module.
+			tasks = append(tasks, &task{arg: arg, path: modload.Target.Path, vers: ""})
+			continue
+		}
+		if path == "all" {
+			if path != arg {
+				base.Errorf("go get %s: cannot use pattern %q with explicit version", arg, arg)
+			}
+
+			// TODO: If *getM, should this be the module pattern "all"?
+
+			// This is the package pattern "all" not the module pattern "all":
+			// enumerate all the modules actually needed by builds of the packages
+			// in the main module, not incidental modules that happen to be
+			// in the package graph (and therefore build list).
+			// Note that LoadALL may add new modules to the build list to
+			// satisfy new imports, but vers == "latest" implicitly anyway,
+			// so we'll assume that's OK.
+			seen := make(map[module.Version]bool)
+			pkgs := modload.LoadALL()
+			for _, pkg := range pkgs {
+				m := modload.PackageModule(pkg)
+				if m.Path != "" && !seen[m] {
+					seen[m] = true
+					tasks = append(tasks, &task{arg: arg, path: m.Path, vers: "latest", forceModulePath: true})
+				}
+			}
+			continue
+		}
+		if search.IsMetaPackage(path) {
+			// Already handled "all", so this must be "std" or "cmd",
+			// which are entirely in the standard library.
+			if path != arg {
+				base.Errorf("go get %s: cannot use pattern %q with explicit version", arg, arg)
+			}
+			if *getM {
+				base.Errorf("go get %s: cannot use pattern %q with -m", arg, arg)
+				continue
+			}
+			continue
+		}
+		if strings.Contains(path, "...") {
+			// Apply to modules in build list matched by pattern (golang.org/x/...), if any.
+			match := search.MatchPattern(path)
+			matched := false
+			for _, m := range modload.BuildList() {
+				if match(m.Path) || str.HasPathPrefix(path, m.Path) {
+					tasks = append(tasks, &task{arg: arg, path: m.Path, vers: vers, forceModulePath: true})
+					matched = true
+				}
+			}
+			// If matched, we're done.
+			// Otherwise assume pattern is inside a single module
+			// (golang.org/x/text/unicode/...) and leave for usual lookup.
+			// Unless we're using -m.
+			if matched {
+				continue
+			}
+			if *getM {
+				base.Errorf("go get %s: pattern matches no modules in build list", arg)
+				continue
+			}
+		}
+		tasks = append(tasks, &task{arg: arg, path: path, vers: vers})
+	}
+	base.ExitIfErrors()
+
+	// Now we've reduced the upgrade/downgrade work to a list of path@vers pairs (tasks).
+	// Resolve each one and load direct requirements in parallel.
+	reqs := modload.Reqs()
+	var lookup par.Work
+	for _, t := range tasks {
+		lookup.Add(t)
+	}
+	lookup.Do(10, func(item interface{}) {
+		t := item.(*task)
+		m, err := getQuery(t.path, t.vers, t.forceModulePath)
+		if err != nil {
+			base.Errorf("go get %v: %v", t.arg, err)
+			return
+		}
+		t.m = m
+		if t.vers == "none" {
+			// Wait for downgrade step.
+			return
+		}
+		// If there is no -u, then we don't need to upgrade the
+		// collected requirements separately from the overall
+		// recalculation of the build list (modload.ReloadBuildList below),
+		// so don't bother doing it now. Doing it now wouldn't be
+		// any slower (because it would prime the cache for later)
+		// but the larger operation below can report more errors in a single run.
+		if getU != "" {
+			list, err := reqs.Required(m)
+			if err != nil {
+				base.Errorf("go get %v: %v", t.arg, err)
+				return
+			}
+			t.req = list
+		}
+	})
+	base.ExitIfErrors()
+
+	// Now we know the specific version of each path@vers along with its requirements.
+	// The final build list will be the union of three build lists:
+	//	1. the original build list
+	//	2. the modules named on the command line
+	//	3. the upgraded requirements of those modules (if upgrading)
+	// Start building those lists.
+	// This loop collects (2) and the not-yet-upgraded (3).
+	// Also, because the list of paths might have named multiple packages in a single module
+	// (or even the same package multiple times), now that we know the module for each
+	// package, this loop deduplicates multiple references to a given module.
+	// (If a module is mentioned multiple times, the listed target version must be the same each time.)
+	var named []module.Version
+	var required []module.Version
+	byPath := make(map[string]*task)
+	for _, t := range tasks {
+		prev, ok := byPath[t.m.Path]
+		if prev != nil && prev.m != t.m {
+			base.Errorf("go get: conflicting versions for module %s: %s and %s", t.m.Path, prev.m.Version, t.m.Version)
+			byPath[t.m.Path] = nil // sentinel to stop errors
+			continue
+		}
+		if ok {
+			continue // already added
+		}
+		byPath[t.m.Path] = t
+		named = append(named, t.m)
+		required = append(required, t.req...)
+	}
+	base.ExitIfErrors()
+
+	// If the modules named on the command line have any dependencies
+	// and we're supposed to upgrade dependencies,
+	// chase down the full list of upgraded dependencies.
+	// This turns required from a not-yet-upgraded (3) to the final (3).
+	// (See list above.)
+	if len(required) > 0 {
+		upgraded, err := mvs.UpgradeAll(upgradeTarget, &upgrader{
+			Reqs:    modload.Reqs(),
+			targets: required,
+			patch:   getU == "patch",
+		})
+		if err != nil {
+			base.Fatalf("go get: %v", err)
+		}
+		required = upgraded[1:] // slice off upgradeTarget
+	}
+
+	// Put together the final build list as described above (1) (2) (3).
+	// If we're not using -u, then len(required) == 0 and ReloadBuildList
+	// chases down the dependencies of all the named module versions
+	// in one operation.
+	var list []module.Version
+	list = append(list, modload.BuildList()...)
+	list = append(list, named...)
+	list = append(list, required...)
+	modload.SetBuildList(list)
+	modload.ReloadBuildList() // note: does not update go.mod
+
+	// Apply any needed downgrades.
+	var down []module.Version
+	for _, m := range modload.BuildList() {
+		t := byPath[m.Path]
+		if t != nil && semver.Compare(m.Version, t.m.Version) > 0 {
+			down = append(down, module.Version{Path: m.Path, Version: t.m.Version})
+		}
+	}
+	if len(down) > 0 {
+		list, err := mvs.Downgrade(modload.Target, modload.Reqs(), down...)
 		if err != nil {
 			base.Fatalf("go get: %v", err)
 		}
 		modload.SetBuildList(list)
-
-		// TODO: Check that everything we need to import is still available.
-		/*
-			local := v.matchPackages("all", v.Reqs[:1])
-			for _, path := range local {
-				dir, err := v.importDir(path)
-				if err != nil {
-					return err // TODO
-				}
-				imports, testImports, err := scanDir(dir, v.Tags)
-				for _, path := range imports {
-					xxx
-				}
-				for _, path := range testImports {
-					xxx
-				}
-			}
-		*/
+		modload.ReloadBuildList() // note: does not update go.mod
 	}
+
+	// Everything succeeded. Update go.mod.
 	modload.WriteGoMod()
 
-	if *getD {
-		// Download all needed code as side-effect.
-		modload.LoadALL()
-	}
-
+	// If -m was specified, we're done after the module work. No download, no build.
 	if *getM {
 		return
 	}
 
-	if len(args) > 0 {
+	if len(install) > 0 {
 		work.BuildInit()
-		var list []string
-		for _, p := range load.PackagesAndErrors(args) {
+		var pkgs []string
+		for _, p := range load.PackagesAndErrors(install) {
 			if p.Error == nil || !strings.HasPrefix(p.Error.Err, "no Go files") {
-				list = append(list, p.ImportPath)
+				pkgs = append(pkgs, p.ImportPath)
 			}
 		}
-		if len(list) > 0 {
-			work.InstallPackages(list)
+		// If -d was specified, we're done after the download: no build.
+		// (The load.PackagesAndErrors is what did the download
+		// of the named packages and their dependencies.)
+		if len(pkgs) > 0 && !*getD {
+			work.InstallPackages(pkgs)
 		}
 	}
 }
+
+// getQuery evaluates the given package path, version pair
+// to determine the underlying module version being requested.
+// If forceModulePath is set, getQuery must interpret path
+// as a module path.
+func getQuery(path, vers string, forceModulePath bool) (module.Version, error) {
+	if path == modload.Target.Path {
+		if vers != "" {
+			return module.Version{}, fmt.Errorf("cannot update main module to explicit version")
+		}
+		return modload.Target, nil
+	}
+
+	if vers == "" {
+		vers = "latest"
+	}
+
+	// First choice is always to assume path is a module path.
+	// If that works out, we're done.
+	info, err := modfetch.Query(path, vers, modload.Allowed)
+	if err == nil {
+		return module.Version{Path: path, Version: info.Version}, nil
+	}
+
+	// Even if the query fails, if the path is (or must be) a real module, then report the query error.
+	if forceModulePath || *getM || isModulePath(path) {
+		return module.Version{}, err
+	}
+
+	// Otherwise fall back to resolving package path as of today
+	// and applying the version to the resulting module.
+	// We could do more subtle things when older versions are
+	// specified, but this seems good enough and more predictable.
+	// If this behavior is wrong, the user can always specify the
+	// desired module path instead of a package path,
+	// and then the code above will handle it.
+	repo, info, err := modfetch.Import(path, modload.Allowed)
+	if err != nil {
+		return module.Version{}, err
+	}
+	if vers != "latest" {
+		// modfetch.Import returned "latest" version. Look up requested version.
+		if info, err = modfetch.Query(repo.ModulePath(), vers, modload.Allowed); err != nil {
+			return module.Version{}, err
+		}
+	}
+	return module.Version{Path: repo.ModulePath(), Version: info.Version}, nil
+}
+
+// isModulePath reports whether path names an actual module,
+// defined as one with an accessible latest version.
+func isModulePath(path string) bool {
+	_, err := modfetch.Query(path, "latest", modload.Allowed)
+	return err == nil
+}
+
+// An upgrader adapts an underlying mvs.Reqs to apply an
+// upgrade policy to a list of targets and their dependencies.
+// If patch=false, the upgrader implements "get -u".
+// If patch=true, the upgrader implements "get -u=patch".
+type upgrader struct {
+	mvs.Reqs
+	targets []module.Version
+	patch   bool
+}
+
+// upgradeTarget is a fake "target" requiring all the modules to be upgraded.
+var upgradeTarget = module.Version{Path: "upgrade target", Version: ""}
+
+// Required returns the requirement list for m.
+// Other than the upgradeTarget, we defer to u.Reqs.
+func (u *upgrader) Required(m module.Version) ([]module.Version, error) {
+	if m == upgradeTarget {
+		return u.targets, nil
+	}
+	return u.Reqs.Required(m)
+}
+
+// Upgrade returns the desired upgrade for m.
+// If m is a tagged version, then Upgrade returns the latest tagged version.
+// If m is a pseudo-version, then Upgrade returns the latest tagged version
+// when that version has a time-stamp newer than m.
+// Otherwise Upgrade returns m (preserving the pseudo-version).
+// This special case prevents accidental downgrades
+// when already using a pseudo-version newer than the latest tagged version.
+func (u *upgrader) Upgrade(m module.Version) (module.Version, error) {
+	// Note that query "latest" is not the same as
+	// using repo.Latest.
+	// The query only falls back to untagged versions
+	// if nothing is tagged. The Latest method
+	// only ever returns untagged versions,
+	// which is not what we want.
+	query := "latest"
+	if u.patch {
+		// For patch upgrade, query "v1.2".
+		query = semver.MajorMinor(m.Version)
+	}
+	info, err := modfetch.Query(m.Path, query, modload.Allowed)
+	if err != nil {
+		// Report error but return m, to let version selection continue.
+		// (Reporting the error will fail the command at the next base.ExitIfErrors.)
+		// Special case: if the error is "no matching versions" then don't
+		// even report the error. Because Query does not consider pseudo-versions,
+		// it may happen that we have a pseudo-version but during -u=patch
+		// the query v0.0 matches no versions (not even the one we're using).
+		if !strings.Contains(err.Error(), "no matching versions") {
+			base.Errorf("go get: upgrading %s@%s: %v", m.Path, m.Version, err)
+		}
+		return m, nil
+	}
+
+	// If we're on a later prerelease, keep using it,
+	// even though normally an Upgrade will ignore prereleases.
+	if semver.Compare(info.Version, m.Version) < 0 {
+		return m, nil
+	}
+
+	// If we're on a pseudo-version chronologically after the latest tagged version, keep using it.
+	// This avoids some accidental downgrades.
+	if mTime, err := modfetch.PseudoVersionTime(m.Version); err == nil && info.Time.Before(mTime) {
+		return m, nil
+	}
+	return module.Version{Path: m.Path, Version: info.Version}, nil
+}
diff --git a/vendor/cmd/go/internal/modload/init.go b/vendor/cmd/go/internal/modload/init.go
index fa98cbc..2b39a0e 100644
--- a/vendor/cmd/go/internal/modload/init.go
+++ b/vendor/cmd/go/internal/modload/init.go
@@ -7,6 +7,7 @@
 import (
 	"bytes"
 	"cmd/go/internal/base"
+	"cmd/go/internal/cache"
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/load"
 	"cmd/go/internal/modconv"
@@ -167,6 +168,12 @@
 		ModRoot = root
 	}
 
+	if c := cache.Default(); c == nil {
+		// With modules, there are no install locations for packages
+		// other than the build cache.
+		base.Fatalf("go: cannot use modules with build cache disabled")
+	}
+
 	enabled = true
 	load.ModBinDir = BinDir
 	load.ModLookup = Lookup
@@ -214,8 +221,9 @@
 
 	if CmdModInit {
 		// Running go mod -init: do legacy module conversion
-		// (go.mod does not exist yet).
+		// (go.mod does not exist yet, and it's not our job to write it).
 		legacyModInit()
+		modFileToBuildList()
 		return
 	}
 
@@ -224,6 +232,8 @@
 	if err != nil {
 		if os.IsNotExist(err) {
 			legacyModInit()
+			modFileToBuildList()
+			WriteGoMod()
 			return
 		}
 		base.Fatalf("go: %v", err)
@@ -255,10 +265,20 @@
 	for _, x := range f.Exclude {
 		excluded[x.Mod] = true
 	}
-	Target = f.Module.Mod
+	modFileToBuildList()
 	WriteGoMod()
 }
 
+// modFileToBuildList initializes buildList from the modFile.
+func modFileToBuildList() {
+	Target = modFile.Module.Mod
+	list := []module.Version{Target}
+	for _, r := range modFile.Require {
+		list = append(list, r.Mod)
+	}
+	buildList = list
+}
+
 // Allowed reports whether module m is allowed (not excluded) by the main module's go.mod.
 func Allowed(m module.Version) bool {
 	return !excluded[m]
@@ -275,7 +295,6 @@
 		modFile.AddModuleStmt(path)
 	}
 
-	Target = modFile.Module.Mod
 	for _, name := range altConfigs {
 		cfg := filepath.Join(ModRoot, name)
 		data, err := ioutil.ReadFile(cfg)
@@ -445,14 +464,14 @@
 func WriteGoMod() {
 	modfetch.WriteGoSum()
 
-	if buildList != nil {
+	if loaded != nil {
 		var direct []string
 		for _, m := range buildList[1:] {
 			if loaded.direct[m.Path] {
 				direct = append(direct, m.Path)
 			}
 		}
-		min, err := mvs.Req(Target, buildList, direct, newReqs(buildList))
+		min, err := mvs.Req(Target, buildList, direct, Reqs())
 		if err != nil {
 			base.Fatalf("go: %v", err)
 		}
diff --git a/vendor/cmd/go/internal/modload/load.go b/vendor/cmd/go/internal/modload/load.go
index f1c8b7b..8c1fac2 100644
--- a/vendor/cmd/go/internal/modload/load.go
+++ b/vendor/cmd/go/internal/modload/load.go
@@ -47,9 +47,6 @@
 // which should be used instead.
 var loaded *loader
 
-// get -u flag; TODO: remove.
-var GetU bool
-
 // ImportPaths returns the set of packages matching the args (patterns),
 // adding modules to the build list as needed to satisfy new imports.
 func ImportPaths(args []string) []string {
@@ -105,7 +102,7 @@
 
 			case strings.Contains(pkg, "..."):
 				// TODO: Don't we need to reevaluate this one last time once the build list stops changing?
-				list := warnPattern(pkg, matchPackages(pkg, loaded.tags, loaded.buildList))
+				list := warnPattern(pkg, matchPackages(pkg, loaded.tags, buildList))
 				roots = append(roots, list...)
 				paths = append(paths, list...)
 
@@ -184,9 +181,14 @@
 		base.Fatalf("go: LoadBuildList called but modules not enabled")
 	}
 	InitMod()
+	ReloadBuildList()
+	WriteGoMod()
+	return buildList
+}
+
+func ReloadBuildList() []module.Version {
 	loaded = newLoader()
 	loaded.load(func() []string { return nil })
-	WriteGoMod()
 	return buildList
 }
 
@@ -245,14 +247,16 @@
 // BuildList returns the module build list,
 // typically constructed by a previous call to
 // LoadBuildList or ImportPaths.
+// The caller must not modify the returned list.
 func BuildList() []module.Version {
 	return buildList
 }
 
 // SetBuildList sets the module build list.
 // The caller is responsible for ensuring that the list is valid.
+// SetBuildList does not retain a reference to the original list.
 func SetBuildList(list []module.Version) {
-	buildList = list
+	buildList = append([]module.Version{}, list...)
 }
 
 // ImportMap returns the actual package import path
@@ -330,9 +334,6 @@
 	missingMu sync.Mutex
 	found     map[string]bool
 
-	// updated on each iteration
-	buildList []module.Version
-
 	// reset on each iteration
 	roots    []*loadPkg
 	pkgs     []*loadPkg
@@ -384,12 +385,7 @@
 // which must call add(path) with the import path of each root package.
 func (ld *loader) load(roots func() []string) {
 	var err error
-	mvsOp := mvs.BuildList
-	if GetU {
-		mvsOp = mvs.UpgradeAll
-	}
-	ld.buildList = buildList
-	ld.buildList, err = mvsOp(Target, newReqs(ld.buildList))
+	buildList, err = mvs.BuildList(Target, Reqs())
 	if err != nil {
 		base.Fatalf("go: %v", err)
 	}
@@ -422,7 +418,7 @@
 		ld.missing.Do(10, ld.findMissing)
 		base.ExitIfErrors()
 
-		ld.buildList, err = mvsOp(Target, newReqs(ld.buildList))
+		buildList, err = mvs.BuildList(Target, Reqs())
 		if err != nil {
 			base.Fatalf("go: %v", err)
 		}
@@ -451,9 +447,6 @@
 			}
 		}
 	}
-
-	buildList = ld.buildList
-	ld.buildList = nil // catch accidental use
 }
 
 // pkg returns the *loadPkg for path, creating and queuing it if needed.
@@ -594,7 +587,7 @@
 	// (See comment about module paths in modfetch/repo.go.)
 	var mod1 module.Version
 	var dir1 string
-	for _, mod := range ld.buildList {
+	for _, mod := range buildList {
 		if !importPathInModule(path, mod.Path) {
 			continue
 		}
@@ -627,7 +620,7 @@
 	// TODO: This is wrong (if path = foo/v2/bar and m.Path is foo,
 	// maybe we should fall through to the loop at the bottom and check foo/v2).
 	ld.missingMu.Lock()
-	for _, m := range ld.buildList {
+	for _, m := range buildList {
 		if importPathInModule(path, m.Path) {
 			ld.missingMu.Unlock()
 			return
@@ -648,7 +641,7 @@
 	defer ld.missingMu.Unlock()
 
 	// Double-check before adding repo twice.
-	for _, m := range ld.buildList {
+	for _, m := range buildList {
 		if importPathInModule(path, m.Path) {
 			return
 		}
@@ -661,7 +654,7 @@
 	}
 	ld.found[path] = true
 	fmt.Fprintf(os.Stderr, "go: adding %s %s\n", root, info.Version)
-	ld.buildList = append(ld.buildList, module.Version{Path: root, Version: info.Version})
+	buildList = append(buildList, module.Version{Path: root, Version: info.Version})
 	modFile.AddRequire(root, info.Version)
 }
 
@@ -775,23 +768,19 @@
 // with any exclusions or replacements applied internally.
 type mvsReqs struct {
 	buildList []module.Version
-	extra     []module.Version
 	cache     par.Cache
 }
 
-func newReqs(buildList []module.Version, extra ...module.Version) *mvsReqs {
+// Reqs returns the current module requirement graph.
+// Future calls to SetBuildList do not affect the operation
+// of the returned Reqs.
+func Reqs() mvs.Reqs {
 	r := &mvsReqs{
 		buildList: buildList,
-		extra:     extra,
 	}
 	return r
 }
 
-// Reqs returns the module requirement graph.
-func Reqs() mvs.Reqs {
-	return newReqs(buildList)
-}
-
 func (r *mvsReqs) Required(mod module.Version) ([]module.Version, error) {
 	type cached struct {
 		list []module.Version
@@ -826,14 +815,7 @@
 func (r *mvsReqs) required(mod module.Version) ([]module.Version, error) {
 	if mod == Target {
 		var list []module.Version
-		if r.buildList != nil {
-			list = append(list, r.buildList[1:]...)
-			return list, nil
-		}
-		for _, r := range modFile.Require {
-			list = append(list, r.Mod)
-		}
-		list = append(list, r.extra...)
+		list = append(list, r.buildList[1:]...)
 		return list, nil
 	}
 
@@ -910,38 +892,10 @@
 	return v1
 }
 
-// Upgrade returns the desired upgrade for m.
-// If m is a tagged version, then Upgrade returns the latest tagged version.
-// If m is a pseudo-version, then Upgrade returns the latest tagged version
-// when that version has a time-stamp newer than m.
-// Otherwise Upgrade returns m (preserving the pseudo-version).
-// This special case prevents accidental downgrades
-// when already using a pseudo-version newer than the latest tagged version.
+// Upgrade is a no-op, here to implement mvs.Reqs.
+// The upgrade logic for go get -u is in ../modget/get.go.
 func (*mvsReqs) Upgrade(m module.Version) (module.Version, error) {
-	// Note that query "latest" is not the same as
-	// using repo.Latest.
-	// The query only falls back to untagged versions
-	// if nothing is tagged. The Latest method
-	// only ever returns untagged versions,
-	// which is not what we want.
-	fmt.Fprintf(os.Stderr, "go: finding %s latest\n", m.Path)
-	info, err := modfetch.Query(m.Path, "latest", Allowed)
-	if err != nil {
-		return module.Version{}, err
-	}
-
-	// If we're on a later prerelease, keep using it,
-	// even though normally an Upgrade will ignore prereleases.
-	if semver.Compare(info.Version, m.Version) < 0 {
-		return m, nil
-	}
-
-	// If we're on a pseudo-version chronologically after the latest tagged version, keep using it.
-	// This avoids accidental downgrades.
-	if mTime, err := modfetch.PseudoVersionTime(m.Version); err == nil && info.Time.Before(mTime) {
-		return m, nil
-	}
-	return module.Version{Path: m.Path, Version: info.Version}, nil
+	return m, nil
 }
 
 func versions(path string) ([]string, error) {
diff --git a/vendor/cmd/go/internal/semver/semver.go b/vendor/cmd/go/internal/semver/semver.go
index 42760f7..4af7118 100644
--- a/vendor/cmd/go/internal/semver/semver.go
+++ b/vendor/cmd/go/internal/semver/semver.go
@@ -69,6 +69,21 @@
 	return v[:1+len(pv.major)]
 }
 
+// MajorMinor returns the major.minor version prefix of the semantic version v.
+// For example, MajorMinor("v2.1.0") == "v2.1".
+// If v is an invalid semantic version string, MajorMinor returns the empty string.
+func MajorMinor(v string) string {
+	pv, ok := parse(v)
+	if !ok {
+		return ""
+	}
+	i := 1 + len(pv.major)
+	if j := i + 1 + len(pv.minor); j <= len(v) && v[i] == '.' && v[i+1:j] == pv.minor {
+		return v[:j]
+	}
+	return v[:i] + "." + pv.minor
+}
+
 // Prerelease returns the prerelease suffix of the semantic version v.
 // For example, Prerelease("v2.1.0-pre+meta") == "-pre".
 // If v is an invalid semantic version string, Prerelease returns the empty string.
diff --git a/vendor/cmd/go/internal/semver/semver_test.go b/vendor/cmd/go/internal/semver/semver_test.go
index 6c9a735..96b64a5 100644
--- a/vendor/cmd/go/internal/semver/semver_test.go
+++ b/vendor/cmd/go/internal/semver/semver_test.go
@@ -14,6 +14,7 @@
 	out string
 }{
 	{"bad", ""},
+	{"v1-alpha.beta.gamma", ""},
 	{"v1-pre", ""},
 	{"v1+meta", ""},
 	{"v1-pre+meta", ""},
@@ -76,6 +77,33 @@
 	}
 }
 
+func TestMajorMinor(t *testing.T) {
+	for _, tt := range tests {
+		out := MajorMinor(tt.in)
+		var want string
+		if tt.out != "" {
+			want = tt.in
+			if i := strings.Index(want, "+"); i >= 0 {
+				want = want[:i]
+			}
+			if i := strings.Index(want, "-"); i >= 0 {
+				want = want[:i]
+			}
+			switch strings.Count(want, ".") {
+			case 0:
+				want += ".0"
+			case 1:
+				// ok
+			case 2:
+				want = want[:strings.LastIndex(want, ".")]
+			}
+		}
+		if out != want {
+			t.Errorf("MajorMinor(%q) = %q, want %q", tt.in, out, want)
+		}
+	}
+}
+
 func TestPrerelease(t *testing.T) {
 	for _, tt := range tests {
 		pre := Prerelease(tt.in)
diff --git a/vendor/cmd/go/internal/str/path.go b/vendor/cmd/go/internal/str/path.go
index 84ca9d5..65cd639 100644
--- a/vendor/cmd/go/internal/str/path.go
+++ b/vendor/cmd/go/internal/str/path.go
@@ -9,8 +9,25 @@
 	"strings"
 )
 
-// HasFilePathPrefix reports whether the filesystem path s begins with the
-// elements in prefix.
+// HasPath reports whether the slash-separated path s
+// begins with the elements in prefix.
+func HasPathPrefix(s, prefix string) bool {
+	if len(s) == len(prefix) {
+		return s == prefix
+	}
+	if prefix == "" {
+		return true
+	}
+	if len(s) > len(prefix) {
+		if prefix != "" && prefix[len(prefix)-1] == '/' || s[len(prefix)] == '/' {
+			return s[:len(prefix)] == prefix
+		}
+	}
+	return false
+}
+
+// HasFilePathPrefix reports whether the filesystem path s
+// begins with the elements in prefix.
 func HasFilePathPrefix(s, prefix string) bool {
 	sv := strings.ToUpper(filepath.VolumeName(s))
 	pv := strings.ToUpper(filepath.VolumeName(prefix))
@@ -23,8 +40,10 @@
 		return false
 	case len(s) == len(prefix):
 		return s == prefix
+	case prefix == "":
+		return true
 	case len(s) > len(prefix):
-		if prefix != "" && prefix[len(prefix)-1] == filepath.Separator {
+		if prefix[len(prefix)-1] == filepath.Separator {
 			return strings.HasPrefix(s, prefix)
 		}
 		return s[len(prefix)] == filepath.Separator && s[:len(prefix)] == prefix
diff --git a/vendor/cmd/go/internal/work/action.go b/vendor/cmd/go/internal/work/action.go
index 8edf55f..8ce68be 100644
--- a/vendor/cmd/go/internal/work/action.go
+++ b/vendor/cmd/go/internal/work/action.go
@@ -327,8 +327,8 @@
 // depMode is the action (build or install) to use when building dependencies.
 // To turn package main into an executable, call b.Link instead.
 func (b *Builder) CompileAction(mode, depMode BuildMode, p *load.Package) *Action {
-	if mode != ModeBuild && p.Internal.Local && p.Target == "" {
-		// Imported via local path. No permanent target.
+	if mode != ModeBuild && (p.Internal.Local || p.Module != nil) && p.Target == "" {
+		// Imported via local path or using modules. No permanent target.
 		mode = ModeBuild
 	}
 	if mode != ModeBuild && p.Name == "main" {
diff --git a/vendor/cmd/go/internal/work/build.go b/vendor/cmd/go/internal/work/build.go
index d0b13da..d52998f 100644
--- a/vendor/cmd/go/internal/work/build.go
+++ b/vendor/cmd/go/internal/work/build.go
@@ -459,10 +459,18 @@
 	}
 
 	pkgs := omitTestOnly(pkgsFilter(load.PackagesForBuild(args)))
-
 	for _, p := range pkgs {
-		if p.Target == "" && (!p.Standard || p.ImportPath != "unsafe") {
+		if p.Target == "" {
 			switch {
+			case p.Standard && p.ImportPath == "unsafe":
+				// unsafe is a built-in package, has no target
+			case p.Name != "main" && p.Internal.Local && p.ConflictDir == "":
+				// Non-executables outside GOPATH need not have a target:
+				// we can use the cache to hold the built package archive for use in future builds.
+				// The ones inside GOPATH should have a target (in GOPATH/pkg)
+				// or else something is wrong and worth reporting (like a ConflictDir).
+			case p.Name != "main" && p.Module != nil:
+				// Non-executables have no target (except the cache) when building with modules.
 			case p.Internal.GobinSubdir:
 				base.Errorf("go %s: cannot install cross-compiled binaries when GOBIN is set", cfg.CmdName)
 			case p.Internal.CmdlineFiles:
diff --git a/vendor/cmd/go/mod_test.go b/vendor/cmd/go/mod_test.go
index 565bbb2..d5e63ec 100644
--- a/vendor/cmd/go/mod_test.go
+++ b/vendor/cmd/go/mod_test.go
@@ -449,22 +449,21 @@
 	// Now there should be no build at all.
 	tg.run("get", "-m", "golang.org/x/crypto@7f39a6fea4fe9364")
 
-	// TODO(rsc): These should work, but "go get" needs more work
-	// regarding packages versus modules.
-
-	// @7f39a6fea4fe9364 should resolve.
-	// Now there should be no build at all.
-	// tg.run("get", "-m", "-x", "golang.org/x/crypto/pbkdf2@7f39a6fea4fe9364")
-	// tg.grepStderrNot("compile", "should not see compile steps")
-
-	// @7f39a6fea4fe9364 should resolve.
-	// Now there should be a build
-	// tg.run("get", "-x", "golang.org/x/crypto/pbkdf2@7f39a6fea4fe9364")
-	// tg.grepStderr("compile", "should see compile steps")
-
-	// .../pbkdf2@7f39a6fea4fe9364 should NOT resolve:
-	// we are using -m and .../pbkdf2 is not a module path.
+	// pbkdf2@7f39a6fea4fe9364 should not resolve with -m,
+	// because .../pbkdf2 is not a module path.
 	tg.runFail("get", "-m", "golang.org/x/crypto/pbkdf2@7f39a6fea4fe9364")
+
+	// pbkdf2@7f39a6fea4fe9364 should resolve without -m.
+	// Because of -d, there should be no build at all.
+	tg.run("get", "-d", "-x", "golang.org/x/crypto/pbkdf2@7f39a6fea4fe9364")
+	tg.grepStderrNot("compile", "should not see compile steps")
+
+	// Dropping -d, we should see a build now.
+	tg.run("get", "-x", "golang.org/x/crypto/pbkdf2@7f39a6fea4fe9364")
+	tg.grepStderr("compile", "should see compile steps")
+
+	// Even with -d, we should see an error for unknown packages.
+	tg.runFail("get", "-x", "golang.org/x/crypto/nonexist@7f39a6fea4fe9364")
 }
 
 func TestModGetUpgrade(t *testing.T) {
@@ -589,6 +588,31 @@
 
 	tg.run("list", "-m", "-e", "-f={{.Error.Err}}", "rsc.io/quote@>v1.5.3")
 	tg.grepStdout(`no matching versions for query ">v1.5.3"`, "expected no matching version")
+
+	tg.must(ioutil.WriteFile(tg.path("x/go.mod"), []byte(`
+		module x
+		require rsc.io/quote v1.4.0
+	`), 0666))
+
+	tg.run("list", "-m", "all")
+	tg.grepStdout(`rsc.io/sampler v1.0.0`, "expected sampler v1.0.0")
+
+	tg.run("get", "-m", "-u=patch", "rsc.io/quote")
+	tg.run("list", "-m", "all")
+	tg.grepStdout(`rsc.io/quote v1.5.2`, "expected quote v1.5.2")                // rsc.io/quote gets implicit @latest (not -u=patch)
+	tg.grepStdout(`rsc.io/sampler v1.3.1`, "expected sampler v1.3.1")            // even though v1.5.2 requires v1.3.0
+	tg.grepStdout(`golang.org/x/text v0.0.0-`, "expected x/text pseudo-version") // can't jump from v0.0.0- to v0.3.0
+
+	tg.run("get", "-m", "-u=patch", "rsc.io/quote@v1.2.0")
+	tg.run("list", "-m", "all")
+	tg.grepStdout(`rsc.io/quote v1.2.0`, "expected quote v1.2.0")           // not v1.2.1: -u=patch applies to deps of args, not args
+	tg.grepStdout(`rsc.io/sampler v1.3.1`, "expected sampler line to stay") // even though v1.2.0 does not require sampler?
+
+	tg.run("get", "-m", "-u=patch")
+	tg.run("list", "-m", "all")
+	tg.grepStdout(`rsc.io/quote v1.2.1`, "expected quote v1.2.1") // -u=patch with no args applies to deps of main module
+	tg.grepStdout(`rsc.io/sampler v1.3.1`, "expected sampler line to stay")
+	tg.grepStdout(`golang.org/x/text v0.0.0-`, "expected x/text pseudo-version") // even though x/text v0.3.0 is tagged
 }
 
 func TestModBadDomain(t *testing.T) {