diff --git a/vendor/cmd/go/internal/modcmd/verify.go b/vendor/cmd/go/internal/modcmd/verify.go
index 60a9871..e965ac9 100644
--- a/vendor/cmd/go/internal/modcmd/verify.go
+++ b/vendor/cmd/go/internal/modcmd/verify.go
@@ -29,9 +29,9 @@
 
 func verifyMod(mod module.Version) bool {
 	ok := true
-	zip := filepath.Join(vgo.SrcV, "cache", mod.Path, "/@v/", mod.Version+".zip")
+	zip := filepath.Join(vgo.SrcMod, "cache", mod.Path, "/@v/", mod.Version+".zip")
 	_, zipErr := os.Stat(zip)
-	dir := filepath.Join(vgo.SrcV, mod.Path+"@"+mod.Version)
+	dir := filepath.Join(vgo.SrcMod, mod.Path+"@"+mod.Version)
 	_, dirErr := os.Stat(dir)
 	data, err := ioutil.ReadFile(zip + "hash")
 	if err != nil {
diff --git a/vendor/cmd/go/internal/modfetch/cache.go b/vendor/cmd/go/internal/modfetch/cache.go
index c90602f..cc7a34b 100644
--- a/vendor/cmd/go/internal/modfetch/cache.go
+++ b/vendor/cmd/go/internal/modfetch/cache.go
@@ -5,11 +5,24 @@
 package modfetch
 
 import (
-	"sync"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
 
+	"cmd/go/internal/modconv"
+	"cmd/go/internal/modfetch/codehost"
 	"cmd/go/internal/par"
+	"cmd/go/internal/semver"
 )
 
+var QuietLookup bool // do not print about lookups
+
+var CacheRoot string // $GOPATH/src/mod/cache
+
 // A cachingRepo is a cache around an underlying Repo,
 // avoiding redundant calls to ModulePath, Versions, Stat, Latest, and GoMod (but not Zip).
 // It is also safe for simultaneous use by multiple goroutines
@@ -18,9 +31,7 @@
 type cachingRepo struct {
 	path  string
 	cache par.Cache // cache for all operations
-
-	mu sync.Mutex // protects r's methods
-	r  Repo
+	r     Repo
 }
 
 func newCachingRepo(r Repo) *cachingRepo {
@@ -40,8 +51,6 @@
 		err  error
 	}
 	c := r.cache.Do("versions:"+prefix, func() interface{} {
-		r.mu.Lock()
-		defer r.mu.Unlock()
 		list, err := r.r.Versions(prefix)
 		return cached{list, err}
 	}).(cached)
@@ -52,17 +61,36 @@
 	return append([]string(nil), c.list...), nil
 }
 
+type cachedInfo struct {
+	info *RevInfo
+	err  error
+}
+
 func (r *cachingRepo) Stat(rev string) (*RevInfo, error) {
-	type cached struct {
-		info *RevInfo
-		err  error
-	}
 	c := r.cache.Do("stat:"+rev, func() interface{} {
-		r.mu.Lock()
-		defer r.mu.Unlock()
-		info, err := r.r.Stat(rev)
-		return cached{info, err}
-	}).(cached)
+		file, info, err := readDiskStat(r.path, rev)
+		if err == nil {
+			return cachedInfo{info, nil}
+		}
+
+		if !QuietLookup {
+			fmt.Fprintf(os.Stderr, "vgo: finding %s %s\n", r.path, rev)
+		}
+		info, err = r.r.Stat(rev)
+		if err == nil {
+			if err := writeDiskStat(file, info); err != nil {
+				fmt.Fprintf(os.Stderr, "go: writing stat cache: %v\n", err)
+			}
+			// If we resolved, say, 1234abcde to v0.0.0-20180604122334-1234abcdef78,
+			// then save the information under the proper version, for future use.
+			if info.Version != rev {
+				r.cache.Do("stat:"+info.Version, func() interface{} {
+					return cachedInfo{info, err}
+				})
+			}
+		}
+		return cachedInfo{info, err}
+	}).(cachedInfo)
 
 	if c.err != nil {
 		return nil, c.err
@@ -72,16 +100,28 @@
 }
 
 func (r *cachingRepo) Latest() (*RevInfo, error) {
-	type cached struct {
+	type cachedInfo struct {
 		info *RevInfo
 		err  error
 	}
 	c := r.cache.Do("latest:", func() interface{} {
-		r.mu.Lock()
-		defer r.mu.Unlock()
+		if !QuietLookup {
+			fmt.Fprintf(os.Stderr, "vgo: finding %s latest\n", r.path)
+		}
 		info, err := r.r.Latest()
-		return cached{info, err}
-	}).(cached)
+
+		// Save info for likely future Stat call.
+		if err == nil {
+			r.cache.Do("stat:"+info.Version, func() interface{} {
+				return cachedInfo{info, err}
+			})
+			if file, _, err := readDiskStat(r.path, info.Version); err != nil {
+				writeDiskStat(file, info)
+			}
+		}
+
+		return cachedInfo{info, err}
+	}).(cachedInfo)
 
 	if c.err != nil {
 		return nil, c.err
@@ -96,9 +136,17 @@
 		err  error
 	}
 	c := r.cache.Do("gomod:"+rev, func() interface{} {
-		r.mu.Lock()
-		defer r.mu.Unlock()
-		text, err := r.r.GoMod(rev)
+		file, text, err := readDiskGoMod(r.path, rev)
+		if err == nil {
+			return cached{text, nil}
+		}
+
+		text, err = r.r.GoMod(rev)
+		if err == nil {
+			if err := writeDiskGoMod(file, text); err != nil {
+				fmt.Fprintf(os.Stderr, "go: writing go.mod cache: %v\n", err)
+			}
+		}
 		return cached{text, err}
 	}).(cached)
 
