diff --git a/vendor/cmd/go/internal/cfg/cfg.go b/vendor/cmd/go/internal/cfg/cfg.go
index af86b96..f4817b8 100644
--- a/vendor/cmd/go/internal/cfg/cfg.go
+++ b/vendor/cmd/go/internal/cfg/cfg.go
@@ -108,7 +108,7 @@
 func objabi() (GOARM, GO386, GOMIPS, GOMIPS64 string) {
 	data, err := ioutil.ReadFile(filepath.Join(GOROOT, "src/cmd/internal/objabi/zbootstrap.go"))
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "vgo objabi: %v\n", err)
+		fmt.Fprintf(os.Stderr, "go objabi: %v\n", err)
 	}
 
 	find := func(key string) string {
@@ -120,7 +120,7 @@
 			if key == "GOMIPS64" { // new in Go 1.11
 				return ""
 			}
-			fmt.Fprintf(os.Stderr, "vgo objabi: cannot find %s\n", key)
+			fmt.Fprintf(os.Stderr, "go objabi: cannot find %s\n", key)
 			os.Exit(2)
 		}
 		line := data[i:]
@@ -134,7 +134,7 @@
 func compilers() (CC, CXX string) {
 	data, err := ioutil.ReadFile(filepath.Join(GOROOT, "src/cmd/go/internal/cfg/zdefaultcc.go"))
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "vgo compilers: %v\n", err)
+		fmt.Fprintf(os.Stderr, "go compilers: %v\n", err)
 	}
 
 	find := func(key string) string {
@@ -143,12 +143,12 @@
 		}
 		fi := bytes.Index(data, []byte("Default"+key+"(goos, goarch string)"))
 		if fi < 0 {
-			fmt.Fprintf(os.Stderr, "vgo compilers: cannot find %s\n", key)
+			fmt.Fprintf(os.Stderr, "go compilers: cannot find %s\n", key)
 			os.Exit(2)
 		}
 		i := bytes.Index(data[fi:], []byte("\treturn "))
 		if i < 0 {
-			fmt.Fprintf(os.Stderr, "vgo compilers: cannot find %s\n", key)
+			fmt.Fprintf(os.Stderr, "go compilers: cannot find %s\n", key)
 			os.Exit(2)
 		}
 		line := data[fi+i:]
@@ -164,7 +164,7 @@
 	_, err := os.Stat(filepath.Join(goroot, "api/go1.10.txt"))
 	if err != nil {
 		log.SetFlags(0)
-		log.Fatalf("vgo requires Go 1.10 but VGOROOT=%s is not a Go 1.10 source tree", goroot)
+		log.Fatalf("go requires Go 1.10 but VGOROOT=%s is not a Go 1.10 source tree", goroot)
 	}
 	return goroot
 }