@@ -109,7 +157,186 @@
 }
 
 func (r *cachingRepo) Zip(version, tmpdir string) (string, error) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
 	return r.r.Zip(version, tmpdir)
 }
+
+// Stat is like Lookup(path).Stat(rev) but avoids the
+// repository path resolution in Lookup if the result is
+// already cached on local disk.
+func Stat(path, rev string) (*RevInfo, error) {
+	_, info, err := readDiskStat(path, rev)
+	if err == nil {
+		return info, nil
+	}
+	repo, err := Lookup(path)
+	if err != nil {
+		return nil, err
+	}
+	return repo.Stat(rev)
+}
+
+// GoMod is like Lookup(path).GoMod(rev) but avoids the
+// repository path resolution in Lookup if the result is
+// already cached on local disk.
+func GoMod(path, rev string) ([]byte, error) {
+	// Convert commit hash to pseudo-version
+	// to increase cache hit rate.
+	if !semver.IsValid(rev) {
+		info, err := Stat(path, rev)
+		if err != nil {
+			return nil, err
+		}
+		rev = info.Version
+	}
+	_, data, err := readDiskGoMod(path, rev)
+	if err == nil {
+		return data, nil
+	}
+	repo, err := Lookup(path)
+	if err != nil {
+		return nil, err
+	}
+	return repo.GoMod(rev)
+}
+
+var errNotCached = fmt.Errorf("not in cache")
+
+// readDiskStat reads a cached stat result from disk,
+// returning the name of the cache file and the result.
+// If the read fails, the caller can use
+// writeDiskStat(file, info) to write a new cache entry.
+func readDiskStat(path, rev string) (file string, info *RevInfo, err error) {
+	file, data, err := readDiskCache(path, rev, "info")
+	if err != nil {
+		if file, info, err := readDiskStatByHash(path, rev); err == nil {
+			return file, info, nil
+		}
+		return file, nil, err
+	}
+	info = new(RevInfo)
+	if err := json.Unmarshal(data, info); err != nil {
+		return file, nil, errNotCached
+	}
+	return file, info, nil
+}
+
+// readDiskStatByHash is a fallback for readDiskStat for the case
+// where rev is a commit hash instead of a proper semantic version.
+// In that case, we look for a cached pseudo-version that matches
+// the commit hash. If we find one, we use it.
+// This matters most for converting legacy package management
+// configs, when we are often looking up commits by full hash.
+// Without this check we'd be doing network I/O to the remote repo
+// just to find out about a commit we already know about
+// (and have cached under its pseudo-version).
+func readDiskStatByHash(path, rev string) (file string, info *RevInfo, err error) {
+	if !codehost.AllHex(rev) || len(rev) < 12 {
+		return "", nil, errNotCached
+	}
+	rev = rev[:12]
+	dir, err := os.Open(filepath.Join(CacheRoot, path, "@v"))
+	if err != nil {
+		return "", nil, errNotCached
+	}
+	names, err := dir.Readdirnames(-1)
+	dir.Close()
+	if err != nil {
+		return "", nil, errNotCached
+	}
+	suffix := "-" + rev + ".info"
+	for _, name := range names {
+		if strings.HasSuffix(name, suffix) && isPseudoVersion(strings.TrimSuffix(name, ".info")) {
+			return readDiskStat(path, strings.TrimSuffix(name, ".info"))
+		}
+	}
+	return "", nil, errNotCached
+}
+
+var vgoVersion = []byte(modconv.Prefix)
+
+// readDiskGoMod reads a cached stat result from disk,
+// returning the name of the cache file and the result.
+// If the read fails, the caller can use
+// writeDiskGoMod(file, data) to write a new cache entry.
+func readDiskGoMod(path, rev string) (file string, data []byte, err error) {
+	file, data, err = readDiskCache(path, rev, "mod")
+
+	// If go.mod has a //vgo comment at the start,
+	// it was auto-converted from a legacy lock file.
+	// The auto-conversion details may have bugs and
+	// may be fixed in newer versions of vgo.
+	// We ignore cached go.mod files if they do not match
+	// our own vgoVersion.
+	// This use of "vgo" appears in disk files and must be preserved
+	// even once we excise most of the mentions of vgo from the code.
+	if err == nil && bytes.HasPrefix(data, vgoVersion[:len("//vgo")]) && !bytes.HasPrefix(data, vgoVersion) {
+		err = errNotCached
+		data = nil
+	}
+
+	return file, data, err
+}
+
+// readDiskCache is the generic "read from a cache file" implementation.
+// It takes the revision and an identifying suffix for the kind of data being cached.
+// It returns the name of the cache file and the content of the file.
+// If the read fails, the caller can use
+// writeDiskCache(file, data) to write a new cache entry.
+func readDiskCache(path, rev, suffix string) (file string, data []byte, err error) {
+	if !semver.IsValid(rev) || CacheRoot == "" {
+		return "", nil, errNotCached
+	}
+	file = filepath.Join(CacheRoot, path, "@v", rev+"."+suffix)
+	data, err = ioutil.ReadFile(file)
+	if err != nil {
+		return file, nil, errNotCached
+	}
+	return file, data, nil
+}
+
+// writeDiskStat writes a stat result cache entry.
+// The file name must have been returned by a previous call to readDiskStat.
+func writeDiskStat(file string, info *RevInfo) error {
+	if file == "" {
+		return nil
+	}
+	js, err := json.Marshal(info)
+	if err != nil {
+		return err
+	}
+	return writeDiskCache(file, js)
+}
+
+// writeDiskGoMod writes a go.mod cache entry.
+// The file name must have been returned by a previous call to readDiskGoMod.
+func writeDiskGoMod(file string, text []byte) error {
+	return writeDiskCache(file, text)
+}
+
+// writeDiskCache is the generic "write to a cache file" implementation.
+// The file must have been returned by a previous call to readDiskCache.
+func writeDiskCache(file string, data []byte) error {
+	if file == "" {
+		return nil
+	}
+	// Make sure directory for file exists.
+	if err := os.MkdirAll(filepath.Dir(file), 0777); err != nil {
+		return err
+	}
+	// Write data to temp file next to target file.
+	f, err := ioutil.TempFile(filepath.Dir(file), filepath.Base(file)+".tmp*")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+	defer f.Close()
+	if _, err := f.Write(data); err != nil {
+		return err
+	}
+	if err := f.Close(); err != nil {
+		return err
+	}
+	// Rename temp file onto cache file,
+	// so that the cache file is always a complete file.
+	return os.Rename(f.Name(), file)
+}
diff --git a/vendor/cmd/go/internal/modfetch/coderepo.go b/vendor/cmd/go/internal/modfetch/coderepo.go
index c208fb2..bd815e1 100644
--- a/vendor/cmd/go/internal/modfetch/coderepo.go
+++ b/vendor/cmd/go/internal/modfetch/coderepo.go
@@ -15,6 +15,7 @@
 	"path/filepath"
 	"regexp"
 	"strings"
+	"sync"
 	"time"
 
 	"cmd/go/internal/modconv"
@@ -26,10 +27,12 @@
 
 // A codeRepo implements modfetch.Repo using an underlying codehost.Repo.
 type codeRepo struct {
-	modPath  string
+	modPath string
+
 	code     codehost.Repo
 	codeRoot string
 	codeDir  string
+	codeMu   sync.Mutex // protects code methods
 
 	path        string
 	pathPrefix  string
@@ -95,7 +98,9 @@
 	if r.codeDir != "" {
 		p = r.codeDir + "/" + p
 	}
+	r.codeMu.Lock()
 	tags, err := r.code.Tags(p)
+	r.codeMu.Unlock()
 	if err != nil {
 		return nil, err
 	}
@@ -125,7 +130,9 @@
 	if semver.IsValid(codeRev) && r.codeDir != "" {
 		codeRev = r.codeDir + "/" + codeRev
 	}
+	r.codeMu.Lock()
 	info, err := r.code.Stat(codeRev)
+	r.codeMu.Unlock()
 	if err != nil {
 		return nil, err
 	}
@@ -133,7 +140,9 @@
 }
 
 func (r *codeRepo) Latest() (*RevInfo, error) {
+	r.codeMu.Lock()
 	info, err := r.code.Latest()
+	r.codeMu.Unlock()
 	if err != nil {
 		return nil, err
 	}
@@ -199,7 +208,9 @@
 			return rev, "", nil, nil
 		}
 		file1 := path.Join(r.codeDir, "go.mod")