diff --git a/vendor/cmd/go/internal/fix/fix.go b/vendor/cmd/go/internal/fix/fix.go
index 8de746c..1f51d77 100644
--- a/vendor/cmd/go/internal/fix/fix.go
+++ b/vendor/cmd/go/internal/fix/fix.go
@@ -36,7 +36,7 @@
 	for _, pkg := range load.Packages(args) {
 		if modload.Enabled() && !pkg.Module.Main {
 			if !printed {
-				fmt.Fprintf(os.Stderr, "vgo: not fixing packages in dependency modules\n")
+				fmt.Fprintf(os.Stderr, "go: not fixing packages in dependency modules\n")
 				printed = true
 			}
 			continue
diff --git a/vendor/cmd/go/internal/fmtcmd/fmt.go b/vendor/cmd/go/internal/fmtcmd/fmt.go
index 800169e..ae158a7 100644
--- a/vendor/cmd/go/internal/fmtcmd/fmt.go
+++ b/vendor/cmd/go/internal/fmtcmd/fmt.go
@@ -62,7 +62,7 @@
 	for _, pkg := range load.PackagesAndErrors(args) {
 		if modload.Enabled() && !pkg.Module.Main {
 			if !printed {
-				fmt.Fprintf(os.Stderr, "vgo: not formatting packages in dependency modules\n")
+				fmt.Fprintf(os.Stderr, "go: not formatting packages in dependency modules\n")
 				printed = true
 			}
 			continue
diff --git a/vendor/cmd/go/internal/generate/generate.go b/vendor/cmd/go/internal/generate/generate.go
index 130cefd..d9ff83f 100644
--- a/vendor/cmd/go/internal/generate/generate.go
+++ b/vendor/cmd/go/internal/generate/generate.go
@@ -157,7 +157,7 @@
 	for _, pkg := range load.Packages(args) {
 		if modload.Enabled() && !pkg.Module.Main {
 			if !printed {
-				fmt.Fprintf(os.Stderr, "vgo: not generating in packages in dependency modules\n")
+				fmt.Fprintf(os.Stderr, "go: not generating in packages in dependency modules\n")
 				printed = true
 			}
 			continue
diff --git a/vendor/cmd/go/internal/get/get.go b/vendor/cmd/go/internal/get/get.go
index 8ab96fb..43aade2 100644
--- a/vendor/cmd/go/internal/get/get.go
+++ b/vendor/cmd/go/internal/get/get.go
@@ -114,9 +114,9 @@
 }
 
 func runGet(cmd *base.Command, args []string) {
-	if load.VgoLookup != nil {
-		// Should not happen: main.go should install the separate vgo-enabled get code.
-		base.Fatalf("go get: vgo not implemented")
+	if load.ModLookup != nil {
+		// Should not happen: main.go should install the separate module-enabled get code.
+		base.Fatalf("go get: modules not implemented")
 	}
 
 	work.BuildInit()
diff --git a/vendor/cmd/go/internal/load/pkg.go b/vendor/cmd/go/internal/load/pkg.go
index 0a8eae6..b57b273 100644
--- a/vendor/cmd/go/internal/load/pkg.go
+++ b/vendor/cmd/go/internal/load/pkg.go
@@ -28,14 +28,14 @@
 )
 
 var (
-	// module (vgo) hooks; nil if vgo is disabled
-	VgoBinDir            func() string                                                   // return effective bin directory
-	VgoLookup            func(parentPath, path string) (dir, realPath string, err error) // lookup effective meaning of import
-	VgoPackageModuleInfo func(path string) *modinfo.ModulePublic                         // return module info for Package struct
-	VgoImportPaths       func(args []string) []string                                    // expand import paths
-	VgoPackageBuildInfo  func(main string, deps []string) string                         // return module info to embed in binary
-	VgoModInfoProg       func(info string) []byte                                        // wrap module info in .go code for binary
-	VgoImportFromFiles   func([]string)                                                  // update go.mod to add modules for imports in these files
+	// module hooks; nil if module use is disabled
+	ModBinDir            func() string                                                   // return effective bin directory
+	ModLookup            func(parentPath, path string) (dir, realPath string, err error) // lookup effective meaning of import
+	ModPackageModuleInfo func(path string) *modinfo.ModulePublic                         // return module info for Package struct
+	ModImportPaths       func(args []string) []string                                    // expand import paths
+	ModPackageBuildInfo  func(main string, deps []string) string                         // return module info to embed in binary
+	ModInfoProg          func(info string) []byte                                        // wrap module info in .go code for binary
+	ModImportFromFiles   func([]string)                                                  // update go.mod to add modules for imports in these files
 )
 
 var IgnoreImports bool // control whether we ignore imports in packages
@@ -450,18 +450,18 @@
 	importPath := path
 	origPath := path
 	isLocal := build.IsLocalImport(path)
-	var vgoDir string
-	var vgoErr error
+	var modDir string
+	var modErr error
 	if isLocal {
 		importPath = dirToImportPath(filepath.Join(srcDir, path))
-	} else if VgoLookup != nil {
+	} else if ModLookup != nil {
 		parentPath := ""
 		if parent != nil {
 			parentPath = parent.ImportPath
 		}
 		var p string
-		vgoDir, p, vgoErr = VgoLookup(parentPath, path)
-		if vgoErr == nil {
+		modDir, p, modErr = ModLookup(parentPath, path)
+		if modErr == nil {
 			importPath = p
 		}
 	} else if mode&ResolveImport != 0 {
@@ -490,11 +490,11 @@
 		// in order to return partial information.
 		var bp *build.Package
 		var err error
-		if vgoDir != "" {
-			bp, err = cfg.BuildContext.ImportDir(vgoDir, 0)
-		} else if vgoErr != nil {
+		if modDir != "" {
+			bp, err = cfg.BuildContext.ImportDir(modDir, 0)
+		} else if modErr != nil {
 			bp = new(build.Package)
-			err = fmt.Errorf("unknown import path %q: %v", importPath, vgoErr)
+			err = fmt.Errorf("unknown import path %q: %v", importPath, modErr)
 		} else {
 			buildMode := build.ImportComment
 			if mode&ResolveImport == 0 || path != origPath {
@@ -506,10 +506,10 @@
 		bp.ImportPath = importPath
 		if cfg.GOBIN != "" {
 			bp.BinDir = cfg.GOBIN
-		} else if VgoBinDir != nil {
-			bp.BinDir = VgoBinDir()
+		} else if ModBinDir != nil {
+			bp.BinDir = ModBinDir()
 		}
-		if vgoDir == "" && err == nil && !isLocal && bp.ImportComment != "" && bp.ImportComment != path &&
+		if modDir == "" && err == nil && !isLocal && bp.ImportComment != "" && bp.ImportComment != path &&
 			!strings.Contains(path, "/vendor/") && !strings.HasPrefix(path, "vendor/") {
 			err = fmt.Errorf("code in directory %s expects import %q", bp.Dir, bp.ImportComment)
 		}
@@ -518,7 +518,7 @@
 			p = setErrorPos(p, importPos)
 		}
 
-		if vgoDir == "" && origPath != cleanImport(origPath) {
+		if modDir == "" && origPath != cleanImport(origPath) {
 			p.Error = &PackageError{
 				ImportStack: stk.Copy(),
 				Err:         fmt.Sprintf("non-canonical import path: %q should be %q", origPath, pathpkg.Clean(origPath)),
@@ -594,14 +594,14 @@
 // There are two different resolutions applied.
 // First, there is Go 1.5 vendoring (golang.org/s/go15vendor).
 // If vendor expansion doesn't trigger, then the path is also subject to
-// Go 1.11 vgo legacy conversion (golang.org/issue/25069).
+// Go 1.11 module legacy conversion (golang.org/issue/25069).
 func ResolveImportPath(parent *Package, path string) (found string) {
-	if VgoLookup != nil {
+	if ModLookup != nil {
 		parentPath := ""
 		if parent != nil {
 			parentPath = parent.ImportPath
 		}
-		if _, p, e := VgoLookup(parentPath, path); e == nil {
+		if _, p, e := ModLookup(parentPath, path); e == nil {
 			return p
 		}
 		return path
@@ -1184,8 +1184,8 @@
 			// Install cross-compiled binaries to subdirectories of bin.
 			elem = full
 		}
-		if p.Internal.Build.BinDir == "" && VgoBinDir != nil {
-			p.Internal.Build.BinDir = VgoBinDir()
+		if p.Internal.Build.BinDir == "" && ModBinDir != nil {
+			p.Internal.Build.BinDir = ModBinDir()
 		}
 		if p.Internal.Build.BinDir != "" {
 			// Install to GOBIN or bin of GOPATH entry.
@@ -1438,10 +1438,10 @@
 		return
 	}
 
-	if VgoPackageModuleInfo != nil {
-		p.Module = VgoPackageModuleInfo(p.ImportPath)
+	if ModPackageModuleInfo != nil {
+		p.Module = ModPackageModuleInfo(p.ImportPath)
 		if p.Name == "main" {
-			p.Internal.BuildInfo = VgoPackageBuildInfo(p.ImportPath, p.Deps)
+			p.Internal.BuildInfo = ModPackageBuildInfo(p.ImportPath, p.Deps)
 		}
 	}
 }
@@ -1722,8 +1722,8 @@
 	if cmdlineMatchers == nil {
 		SetCmdlinePatterns(search.CleanImportPaths(args))
 	}
-	if VgoImportPaths != nil {
-		return VgoImportPaths(args)
+	if ModImportPaths != nil {
+		return ModImportPaths(args)
 	}
 	return search.ImportPaths(args)
 }
@@ -1820,8 +1820,8 @@
 	}
 	ctxt.ReadDir = func(string) ([]os.FileInfo, error) { return dirent, nil }
 
-	if VgoImportFromFiles != nil {
-		VgoImportFromFiles(gofiles)
+	if ModImportFromFiles != nil {
+		ModImportFromFiles(gofiles)
 	}
 
 	var err error
@@ -1852,8 +1852,8 @@
 		}
 		if cfg.GOBIN != "" {
 			pkg.Target = filepath.Join(cfg.GOBIN, exe)
-		} else if VgoBinDir != nil {
-			pkg.Target = filepath.Join(VgoBinDir(), exe)
+		} else if ModBinDir != nil {
+			pkg.Target = filepath.Join(ModBinDir(), exe)
 		}
 	}
 
diff --git a/vendor/cmd/go/internal/modcmd/mod.go b/vendor/cmd/go/internal/modcmd/mod.go
index db3c2cf..8e0e51a 100644
--- a/vendor/cmd/go/internal/modcmd/mod.go
+++ b/vendor/cmd/go/internal/modcmd/mod.go
@@ -204,10 +204,10 @@
 
 func runMod(cmd *base.Command, args []string) {
 	if modload.Init(); !modload.Enabled() {
-		base.Fatalf("vgo mod: cannot use outside module")
+		base.Fatalf("go mod: cannot use outside module")
 	}
 	if len(args) != 0 {
-		base.Fatalf("vgo mod: mod takes no arguments")
+		base.Fatalf("go mod: mod takes no arguments")
 	}
 
 	anyFlags :=
@@ -224,18 +224,18 @@
 			len(modEdits) > 0
 
 	if !anyFlags {
-		base.Fatalf("vgo mod: no flags specified (see 'go help mod').")
+		base.Fatalf("go mod: no flags specified (see 'go help mod').")
 	}
 
 	if modload.CmdModModule != "" {
 		if err := module.CheckPath(modload.CmdModModule); err != nil {
-			base.Fatalf("vgo mod: invalid -module: %v", err)
+			base.Fatalf("go mod: invalid -module: %v", err)
 		}
 	}
 
 	if modload.CmdModInit {
 		if _, err := os.Stat("go.mod"); err == nil {
-			base.Fatalf("vgo mod -init: go.mod already exists")
+			base.Fatalf("go mod -init: go.mod already exists")
 		}
 	}
 	modload.InitMod()
@@ -319,20 +319,20 @@
 func parsePathVersion(flag, arg string) (path, version string) {
 	i := strings.Index(arg, "@")
 	if i < 0 {
-		base.Fatalf("vgo mod: -%s=%s: need path@version", flag, arg)
+		base.Fatalf("go mod: -%s=%s: need path@version", flag, arg)
 	}
 	path, version = strings.TrimSpace(arg[:i]), strings.TrimSpace(arg[i+1:])
 	if err := module.CheckPath(path); err != nil {
-		base.Fatalf("vgo mod: -%s=%s: invalid path: %v", flag, arg, err)
+		base.Fatalf("go mod: -%s=%s: invalid path: %v", flag, arg, err)
 	}
 
 	// We don't call modfile.CheckPathVersion, because that insists
 	// on versions being in semver form, but here we want to allow
-	// versions like "master" or "1234abcdef", which vgo will resolve
+	// versions like "master" or "1234abcdef", which the go command will resolve
 	// the next time it runs (or during -fix).
 	// Even so, we need to make sure the version is a valid token.
 	if modfile.MustQuote(version) {
-		base.Fatalf("vgo mod: -%s=%s: invalid version %q", flag, arg, version)
+		base.Fatalf("go mod: -%s=%s: invalid version %q", flag, arg, version)
 	}
 
 	return path, version
@@ -341,11 +341,11 @@
 // parsePath parses -flag=arg expecting arg to be path (not path@version).
 func parsePath(flag, arg string) (path string) {
 	if strings.Contains(arg, "@") {
-		base.Fatalf("vgo mod: -%s=%s: need just path, not path@version", flag, arg)
+		base.Fatalf("go mod: -%s=%s: need just path, not path@version", flag, arg)
 	}
 	path = arg
 	if err := module.CheckPath(path); err != nil {
-		base.Fatalf("vgo mod: -%s=%s: invalid path: %v", flag, arg, err)
+		base.Fatalf("go mod: -%s=%s: invalid path: %v", flag, arg, err)
 	}
 	return path
 }
@@ -355,7 +355,7 @@
 	path, version := parsePathVersion("require", arg)
 	modEdits = append(modEdits, func(f *modfile.File) {
 		if err := f.AddRequire(path, version); err != nil {
-			base.Fatalf("vgo mod: -require=%s: %v", arg, err)
+			base.Fatalf("go mod: -require=%s: %v", arg, err)
 		}
 	})
 }
@@ -365,7 +365,7 @@
 	path := parsePath("droprequire", arg)
 	modEdits = append(modEdits, func(f *modfile.File) {
 		if err := f.DropRequire(path); err != nil {
-			base.Fatalf("vgo mod: -droprequire=%s: %v", arg, err)
+			base.Fatalf("go mod: -droprequire=%s: %v", arg, err)
 		}
 	})
 }
@@ -375,7 +375,7 @@
 	path, version := parsePathVersion("exclude", arg)
 	modEdits = append(modEdits, func(f *modfile.File) {
 		if err := f.AddExclude(path, version); err != nil {
-			base.Fatalf("vgo mod: -exclude=%s: %v", arg, err)
+			base.Fatalf("go mod: -exclude=%s: %v", arg, err)
 		}
 	})
 }
@@ -385,7 +385,7 @@
 	path, version := parsePathVersion("dropexclude", arg)
 	modEdits = append(modEdits, func(f *modfile.File) {
 		if err := f.DropExclude(path, version); err != nil {
-			base.Fatalf("vgo mod: -dropexclude=%s: %v", arg, err)
+			base.Fatalf("go mod: -dropexclude=%s: %v", arg, err)
 		}
 	})
 }
@@ -394,38 +394,38 @@
 func flagReplace(arg string) {
 	var i int
 	if i = strings.Index(arg, "=>"); i < 0 {
-		base.Fatalf("vgo mod: -replace=%s: need old@v=>new[@v] (missing =>)", arg)
+		base.Fatalf("go mod: -replace=%s: need old@v=>new[@v] (missing =>)", arg)
 	}
 	old, new := strings.TrimSpace(arg[:i]), strings.TrimSpace(arg[i+2:])
 	if i = strings.Index(old, "@"); i < 0 {
-		base.Fatalf("vgo mod: -replace=%s: need old@v=>new[@v] (missing @ in old@v)", arg)
+		base.Fatalf("go mod: -replace=%s: need old@v=>new[@v] (missing @ in old@v)", arg)
 	}
 	oldPath, oldVersion := strings.TrimSpace(old[:i]), strings.TrimSpace(old[i+1:])
 	if err := module.CheckPath(oldPath); err != nil {
-		base.Fatalf("vgo mod: -replace=%s: invalid old path: %v", arg, err)
+		base.Fatalf("go mod: -replace=%s: invalid old path: %v", arg, err)
 	}
 	if modfile.MustQuote(oldVersion) {
-		base.Fatalf("vgo mod: -replace=%s: invalid old version %q", arg, oldVersion)
+		base.Fatalf("go mod: -replace=%s: invalid old version %q", arg, oldVersion)
 	}
 	var newPath, newVersion string
 	if i = strings.Index(new, "@"); i >= 0 {
 		newPath, newVersion = strings.TrimSpace(new[:i]), strings.TrimSpace(new[i+1:])
 		if err := module.CheckPath(newPath); err != nil {
-			base.Fatalf("vgo mod: -replace=%s: invalid new path: %v", arg, err)
+			base.Fatalf("go mod: -replace=%s: invalid new path: %v", arg, err)
 		}
 		if modfile.MustQuote(newVersion) {
-			base.Fatalf("vgo mod: -replace=%s: invalid new version %q", arg, newVersion)
+			base.Fatalf("go mod: -replace=%s: invalid new version %q", arg, newVersion)
 		}
 	} else {
 		if !modfile.IsDirectoryPath(new) {
-			base.Fatalf("vgo mod: -replace=%s: unversioned new path must be local directory", arg)
+			base.Fatalf("go mod: -replace=%s: unversioned new path must be local directory", arg)
 		}
 		newPath = new
 	}
 
 	modEdits = append(modEdits, func(f *modfile.File) {
 		if err := f.AddReplace(oldPath, oldVersion, newPath, newVersion); err != nil {
-			base.Fatalf("vgo mod: -replace=%s: %v", arg, err)
+			base.Fatalf("go mod: -replace=%s: %v", arg, err)
 		}
 	})
 }
@@ -435,7 +435,7 @@
 	path, version := parsePathVersion("dropreplace", arg)
 	modEdits = append(modEdits, func(f *modfile.File) {
 		if err := f.DropReplace(path, version); err != nil {
-			base.Fatalf("vgo mod: -dropreplace=%s: %v", arg, err)
+			base.Fatalf("go mod: -dropreplace=%s: %v", arg, err)
 		}
 	})
 }
@@ -476,7 +476,7 @@
 	}
 	data, err := json.MarshalIndent(&f, "", "\t")
 	if err != nil {
-		base.Fatalf("vgo mod -json: internal error: %v", err)
+		base.Fatalf("go mod -json: internal error: %v", err)
 	}
 	data = append(data, '\n')
 	os.Stdout.Write(data)
diff --git a/vendor/cmd/go/internal/modcmd/vendor.go b/vendor/cmd/go/internal/modcmd/vendor.go
index b0e6001..078c44f 100644
--- a/vendor/cmd/go/internal/modcmd/vendor.go
+++ b/vendor/cmd/go/internal/modcmd/vendor.go
@@ -23,7 +23,7 @@
 
 	vdir := filepath.Join(modload.ModRoot, "vendor")
 	if err := os.RemoveAll(vdir); err != nil {
-		base.Fatalf("vgo vendor: %v", err)
+		base.Fatalf("go vendor: %v", err)
 	}
 
 	modpkgs := make(map[module.Version][]string)
@@ -59,7 +59,7 @@
 		}
 	}
 	if buf.Len() == 0 {
-		fmt.Fprintf(os.Stderr, "vgo: no dependencies to vendor\n")
+		fmt.Fprintf(os.Stderr, "go: no dependencies to vendor\n")
 		return
 	}
 	if err := ioutil.WriteFile(filepath.Join(vdir, "modules.txt"), buf.Bytes(), 0666); err != nil {
@@ -150,10 +150,10 @@
 func copyDir(dst, src string, match func(os.FileInfo) bool) {
 	files, err := ioutil.ReadDir(src)
 	if err != nil {
-		base.Fatalf("vgo vendor: %v", err)
+		base.Fatalf("go vendor: %v", err)
 	}
 	if err := os.MkdirAll(dst, 0777); err != nil {
-		base.Fatalf("vgo vendor: %v", err)
+		base.Fatalf("go vendor: %v", err)
 	}
 	for _, file := range files {
 		if file.IsDir() || !file.Mode().IsRegular() || !match(file) {
@@ -161,18 +161,18 @@
 		}
 		r, err := os.Open(filepath.Join(src, file.Name()))
 		if err != nil {
-			base.Fatalf("vgo vendor: %v", err)
+			base.Fatalf("go vendor: %v", err)
 		}
 		w, err := os.Create(filepath.Join(dst, file.Name()))
 		if err != nil {
-			base.Fatalf("vgo vendor: %v", err)
+			base.Fatalf("go vendor: %v", err)
 		}
 		if _, err := io.Copy(w, r); err != nil {
-			base.Fatalf("vgo vendor: %v", err)
+			base.Fatalf("go vendor: %v", err)
 		}
 		r.Close()
 		if err := w.Close(); err != nil {
-			base.Fatalf("vgo vendor: %v", err)
+			base.Fatalf("go vendor: %v", err)
 		}
 	}
 }
diff --git a/vendor/cmd/go/internal/modconv/convert.go b/vendor/cmd/go/internal/modconv/convert.go
index b8cef90..c2a7813 100644
--- a/vendor/cmd/go/internal/modconv/convert.go
+++ b/vendor/cmd/go/internal/modconv/convert.go
@@ -58,7 +58,7 @@
 		r := item.(module.Version)
 		repo, info, err := modfetch.ImportRepoRev(r.Path, r.Version)
 		if err != nil {
-			fmt.Fprintf(os.Stderr, "vgo: converting %s: stat %s@%s: %v\n", base.ShortPath(file), r.Path, r.Version, err)
+			fmt.Fprintf(os.Stderr, "go: converting %s: stat %s@%s: %v\n", base.ShortPath(file), r.Path, r.Version, err)
 			return
 		}
 		mu.Lock()
diff --git a/vendor/cmd/go/internal/modconv/modconv.go b/vendor/cmd/go/internal/modconv/modconv.go
index d3462b5..a586733 100644
--- a/vendor/cmd/go/internal/modconv/modconv.go
+++ b/vendor/cmd/go/internal/modconv/modconv.go
@@ -17,9 +17,3 @@
 	"vendor/manifest":    ParseVendorManifest,
 	"vendor/vendor.json": ParseVendorJSON,
 }
-
-// Prefix is a line we write at the top of auto-converted go.mod files
-// for dependencies before caching them.
-// In case of bugs in the converter, if we bump this version number,
-// then all the cached copies will be ignored.
-const Prefix = "//vgo 0.0.5\n"
diff --git a/vendor/cmd/go/internal/modfetch/cache.go b/vendor/cmd/go/internal/modfetch/cache.go
index cc785ec..e07b784 100644
--- a/vendor/cmd/go/internal/modfetch/cache.go
+++ b/vendor/cmd/go/internal/modfetch/cache.go
@@ -20,7 +20,7 @@
 
 var QuietLookup bool // do not print about lookups
 
-var SrcMod string // $GOPATH/src/mod; set by package vgo
+var SrcMod string // $GOPATH/src/mod; set by package modload
 
 // A cachingRepo is a cache around an underlying Repo,
 // avoiding redundant calls to ModulePath, Versions, Stat, Latest, and GoMod (but not Zip).
@@ -73,7 +73,7 @@
 		}
 
 		if !QuietLookup {
-			fmt.Fprintf(os.Stderr, "vgo: finding %s %s\n", r.path, rev)
+			fmt.Fprintf(os.Stderr, "go: finding %s %s\n", r.path, rev)
 		}
 		info, err = r.r.Stat(rev)
 		if err == nil {
@@ -101,7 +101,7 @@
 func (r *cachingRepo) Latest() (*RevInfo, error) {
 	c := r.cache.Do("latest:", func() interface{} {
 		if !QuietLookup {
-			fmt.Fprintf(os.Stderr, "vgo: finding %s latest\n", r.path)
+			fmt.Fprintf(os.Stderr, "go: finding %s latest\n", r.path)
 		}
 		info, err := r.r.Latest()
 
diff --git a/vendor/cmd/go/internal/modfetch/cache_test.go b/vendor/cmd/go/internal/modfetch/cache_test.go
index 87b1cdc..241c800 100644
--- a/vendor/cmd/go/internal/modfetch/cache_test.go
+++ b/vendor/cmd/go/internal/modfetch/cache_test.go
@@ -12,7 +12,7 @@
 )
 
 func TestWriteDiskCache(t *testing.T) {
-	tmpdir, err := ioutil.TempDir("", "vgo-writeCache-test-")
+	tmpdir, err := ioutil.TempDir("", "go-writeCache-test-")
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/vendor/cmd/go/internal/modfetch/codehost/vcs.go b/vendor/cmd/go/internal/modfetch/codehost/vcs.go
index 9b95da5..12e45cb 100644
--- a/vendor/cmd/go/internal/modfetch/codehost/vcs.go
+++ b/vendor/cmd/go/internal/modfetch/codehost/vcs.go
@@ -329,7 +329,7 @@
 	if rev == "latest" {
 		rev = r.cmd.latest
 	}
-	f, err := ioutil.TempFile("", "vgo-readzip-*.zip")
+	f, err := ioutil.TempFile("", "go-readzip-*.zip")
 	if err != nil {
 		return nil, "", err
 	}
diff --git a/vendor/cmd/go/internal/modfetch/coderepo.go b/vendor/cmd/go/internal/modfetch/coderepo.go
index 26f1fe8..357fb68 100644
--- a/vendor/cmd/go/internal/modfetch/coderepo.go
+++ b/vendor/cmd/go/internal/modfetch/coderepo.go
@@ -318,7 +318,7 @@
 	subdir := strings.Trim(strings.TrimPrefix(dir, actualDir), "/")
 
 	// Spool to local file.
-	f, err := ioutil.TempFile(tmpdir, "vgo-codehost-")
+	f, err := ioutil.TempFile(tmpdir, "go-codehost-")
 	if err != nil {
 		dl.Close()
 		return "", err
@@ -345,7 +345,7 @@
 	if err != nil {
 		return "", err
 	}
-	f2, err := ioutil.TempFile(tmpdir, "vgo-")
+	f2, err := ioutil.TempFile(tmpdir, "go-codezip-")
 	if err != nil {
 		return "", err
 	}
diff --git a/vendor/cmd/go/internal/modfetch/fetch.go b/vendor/cmd/go/internal/modfetch/fetch.go
index f4eb651..df7adda 100644
--- a/vendor/cmd/go/internal/modfetch/fetch.go
+++ b/vendor/cmd/go/internal/modfetch/fetch.go
@@ -44,12 +44,12 @@
 				// Use it.
 				// This should only happen if the mod/cache directory is preinitialized
 				// or if src/mod/path was removed but not src/mod/cache/download.
-				fmt.Fprintf(os.Stderr, "vgo: extracting %s %s\n", mod.Path, mod.Version)
+				fmt.Fprintf(os.Stderr, "go: extracting %s %s\n", mod.Path, mod.Version)
 			} else {
 				if err := os.MkdirAll(filepath.Join(SrcMod, "cache/download", mod.Path, "@v"), 0777); err != nil {
 					return cached{"", err}
 				}
-				fmt.Fprintf(os.Stderr, "vgo: downloading %s %s\n", mod.Path, mod.Version)
+				fmt.Fprintf(os.Stderr, "go: downloading %s %s\n", mod.Path, mod.Version)
 				if err := downloadZip(mod, zipfile); err != nil {
 					return cached{"", err}
 				}
@@ -115,7 +115,7 @@
 	return ioutil.WriteFile(target+"hash", []byte(hash), 0666)
 }
 
-var GoSumFile string // path to go.sum; set by package vgo
+var GoSumFile string // path to go.sum; set by package modload
 
 var goSum struct {
 	mu        sync.Mutex
@@ -138,7 +138,7 @@
 	goSum.m = make(map[module.Version][]string)
 	data, err := ioutil.ReadFile(GoSumFile)
 	if err != nil && !os.IsNotExist(err) {
-		base.Fatalf("vgo: %v", err)
+		base.Fatalf("go: %v", err)
 	}
 	goSum.enabled = true
 	readGoSum(GoSumFile, data)
@@ -172,7 +172,7 @@
 			continue
 		}
 		if len(f) != 3 {
-			base.Fatalf("vgo: malformed go.sum:\n%s:%d: wrong number of fields %v", file, lineno, len(f))
+			base.Fatalf("go: malformed go.sum:\n%s:%d: wrong number of fields %v", file, lineno, len(f))
 		}
 		mod := module.Version{Path: f[0], Version: f[1]}
 		goSum.m[mod] = append(goSum.m[mod], f[2])
@@ -188,11 +188,11 @@
 			// This can happen if someone does rm -rf GOPATH/src/cache/download. So it goes.
 			return
 		}
-		base.Fatalf("vgo: verifying %s@%s: %v", mod.Path, mod.Version, err)
+		base.Fatalf("go: verifying %s@%s: %v", mod.Path, mod.Version, err)
 	}
 	h := strings.TrimSpace(string(data))
 	if !strings.HasPrefix(h, "h1:") {
-		base.Fatalf("vgo: verifying %s@%s: unexpected ziphash: %q", mod.Path, mod.Version, h)
+		base.Fatalf("go: verifying %s@%s: unexpected ziphash: %q", mod.Path, mod.Version, h)
 	}
 
 	checkOneSum(mod, h)
@@ -205,7 +205,7 @@
 		return ioutil.NopCloser(bytes.NewReader(data)), nil
 	})
 	if err != nil {
-		base.Fatalf("vgo: verifying %s %s go.mod: %v", path, version, err)
+		base.Fatalf("go: verifying %s %s go.mod: %v", path, version, err)
 	}
 
 	checkOneSum(module.Version{Path: path, Version: version + "/go.mod"}, h)
@@ -224,7 +224,7 @@
 			return
 		}
 		if strings.HasPrefix(vh, "h1:") {
-			base.Fatalf("vgo: verifying %s@%s: checksum mismatch\n\tdownloaded: %v\n\tgo.sum:     %v", mod.Path, mod.Version, h, vh)
+			base.Fatalf("go: verifying %s@%s: checksum mismatch\n\tdownloaded: %v\n\tgo.sum:     %v", mod.Path, mod.Version, h, vh)
 		}
 	}
 	if len(goSum.m[mod]) > 0 {
@@ -268,7 +268,7 @@
 	data, _ := ioutil.ReadFile(GoSumFile)
 	if !bytes.Equal(data, buf.Bytes()) {
 		if err := ioutil.WriteFile(GoSumFile, buf.Bytes(), 0666); err != nil {
-			base.Fatalf("vgo: writing go.sum: %v", err)
+			base.Fatalf("go: writing go.sum: %v", err)
 		}
 	}
 
diff --git a/vendor/cmd/go/internal/modfetch/proxy.go b/vendor/cmd/go/internal/modfetch/proxy.go
index 25cad78..02c2e63 100644
--- a/vendor/cmd/go/internal/modfetch/proxy.go
+++ b/vendor/cmd/go/internal/modfetch/proxy.go
@@ -135,7 +135,7 @@
 	defer body.Close()
 
 	// Spool to local file.
-	f, err := ioutil.TempFile(tmpdir, "vgo-proxy-download-")
+	f, err := ioutil.TempFile(tmpdir, "go-proxy-download-")
 	if err != nil {
 		return "", err
 	}
diff --git a/vendor/cmd/go/internal/modfetch/repo.go b/vendor/cmd/go/internal/modfetch/repo.go
index 00bbd27..48cb56b 100644
--- a/vendor/cmd/go/internal/modfetch/repo.go
+++ b/vendor/cmd/go/internal/modfetch/repo.go
@@ -268,7 +268,7 @@
 		// TODO(rsc): Do what the docs promise: download the module
 		// 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 ../vgo into this package.
+		// the unzipped code cache out of ../modload into this package.
 		return r, info, nil
 	}
 
diff --git a/vendor/cmd/go/internal/modfile/rule.go b/vendor/cmd/go/internal/modfile/rule.go
index 1b9e7ba..1f15c97 100644
--- a/vendor/cmd/go/internal/modfile/rule.go
+++ b/vendor/cmd/go/internal/modfile/rule.go
@@ -131,11 +131,6 @@
 	// replace and exclude either. They don't matter, and it will work better for
 	// forward compatibility if we can depend on modules that have local changes.
 
-	// TODO: For the target module (not dependencies), maybe we should
-	// relax the semver requirement and rewrite the file with updated info
-	// after resolving any versions. That would let people type commit hashes
-	// or tags or branch names, and then vgo would fix them.
-
 	switch verb {
 	default:
 		fmt.Fprintf(errs, "%s:%d: unknown directive: %s\n", f.Syntax.Name, line.Start.Line, verb)
diff --git a/vendor/cmd/go/internal/modget/get.go b/vendor/cmd/go/internal/modget/get.go
index 08a8e7c..d2d7791 100644
--- a/vendor/cmd/go/internal/modget/get.go
+++ b/vendor/cmd/go/internal/modget/get.go
@@ -161,10 +161,10 @@
 
 func runGet(cmd *base.Command, args []string) {
 	if modload.GetU && len(args) > 0 {
-		base.Fatalf("vgo get: -u not supported with argument list")
+		base.Fatalf("go get: -u not supported with argument list")
 	}
 	if !modload.GetU && len(args) == 0 {
-		base.Fatalf("vgo get: need arguments or -u")
+		base.Fatalf("go get: need arguments or -u")
 	}
 
 	if modload.GetU {
@@ -184,7 +184,7 @@
 			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("vgo get: invalid module version syntax: %s", pkg)
+				base.Errorf("go get: invalid module version syntax: %s", pkg)
 				continue
 			}
 			path, vers = pkg[:i], pkg[i+1:j]
@@ -193,7 +193,7 @@
 		if i := strings.Index(pkg, "@"); i >= 0 {
 			path, pkg, vers = pkg[:i], pkg[:i], pkg[i+1:]
 			if strings.Contains(vers, "@") {
-				base.Errorf("vgo get: invalid module version syntax: %s", pkg)
+				base.Errorf("go get: invalid module version syntax: %s", pkg)
 				continue
 			}
 		} else {
@@ -205,7 +205,7 @@
 		} else {
 			info, err := modfetch.Query(path, vers, modload.Allowed)
 			if err != nil {
-				base.Errorf("vgo get %v: %v", pkg, err)
+				base.Errorf("go get %v: %v", pkg, err)
 				continue
 			}
 			upgrade = append(upgrade, module.Version{Path: path, Version: info.Version})
@@ -218,7 +218,7 @@
 	var err error
 	list, err := mvs.Upgrade(modload.Target, modload.Reqs(), upgrade...)
 	if err != nil {
-		base.Fatalf("vgo get: %v", err)
+		base.Fatalf("go get: %v", err)
 	}
 	modload.SetBuildList(list)
 
@@ -238,7 +238,7 @@
 	if len(downgrade) > 0 {
 		list, err := mvs.Downgrade(modload.Target, modload.Reqs(), downgrade...)
 		if err != nil {
-			base.Fatalf("vgo get: %v", err)
+			base.Fatalf("go get: %v", err)
 		}
 		modload.SetBuildList(list)
 
diff --git a/vendor/cmd/go/internal/modload/init.go b/vendor/cmd/go/internal/modload/init.go
index 24d5044..fa98cbc 100644
--- a/vendor/cmd/go/internal/modload/init.go
+++ b/vendor/cmd/go/internal/modload/init.go
@@ -30,10 +30,10 @@
 )
 
 var (
-	cwd         string
-	enabled     = MustBeVgo
-	MustBeVgo   = mustBeVgo()
-	initialized bool
+	cwd            string
+	enabled        = MustUseModules
+	MustUseModules = mustUseModules()
+	initialized    bool
 
 	ModRoot  string
 	modFile  *modfile.File
@@ -61,15 +61,15 @@
 
 func BinDir() string {
 	if !Enabled() {
-		panic("vgo.Bin")
+		panic("modload.BinDir")
 	}
 	return filepath.Join(gopath, "bin")
 }
 
-// mustBeVgo reports whether we are invoked as vgo
+// mustUseModules reports whether we are invoked as vgo
 // (as opposed to go).
 // If so, we only support builds with go.mod files.
-func mustBeVgo() bool {
+func mustUseModules() bool {
 	name := os.Args[0]
 	name = name[strings.LastIndex(name, "/")+1:]
 	name = name[strings.LastIndex(name, `\`)+1:]
@@ -87,11 +87,11 @@
 	default:
 		base.Fatalf("go: unknown environment setting GO111MODULE=%s", env)
 	case "", "auto":
-		// leave MustBeVgo alone
+		// leave MustUseModules alone
 	case "on":
-		MustBeVgo = true
+		MustUseModules = true
 	case "off":
-		if !MustBeVgo {
+		if !MustUseModules {
 			return
 		}
 	}
@@ -150,15 +150,15 @@
 			}
 		}
 		if inGOPATH {
-			if !MustBeVgo {
+			if !MustUseModules {
 				// No automatic enabling in GOPATH.
 				return
 			}
 		}
-		root, _ := FindModuleRoot(cwd, "", MustBeVgo)
+		root, _ := FindModuleRoot(cwd, "", MustUseModules)
 		if root == "" {
 			// If invoked as vgo, insist on a mod file.
-			if MustBeVgo {
+			if MustUseModules {
 				base.Fatalf("go: cannot find main module root; see 'go help modules'")
 			}
 			return
@@ -168,20 +168,20 @@
 	}
 
 	enabled = true
-	load.VgoBinDir = BinDir
-	load.VgoLookup = Lookup
-	load.VgoPackageModuleInfo = PackageModuleInfo
-	load.VgoImportPaths = ImportPaths
-	load.VgoPackageBuildInfo = PackageBuildInfo
-	load.VgoModInfoProg = ModInfoProg
-	load.VgoImportFromFiles = ImportFromFiles
+	load.ModBinDir = BinDir
+	load.ModLookup = Lookup
+	load.ModPackageModuleInfo = PackageModuleInfo
+	load.ModImportPaths = ImportPaths
+	load.ModPackageBuildInfo = PackageBuildInfo
+	load.ModInfoProg = ModInfoProg
+	load.ModImportFromFiles = ImportFromFiles
 
 	search.SetModRoot(ModRoot)
 }
 
 func Enabled() bool {
 	if !initialized {
-		panic("vgo: Enabled called before Init")
+		panic("go: Enabled called before Init")
 	}
 	return enabled
 }
@@ -226,13 +226,13 @@
 			legacyModInit()
 			return
 		}
-		base.Fatalf("vgo: %v", err)
+		base.Fatalf("go: %v", err)
 	}
 
 	f, err := modfile.Parse(gomod, data, fixVersion)
 	if err != nil {
 		// Errors returned by modfile.Parse begin with file:line.
-		base.Fatalf("vgo: errors parsing go.mod:\n%s\n", err)
+		base.Fatalf("go: errors parsing go.mod:\n%s\n", err)
 	}
 	modFile = f
 
@@ -240,7 +240,7 @@
 		// Empty mod file. Must add module path.
 		path, err := FindModulePath(ModRoot)
 		if err != nil {
-			base.Fatalf("vgo: %v", err)
+			base.Fatalf("go: %v", err)
 		}
 		f.AddModuleStmt(path)
 	}
@@ -268,9 +268,9 @@
 	if modFile == nil {
 		path, err := FindModulePath(ModRoot)
 		if err != nil {
-			base.Fatalf("vgo: %v", err)
+			base.Fatalf("go: %v", err)
 		}
-		fmt.Fprintf(os.Stderr, "vgo: creating new go.mod: module %s\n", path)
+		fmt.Fprintf(os.Stderr, "go: creating new go.mod: module %s\n", path)
 		modFile = new(modfile.File)
 		modFile.AddModuleStmt(path)
 	}
@@ -284,14 +284,14 @@
 			if convert == nil {
 				return
 			}
-			fmt.Fprintf(os.Stderr, "vgo: copying requirements from %s\n", base.ShortPath(cfg))
+			fmt.Fprintf(os.Stderr, "go: copying requirements from %s\n", base.ShortPath(cfg))
 			cfg = filepath.ToSlash(cfg)
 			if err := modconv.ConvertLegacyConfig(modFile, cfg, data); err != nil {
-				base.Fatalf("vgo: %v", err)
+				base.Fatalf("go: %v", err)
 			}
 			if len(modFile.Syntax.Stmt) == 1 {
-				// Add comment to prevent vgo from re-converting every time it runs.
-				modFile.AddComment("// vgo: no requirements found in " + name)
+				// Add comment to avoid re-converting every time it runs.
+				modFile.AddComment("// go: no requirements found in " + name)
 			}
 			return
 		}
@@ -454,7 +454,7 @@
 		}
 		min, err := mvs.Req(Target, buildList, direct, newReqs(buildList))
 		if err != nil {
-			base.Fatalf("vgo: %v", err)
+			base.Fatalf("go: %v", err)
 		}
 		var list []*modfile.Require
 		for _, m := range min {
@@ -471,13 +471,13 @@
 	modFile.Cleanup() // clean file after edits
 	new, err := modFile.Format()
 	if err != nil {
-		base.Fatalf("vgo: %v", err)
+		base.Fatalf("go: %v", err)
 	}
 	if bytes.Equal(old, new) {
 		return
 	}
 	if err := ioutil.WriteFile(file, new, 0666); err != nil {
-		base.Fatalf("vgo: %v", err)
+		base.Fatalf("go: %v", err)
 	}
 }
 
diff --git a/vendor/cmd/go/internal/modload/list.go b/vendor/cmd/go/internal/modload/list.go
index a35d60a..27d9667 100644
--- a/vendor/cmd/go/internal/modload/list.go
+++ b/vendor/cmd/go/internal/modload/list.go
@@ -50,10 +50,10 @@
 	matchedBuildList := make([]bool, len(buildList))
 	for _, arg := range args {
 		if strings.Contains(arg, `\`) {
-			base.Fatalf("vgo: module paths never use backslash")
+			base.Fatalf("go: module paths never use backslash")
 		}
 		if search.IsRelativePath(arg) {
-			base.Fatalf("vgo: cannot use relative path %s to specify module", arg)
+			base.Fatalf("go: cannot use relative path %s to specify module", arg)
 		}
 		if i := strings.Index(arg, "@"); i >= 0 {
 			info, err := modfetch.Query(arg[:i], arg[i+1:], nil)
diff --git a/vendor/cmd/go/internal/modload/load.go b/vendor/cmd/go/internal/modload/load.go
index b687680..f1c8b7b 100644
--- a/vendor/cmd/go/internal/modload/load.go
+++ b/vendor/cmd/go/internal/modload/load.go
@@ -85,7 +85,7 @@
 							pkg = Target.Path + suffix
 						}
 					} else {
-						base.Errorf("vgo: package %s outside module root", pkg)
+						base.Errorf("go: package %s outside module root", pkg)
 						continue
 					}
 					roots = append(roots, pkg)
@@ -101,7 +101,7 @@
 				paths = append(paths, "all") // will expand after load completes
 
 			case search.IsMetaPackage(pkg): // std, cmd
-				fmt.Fprintf(os.Stderr, "vgo: warning: %q matches no packages when using modules\n", pkg)
+				fmt.Fprintf(os.Stderr, "go: warning: %q matches no packages when using modules\n", pkg)
 
 			case strings.Contains(pkg, "..."):
 				// TODO: Don't we need to reevaluate this one last time once the build list stops changing?
@@ -161,7 +161,7 @@
 
 	imports, testImports, err := imports.ScanFiles(gofiles, imports.Tags())
 	if err != nil {
-		base.Fatalf("vgo: %v", err)
+		base.Fatalf("go: %v", err)
 	}
 
 	loaded = newLoader()
@@ -181,7 +181,7 @@
 // no particular package).
 func LoadBuildList() []module.Version {
 	if Init(); !Enabled() {
-		base.Fatalf("vgo: LoadBuildList called but vgo not enabled")
+		base.Fatalf("go: LoadBuildList called but modules not enabled")
 	}
 	InitMod()
 	loaded = newLoader()
@@ -210,7 +210,7 @@
 
 func loadAll(testAll bool) []string {
 	if Init(); !Enabled() {
-		panic("vgo: misuse of LoadALL/LoadVendor")
+		panic("go: misuse of LoadALL/LoadVendor")
 	}
 	InitMod()
 
@@ -391,7 +391,7 @@
 	ld.buildList = buildList
 	ld.buildList, err = mvsOp(Target, newReqs(ld.buildList))
 	if err != nil {
-		base.Fatalf("vgo: %v", err)
+		base.Fatalf("go: %v", err)
 	}
 
 	for {
@@ -413,7 +413,7 @@
 				}
 				ld.missing.Add(pkg)
 			} else if pkg.err != nil {
-				base.Errorf("vgo: %s: %s", pkg.stackText(), pkg.err)
+				base.Errorf("go: %s: %s", pkg.stackText(), pkg.err)
 			}
 		}
 		if ld.missing == nil {
@@ -424,7 +424,7 @@
 
 		ld.buildList, err = mvsOp(Target, newReqs(ld.buildList))
 		if err != nil {
-			base.Fatalf("vgo: %v", err)
+			base.Fatalf("go: %v", err)
 		}
 	}
 	base.ExitIfErrors()
@@ -621,7 +621,7 @@
 	pkg := item.(*loadPkg)
 	path := pkg.path
 	if build.IsLocalImport(path) {
-		base.Errorf("vgo: relative import is not supported: %s", path)
+		base.Errorf("go: relative import is not supported: %s", path)
 	}
 
 	// TODO: This is wrong (if path = foo/v2/bar and m.Path is foo,
@@ -638,7 +638,7 @@
 	fmt.Fprintf(os.Stderr, "resolving import %q\n", path)
 	repo, info, err := modfetch.Import(path, Allowed)
 	if err != nil {
-		base.Errorf("vgo: %s: %v", pkg.stackText(), err)
+		base.Errorf("go: %s: %v", pkg.stackText(), err)
 		return
 	}
 
@@ -654,19 +654,19 @@
 		}
 	}
 
-	fmt.Fprintf(os.Stderr, "vgo: finding %s (latest)\n", root)
+	fmt.Fprintf(os.Stderr, "go: finding %s (latest)\n", root)
 
 	if ld.found[path] {
 		base.Fatalf("internal error: findMissing loop on %s", path)
 	}
 	ld.found[path] = true
-	fmt.Fprintf(os.Stderr, "vgo: adding %s %s\n", root, info.Version)
+	fmt.Fprintf(os.Stderr, "go: adding %s %s\n", root, info.Version)
 	ld.buildList = append(ld.buildList, module.Version{Path: root, Version: info.Version})
 	modFile.AddRequire(root, info.Version)
 }
 
 // scanDir is like imports.ScanDir but elides known magic imports from the list,
-// so that vgo does not go looking for packages that don't really exist.
+// so that we do not go looking for packages that don't really exist.
 //
 // The standard magic import is "C", for cgo.
 //
@@ -674,7 +674,7 @@
 // These are so old that they predate "go get" and did not use URL-like paths.
 // Most code today now uses google.golang.org/appengine instead,
 // but not all code has been so updated. When we mostly ignore build tags
-// during "vgo vendor", we look into "// +build appengine" files and
+// during "go vendor", we look into "// +build appengine" files and
 // may see these legacy imports. We drop them so that the module
 // search does not look for modules to try to satisfy them.
 func scanDir(dir string, tags map[string]bool) (imports_, testImports []string, err error) {
@@ -771,7 +771,7 @@
 	return found.New
 }
 
-// mvsReqs implements mvs.Reqs for vgo's semantic versions,
+// mvsReqs implements mvs.Reqs for module semantic versions,
 // with any exclusions or replacements applied internally.
 type mvsReqs struct {
 	buildList []module.Version
@@ -875,7 +875,7 @@
 
 	data, err := modfetch.GoMod(mod.Path, mod.Version)
 	if err != nil {
-		base.Errorf("vgo: %s %s: %v\n", mod.Path, mod.Version, err)
+		base.Errorf("go: %s %s: %v\n", mod.Path, mod.Version, err)
 		return nil, err
 	}
 	f, err := modfile.Parse("go.mod", data, nil)
@@ -924,7 +924,7 @@
 	// if nothing is tagged. The Latest method
 	// only ever returns untagged versions,
 	// which is not what we want.
-	fmt.Fprintf(os.Stderr, "vgo: finding %s latest\n", m.Path)
+	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
diff --git a/vendor/cmd/go/internal/modload/search.go b/vendor/cmd/go/internal/modload/search.go
index 481fb98..d67073e 100644
--- a/vendor/cmd/go/internal/modload/search.go
+++ b/vendor/cmd/go/internal/modload/search.go
@@ -46,7 +46,7 @@
 			var err error
 			root, err = fetch(mod)
 			if err != nil {
-				base.Errorf("vgo: %v", err)
+				base.Errorf("go: %v", err)
 				continue
 			}
 		}
diff --git a/vendor/cmd/go/internal/search/search.go b/vendor/cmd/go/internal/search/search.go
index 14886bf..35f469f 100644
--- a/vendor/cmd/go/internal/search/search.go
+++ b/vendor/cmd/go/internal/search/search.go
@@ -352,7 +352,7 @@
 
 // ImportPathsNoDotExpansion returns the import paths to use for the given
 // command line, but it does no ... expansion.
-// TODO(vgo): Delete once old go get is gone.
+// TODO(rsc): Delete once old go get is gone.
 func ImportPathsNoDotExpansion(args []string) []string {
 	args = CleanImportPaths(args)
 	var out []string
diff --git a/vendor/cmd/go/internal/version/version.go b/vendor/cmd/go/internal/version/version.go
index 251ff72..5e2db09 100644
--- a/vendor/cmd/go/internal/version/version.go
+++ b/vendor/cmd/go/internal/version/version.go
@@ -13,7 +13,7 @@
 	"cmd/go/internal/work"
 )
 
-const vgoVersion = "2018-02-20.1"
+const version = "2018-02-20.1"
 
 var CmdVersion = &base.Command{
 	Run:       runVersion,
@@ -27,5 +27,5 @@
 		cmd.Usage()
 	}
 
-	fmt.Printf("go version %s %s/%s vgo:%s\n", work.RuntimeVersion, runtime.GOOS, runtime.GOARCH, vgoVersion)
+	fmt.Printf("go version %s %s/%s go:%s\n", work.RuntimeVersion, runtime.GOOS, runtime.GOARCH, version)
 }
diff --git a/vendor/cmd/go/internal/web2/web.go b/vendor/cmd/go/internal/web2/web.go
index d11ee6b..f390037 100644
--- a/vendor/cmd/go/internal/web2/web.go
+++ b/vendor/cmd/go/internal/web2/web.go
@@ -280,7 +280,7 @@
 	return err
 }
 
-var githubMessage = `vgo: 403 response from api.github.com
+var githubMessage = `go: 403 response from api.github.com
 
 GitHub applies fairly small rate limits to unauthenticated users, and
 you appear to be hitting them. To authenticate, please visit
diff --git a/vendor/cmd/go/internal/work/build.go b/vendor/cmd/go/internal/work/build.go
index 9973e27..d0b13da 100644
--- a/vendor/cmd/go/internal/work/build.go
+++ b/vendor/cmd/go/internal/work/build.go
@@ -282,16 +282,16 @@
 func getRuntimeVersion() string {
 	data, err := ioutil.ReadFile(filepath.Join(cfg.GOROOT, "src/runtime/internal/sys/zversion.go"))
 	if err != nil {
-		base.Fatalf("vgo: %v", err)
+		base.Fatalf("go: %v", err)
 	}
 	i := bytes.Index(data, []byte("TheVersion = `"))
 	if i < 0 {
-		base.Fatalf("vgo: cannot find TheVersion")
+		base.Fatalf("go: cannot find TheVersion")
 	}
 	data = data[i+len("TheVersion = `"):]
 	j := bytes.IndexByte(data, '`')
 	if j < 0 {
-		base.Fatalf("vgo: cannot find TheVersion")
+		base.Fatalf("go: cannot find TheVersion")
 	}
 	return string(data[:j])
 }
diff --git a/vendor/cmd/go/internal/work/exec.go b/vendor/cmd/go/internal/work/exec.go
index 1725493..6408d61 100644
--- a/vendor/cmd/go/internal/work/exec.go
+++ b/vendor/cmd/go/internal/work/exec.go
@@ -599,8 +599,8 @@
 		fmt.Fprintf(&icfg, "packagefile %s=%s\n", p1.ImportPath, a1.built)
 	}
 
-	if p.Internal.BuildInfo != "" && load.VgoModInfoProg != nil {
-		if err := b.writeFile(objdir+"_gomod_.go", load.VgoModInfoProg(p.Internal.BuildInfo)); err != nil {
+	if p.Internal.BuildInfo != "" && load.ModInfoProg != nil {
+		if err := b.writeFile(objdir+"_gomod_.go", load.ModInfoProg(p.Internal.BuildInfo)); err != nil {
 			return err
 		}
 		gofiles = append(gofiles, objdir+"_gomod_.go")
diff --git a/vendor/cmd/go/internal/work/init.go b/vendor/cmd/go/internal/work/init.go
index 3cc3fae..8d13b5f 100644
--- a/vendor/cmd/go/internal/work/init.go
+++ b/vendor/cmd/go/internal/work/init.go
@@ -230,8 +230,8 @@
 	case "":
 		// ok
 	case "local", "vendor":
-		// ok but check for vgo
-		if load.VgoLookup == nil {
+		// ok but check for modules
+		if load.ModLookup == nil {
 			base.Fatalf("build flag -getmode=%s only valid when using modules", cfg.BuildGetmode)
 		}
 	default:
diff --git a/vendor/cmd/go/main.go b/vendor/cmd/go/main.go
index 0f84bb5..a079c49 100644
--- a/vendor/cmd/go/main.go
+++ b/vendor/cmd/go/main.go
@@ -85,8 +85,8 @@
 		base.Usage()
 	}
 
-	if modload.MustBeVgo {
-		// If running as vgo or with -vgo, change get now to change help message.
+	if modload.MustUseModules {
+		// If running with modules force-enabled, change get now to change help message.
 		*get.CmdGet = *modget.CmdGet
 	}
 
@@ -142,7 +142,8 @@
 		os.Exit(2)
 	default:
 		// Run modload.Init so that each subcommand doesn't have to worry about it.
-		// Also install the vgo get command instead of the old go get command in vgo mode.
+		// Also install the module get command instead of the GOPATH go get command
+		// if modules are enabled.
 		modload.Init()
 		if modload.Enabled() {
 			// Might not have done this above, so do it now.