+		r.codeMu.Lock()
 		gomod1, err1 := r.code.ReadFile(rev, file1, codehost.MaxGoMod)
+		r.codeMu.Unlock()
 		if err1 != nil {
 			return "", "", nil, fmt.Errorf("missing go.mod")
 		}
@@ -215,8 +226,10 @@
 	// a replace directive.
 	file1 := path.Join(r.codeDir, "go.mod")
 	file2 := path.Join(r.codeDir, r.pathMajor[1:], "go.mod")
+	r.codeMu.Lock()
 	gomod1, err1 := r.code.ReadFile(rev, file1, codehost.MaxGoMod)
 	gomod2, err2 := r.code.ReadFile(rev, file2, codehost.MaxGoMod)
+	r.codeMu.Unlock()
 	found1 := err1 == nil && isMajor(gomod1, r.pathMajor)
 	found2 := err2 == nil && isMajor(gomod2, r.pathMajor)
 
@@ -247,7 +260,9 @@
 	if gomod != nil {
 		return gomod, nil
 	}
+	r.codeMu.Lock()
 	data, err = r.code.ReadFile(rev, path.Join(dir, "go.mod"), codehost.MaxGoMod)
+	r.codeMu.Unlock()
 	if err != nil {
 		if e := strings.ToLower(err.Error()); strings.Contains(e, "not found") || strings.Contains(e, "404") { // TODO
 			return r.legacyGoMod(rev, dir), nil
@@ -274,7 +289,9 @@
 	mf := new(modfile.File)
 	mf.AddModuleStmt(r.modPath)
 	for _, file := range altConfigs {
+		r.codeMu.Lock()
 		data, err := r.code.ReadFile(rev, path.Join(dir, file), codehost.MaxGoMod)
+		r.codeMu.Unlock()
 		if err != nil {
 			continue
 		}
@@ -303,7 +320,9 @@
 	if err != nil {
 		return "", err
 	}
+	r.codeMu.Lock()
 	dl, actualDir, err := r.code.ReadZip(rev, dir, codehost.MaxZipFile)
+	r.codeMu.Unlock()
 	if err != nil {
 		return "", err
 	}
@@ -441,7 +460,10 @@
 	}
 
 	if !haveLICENSE && subdir != "" {
-		if data, err := r.code.ReadFile(rev, "LICENSE", codehost.MaxLICENSE); err == nil {
+		r.codeMu.Lock()
+		data, err := r.code.ReadFile(rev, "LICENSE", codehost.MaxLICENSE)
+		r.codeMu.Unlock()
+		if err == nil {
 			w, err := zw.Create(r.modPrefix(version) + "/LICENSE")
 			if err != nil {
 				return "", err
diff --git a/vendor/cmd/go/internal/modfetch/convert.go b/vendor/cmd/go/internal/modfetch/convert.go
index 5c482be..9e15116 100644
--- a/vendor/cmd/go/internal/modfetch/convert.go
+++ b/vendor/cmd/go/internal/modfetch/convert.go
@@ -9,9 +9,12 @@
 	"os"
 	"sort"
 	"strings"
+	"sync"
 
 	"cmd/go/internal/modconv"
 	"cmd/go/internal/modfile"
+	"cmd/go/internal/module"
+	"cmd/go/internal/par"
 	"cmd/go/internal/semver"
 )
 
@@ -37,7 +40,7 @@
 
 	// Convert requirements block, which may use raw SHA1 hashes as versions,
 	// to valid semver requirement list, respecting major versions.
-	need := make(map[string]string)
+	var work par.Work
 	for _, r := range require {
 		if r.Path == "" {
 			continue
@@ -50,20 +53,24 @@
 				r.Path = strings.Join(f[:3], "/")
 			}
 		}
+		work.Add(r)
+	}
 
-		repo, err := Lookup(r.Path)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "vgo: lookup %s: %v\n", r.Path, err)
-			continue
-		}
-		info, err := repo.Stat(r.Version)
+	var (
+		mu   sync.Mutex
+		need = make(map[string]string)
+	)
+	work.Do(10, func(item interface{}) {
+		r := item.(module.Version)
+		info, err := Stat(r.Path, r.Version)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "vgo: stat %s@%s: %v\n", r.Path, r.Version, err)
-			continue
+			return
 		}
-		path := repo.ModulePath()
-		need[path] = semver.Max(need[path], info.Version)
-	}
+		mu.Lock()
+		need[r.Path] = semver.Max(need[r.Path], info.Version)
+		mu.Unlock()
+	})
 
 	var paths []string
 	for path := range need {
@@ -71,7 +78,7 @@
 	}
 	sort.Strings(paths)
 	for _, path := range paths {
-		f.AddRequire(path, need[path])
+		f.AddNewRequire(path, need[path])
 	}
 
 	return nil
diff --git a/vendor/cmd/go/internal/modfetch/gitrepo/fetch.go b/vendor/cmd/go/internal/modfetch/gitrepo/fetch.go
index 0d6eb4b..532d3f3 100644
--- a/vendor/cmd/go/internal/modfetch/gitrepo/fetch.go
+++ b/vendor/cmd/go/internal/modfetch/gitrepo/fetch.go
@@ -94,12 +94,35 @@
 	refsOnce sync.Once
 	refs     map[string]string
 	refsErr  error
+
+	localTagsOnce sync.Once
+	localTags     map[string]bool
 }
 
 func (r *repo) Root() string {
 	return r.root
 }
 
+// loadLocalTags loads tag references from the local git cache
+// into the map r.localTags.
+// Should only be called as r.localTagsOnce.Do(r.loadLocalTags).
+func (r *repo) loadLocalTags() {
+	// The git protocol sends all known refs and ls-remote filters them on the client side,
+	// so we might as well record both heads and tags in one shot.
+	// Most of the time we only care about tags but sometimes we care about heads too.
+	out, err := codehost.Run(r.dir, "git", "tag", "-l")
+	if err != nil {
+		return
+	}
+
+	r.localTags = make(map[string]bool)
+	for _, line := range strings.Split(string(out), "\n") {
+		if line != "" {
+			r.localTags[line] = true
+		}
+	}
+}
+
 // loadRefs loads heads and tags references from the remote into the map r.refs.
 // Should only be called as r.refsOnce.Do(r.loadRefs).
 func (r *repo) loadRefs() {
@@ -190,11 +213,38 @@
 // (most do not, but maybe that will change), to let us minimize
 // the amount of code downloaded.
 func (r *repo) statOrArchive(rev string, archiveArgs ...string) (info *codehost.RevInfo, archive []byte, err error) {
-	// Do we have this rev?
+	var (
+		hash      string
+		tag       string
+		out       []byte
+		triedHash string
+	)
+
+	// Maybe rev is a hash we already have locally.
+	if len(rev) >= 12 && codehost.AllHex(rev) {
+		out, err = codehost.Run(r.dir, "git", "log", "-n1", "--format=format:%H", rev)
+		if err == nil {
+			hash = strings.TrimSpace(string(out))
+			goto Found
+		}
+		triedHash = rev
+	}
+
+	// Maybe rev is a tag we already have locally.
+	r.localTagsOnce.Do(r.loadLocalTags)
+	if r.localTags["refs/tags/"+rev] {
+		out, err = codehost.Run(r.dir, "git", "log", "-n1", "--format=format:%H", "refs/tags/"+rev)
+		if err == nil {
+			hash = strings.TrimSpace(string(out))
+			goto Found
+		}
+	}
+
+	// Maybe rev is a ref from the server.
 	r.refsOnce.Do(r.loadRefs)
-	var hash string
 	if k := "refs/tags/" + rev; r.refs[k] != "" {
 		hash = r.refs[k]
+		tag = k
 	} else if k := "refs/heads/" + rev; r.refs[k] != "" {
 		hash = r.refs[k]
 		rev = hash
@@ -207,10 +257,12 @@
 		return nil, nil, fmt.Errorf("unknown revision %q", rev)
 	}
 
-	out, err := codehost.Run(r.dir, "git", "log", "-n1", "--format=format:%H", hash)
-	if err == nil {
-		hash = strings.TrimSpace(string(out))
-		goto Found
+	if hash != triedHash {
+		out, err = codehost.Run(r.dir, "git", "log", "-n1", "--format=format:%H", hash)
+		if err == nil {
+			hash = strings.TrimSpace(string(out))
+			goto Found
+		}
 	}
 
 	// We don't have the rev. Can we fetch it?
@@ -265,7 +317,12 @@
 		if ref, ok := r.findRef(hash); ok {
 			name = ref
 		}
-		if _, err = codehost.Run(r.dir, "git", "fetch", "--depth=1", r.remote, name); err == nil {
+		if tag != "" {
+			_, err = codehost.Run(r.dir, "git", "fetch", "--depth=1", r.remote, tag+":"+tag)
+		} else {
+			_, err = codehost.Run(r.dir, "git", "fetch", "--depth=1", r.remote, name)
+		}
+		if err == nil {
 			goto Found
 		}
 		if !strings.Contains(err.Error(), "unadvertised object") && !strings.Contains(err.Error(), "no such remote ref") && !strings.Contains(err.Error(), "does not support shallow") {
diff --git a/vendor/cmd/go/internal/modfetch/query.go b/vendor/cmd/go/internal/modfetch/query.go
index 5e9d86c..5587890 100644
--- a/vendor/cmd/go/internal/modfetch/query.go
+++ b/vendor/cmd/go/internal/modfetch/query.go
@@ -28,11 +28,6 @@
 // result to revisions on a particular branch name.
 //
 func Query(path, vers string, allowed func(module.Version) bool) (*RevInfo, error) {
-	repo, err := Lookup(path)
-	if err != nil {
-		return nil, err
-	}
-
 	if strings.HasPrefix(vers, "v") && semver.IsValid(vers) {
 		// TODO: This turns query for "v2" into Stat "v2.0.0",
 		// but probably it should allow checking for a branch named "v2".
@@ -40,6 +35,21 @@
 		if allowed != nil && !allowed(module.Version{Path: path, Version: vers}) {
 			return nil, fmt.Errorf("%s@%s excluded", path, vers)
 		}
+
+		// Fast path that avoids network overhead of Lookup (resolving path to repo host),
+		// if we already have this stat information cached on disk.
+		info, err := Stat(path, vers)
+		if err == nil {
+			return info, nil
+		}
+	}
+
+	repo, err := Lookup(path)
+	if err != nil {
+		return nil, err
+	}
+
+	if semver.IsValid(vers) {
 		return repo.Stat(vers)
 	}
 	if strings.HasPrefix(vers, ">") || strings.HasPrefix(vers, "<") || vers == "latest" {
diff --git a/vendor/cmd/go/internal/modfetch/repo.go b/vendor/cmd/go/internal/modfetch/repo.go
index 83b2262..072bbbc 100644
--- a/vendor/cmd/go/internal/modfetch/repo.go
+++ b/vendor/cmd/go/internal/modfetch/repo.go
@@ -26,6 +26,7 @@
 const traceRepo = false // trace all repo actions, for debugging
 
 // A Repo represents a repository storing all versions of a single module.
+// It must be safe for simultaneous use by multiple goroutines.
 type Repo interface {
 	// ModulePath returns the module path.
 	ModulePath() string
diff --git a/vendor/cmd/go/internal/vgo/fetch.go b/vendor/cmd/go/internal/vgo/fetch.go
index fba60dc..7b91908 100644
--- a/vendor/cmd/go/internal/vgo/fetch.go
+++ b/vendor/cmd/go/internal/vgo/fetch.go
@@ -38,16 +38,16 @@
 	}
 
 	modpath := mod.Path + "@" + mod.Version
-	dir = filepath.Join(SrcV, modpath)
+	dir = filepath.Join(SrcMod, modpath)
 	if files, _ := ioutil.ReadDir(dir); len(files) == 0 {
-		zipfile := filepath.Join(SrcV, "cache", mod.Path, "@v", mod.Version+".zip")
+		zipfile := filepath.Join(SrcMod, "cache", mod.Path, "@v", mod.Version+".zip")
 		if _, err := os.Stat(zipfile); err == nil {
 			// Use it.
 			// This should only happen if the v/cache directory is preinitialized
 			// or if src/v/modpath was removed but not src/v/cache.
 			fmt.Fprintf(os.Stderr, "vgo: extracting %s %s\n", mod.Path, mod.Version)
 		} else {
-			if err := os.MkdirAll(filepath.Join(SrcV, "cache", mod.Path, "@v"), 0777); err != nil {
+			if err := os.MkdirAll(filepath.Join(SrcMod, "cache", mod.Path, "@v"), 0777); err != nil {
 				return "", err
 			}
 			fmt.Fprintf(os.Stderr, "vgo: downloading %s %s\n", mod.Path, mod.Version)
@@ -159,7 +159,7 @@
 		return
 	}
 
-	data, err := ioutil.ReadFile(filepath.Join(SrcV, "cache", mod.Path, "@v", mod.Version+".ziphash"))
+	data, err := ioutil.ReadFile(filepath.Join(SrcMod, "cache", mod.Path, "@v", mod.Version+".ziphash"))
 	if err != nil {
 		base.Fatalf("vgo: verifying %s %s: %v", mod.Path, mod.Version, err)
 	}
@@ -183,7 +183,7 @@
 }
 
 func findModHash(mod module.Version) string {
-	data, err := ioutil.ReadFile(filepath.Join(SrcV, "cache", mod.Path, "@v", mod.Version+".ziphash"))
+	data, err := ioutil.ReadFile(filepath.Join(SrcMod, "cache", mod.Path, "@v", mod.Version+".ziphash"))
 	if err != nil {
 		return ""
 	}
diff --git a/vendor/cmd/go/internal/vgo/init.go b/vendor/cmd/go/internal/vgo/init.go
index 5af38cc..ba8122f 100644
--- a/vendor/cmd/go/internal/vgo/init.go
+++ b/vendor/cmd/go/internal/vgo/init.go
@@ -40,7 +40,7 @@
 	Target   module.Version
 
 	gopath string
-	SrcV   string // GOPATH/src/v directory where versioned cache lives
+	SrcMod string // GOPATH/src/v directory where versioned cache lives
 
 	CmdModInit   bool   // go mod -init flag
 	CmdModModule string // go mod -module flag
@@ -170,8 +170,17 @@
 	if _, err := os.Stat(filepath.Join(gopath, "go.mod")); err == nil {
 		base.Fatalf("$GOPATH/go.mod exists but should not")
 	}
-	SrcV = filepath.Join(list[0], "src/v")
-	codehost.WorkRoot = filepath.Join(SrcV, "cache/vcswork")
+
+	srcV := filepath.Join(list[0], "src/v")
+	SrcMod = filepath.Join(list[0], "src/mod")
+	infoV, errV := os.Stat(srcV)
+	_, errMod := os.Stat(SrcMod)
+	if errV == nil && infoV.IsDir() && errMod != nil && os.IsNotExist(errMod) {
+		os.Rename(srcV, SrcMod)
+	}
+
+	modfetch.CacheRoot = filepath.Join(SrcMod, "cache")
+	codehost.WorkRoot = filepath.Join(SrcMod, "cache/vcswork")
 
 	if CmdModInit {
 		// Running go mod -init: do legacy module conversion
diff --git a/vendor/cmd/go/internal/vgo/list.go b/vendor/cmd/go/internal/vgo/list.go
index d3511c1..e56aae5 100644
--- a/vendor/cmd/go/internal/vgo/list.go
+++ b/vendor/cmd/go/internal/vgo/list.go
@@ -80,7 +80,7 @@
 	}
 	InitMod()
 
-	quietLookup = true // do not chatter in v.Lookup
+	modfetch.QuietLookup = true // do not chatter in v.Lookup
 	iterate(func(*loader) {})
 
 	var rows [][]string
diff --git a/vendor/cmd/go/internal/vgo/load.go b/vendor/cmd/go/internal/vgo/load.go
index 0f69bf0..de89526 100644
--- a/vendor/cmd/go/internal/vgo/load.go
+++ b/vendor/cmd/go/internal/vgo/load.go
@@ -6,7 +6,6 @@
 
 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
 	"go/build"
 	"io/ioutil"
@@ -501,71 +500,16 @@
 		// TODO: return nil, fmt.Errorf("invalid semantic version %q", mod.Version)
 	}
 
-	gomod := filepath.Join(SrcV, "cache", mod.Path, "@v", mod.Version+".mod")
-	infofile := filepath.Join(SrcV, "cache", mod.Path, "@v", mod.Version+".info")
-	var f *modfile.File
-	if data, err := ioutil.ReadFile(gomod); err == nil {
-		// If go.mod has a //vgo comment at the start,
-		// it was auto-converted from a legacy lock file.
-		// The auto-conversion details may have bugs and
-		// may be fixed in newer versions of vgo.
-		// We ignore cached go.mod files if they do not match
-		// our own vgoVersion.
-		if !bytes.HasPrefix(data, vgoVersion[:len("//vgo")]) || bytes.HasPrefix(data, vgoVersion) {
-			f, err := modfile.Parse(gomod, data, nil)
-			if err != nil {
-				return nil, err
-			}
-			var list []module.Version
-			for _, r := range f.Require {
-				list = append(list, r.Mod)
-			}
-			return list, nil
-		}
-		f, err = modfile.Parse("go.mod", data, nil)
-		if err != nil {
-			return nil, fmt.Errorf("parsing downloaded go.mod: %v", err)
-		}
-	} else {
-		if !quietLookup {
-			fmt.Fprintf(os.Stderr, "vgo: finding %s %s\n", mod.Path, mod.Version)
-		}
-		repo, err := modfetch.Lookup(mod.Path)
-		if err != nil {
-			base.Errorf("vgo: %s: %v\n", mod.Path, err)
-			return nil, err
-		}
-		info, err := repo.Stat(mod.Version)
-		if err != nil {
-			base.Errorf("vgo: %s %s: %v\n", mod.Path, mod.Version, err)
-			return nil, err
-		}
-		data, err := repo.GoMod(info.Version)
-		if err != nil {
-			base.Errorf("vgo: %s %s: %v\n", mod.Path, mod.Version, err)
-			return nil, err
-		}
-
-		f, err = modfile.Parse("go.mod", data, nil)
-		if err != nil {
-			return nil, fmt.Errorf("parsing downloaded go.mod: %v", err)
-		}
-
-		dir := filepath.Dir(gomod)
-		if err := os.MkdirAll(dir, 0777); err != nil {
-			return nil, fmt.Errorf("caching go.mod: %v", err)
-		}
-		js, err := json.Marshal(info)
-		if err != nil {
-			return nil, fmt.Errorf("internal error: json failure: %v", err)
-		}
-		if err := ioutil.WriteFile(infofile, js, 0666); err != nil {
-			return nil, fmt.Errorf("caching info: %v", err)
-		}
-		if err := ioutil.WriteFile(gomod, data, 0666); err != nil {
-			return nil, fmt.Errorf("caching go.mod: %v", err)
-		}
+	data, err := modfetch.GoMod(mod.Path, mod.Version)
+	if err != nil {
+		base.Errorf("vgo: %s %s: %v\n", mod.Path, mod.Version, err)
+		return nil, err
 	}
+	f, err := modfile.Parse("go.mod", data, nil)
+	if err != nil {
+		return nil, fmt.Errorf("parsing downloaded go.mod: %v", err)
+	}
+
 	if mpath := f.Module.Mod.Path; mpath != origPath && mpath != mod.Path {
 		return nil, fmt.Errorf("downloaded %q and got module %q", mod.Path, mpath)
 	}
@@ -583,8 +527,6 @@
 	return list, nil
 }
 
-var quietLookup bool
-
 func (*mvsReqs) Max(v1, v2 string) string {
 	if semver.Compare(v1, v2) == -1 {
 		return v2