diff --git a/vendor/cmd/go/internal/modcmd/mod.go b/vendor/cmd/go/internal/modcmd/mod.go
new file mode 100644
index 0000000..f8b36d4
--- /dev/null
+++ b/vendor/cmd/go/internal/modcmd/mod.go
@@ -0,0 +1,427 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package modcmd implements the ``go mod'' command.
+package modcmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"cmd/go/internal/base"
+	"cmd/go/internal/modfile"
+	"cmd/go/internal/module"
+	"cmd/go/internal/vgo"
+)
+
+var CmdMod = &base.Command{
+	UsageLine: "mod [maintenance flags]",
+	Short:     "module maintenance",
+	Long: `
+Mod performs module maintenance operations as specified by the
+following flags, which may be combined.
+
+The first group of operations provide low-level editing operations
+for manipulating go.mod from the command line or in scripts or
+other tools. They read only go.mod itself; they do not look up any
+information about the modules involved.
+
+The -init flag initializes and writes a new go.mod to the current directory,
+in effect creating a new module rooted at the current directory.
+The file go.mod must not already exist.
+If possible, mod will guess the module path from import comments
+(see 'go help importpath') or from version control configuration.
+To override this guess, use the -module flag.
+(Without -init, mod applies to the current module.)
+
+The -module flag changes (or, with -init, sets) the module's path
+(the go.mod file's module line).
+
+The -require=path@version and -droprequire=path flags
+add and drop a requirement on the given module path and version.
+Note that -require overrides any existing requirements on path.
+These flags are mainly for tools that understand the module graph.
+Users should prefer 'go get path@version' or 'go get path@none',
+which make other go.mod adjustments as needed to satisfy
+constraints imposed by other modules.
+
+The -exclude=path@version and -dropexclude=path@version flags
+add and drop an exclusion for the given module path and version.
+Note that -exclude=path@version is a no-op if that exclusion already exists.
+
+The -replace=old@v=>new@w and -dropreplace=old@v flags
+add and drop a replacement of the given module path and version pair.
+Note that -replace overrides any existing replacements for old@v.
+
+These editing flags (-require, -droprequire, -exclude, -dropexclude,
+-replace, and -dropreplace) may be repeated.
+
+The -fmt flag reformats the go.mod file without making other changes.
+This reformatting is also implied by any other modifications that use or
+rewrite the go.mod file. The only time this flag is needed is if no other
+flags are specified, as in 'go mod -fmt'.
+
+The -json flag prints the go.mod file in JSON format corresponding to these
+Go types:
+
+	type Module struct {
+		Path string
+		Version string
+	}
+
+	type GoMod struct {
+		Module Module
+		Require []Module
+		Exclude []Module
+		Replace []struct{ Old, New Module }
+	}
+
+Note that this only describes the go.mod file itself, not other modules
+referred to indirectly. For the full set of modules available to a build,
+use 'go list -m -json all'.
+
+The next group of operations provide higher-level editing and maintenance
+of a module, beyond the go.mod file.
+
+The -packages flag prints a list of packages in the module.
+It only identifies directories containing Go source code;
+it does not check that those directories contain code that builds.
+
+The -fix flag updates go.mod to use canonical version identifiers and
+to be semantically consistent. For example, consider this go.mod file:
+
+	module M
+	
+	require (
+		A v1
+		B v1.0.0
+		C v1.0.0
+		D v1.2.3
+		E dev
+	)
+	
+	exclude D v1.2.3
+
+First, -fix rewrites non-canonical version identifiers to semver form, so
+A's v1 becomes v1.0.0 and E's dev becomes the pseudo-version for the latest
+commit on the dev branch, perhaps v0.0.0-20180523231146-b3f5c0f6e5f1.
+
+Next, -fix updates requirements to respect exclusions, so the requirement
+on the excluded D v1.2.3 is updated to use the next available version of D,
+perhaps D v1.2.4 or D v1.3.0.
+
+Finally, -fix removes redundant or misleading requirements.
+For example, if A v1.0.0 itself requires B v1.2.0 and C v1.0.0,
+then go.mod's requirement of B v1.0.0 is misleading (superseded
+by B's need for v1.2.0), and its requirement of C v1.0.0 is redundant
+(implied by B's need for the same version), so both will be removed.
+
+Although -fix runs the fix-up operation in isolation, the fix-up also
+runs automatically any time a go command uses the module graph,
+to update go.mod to reflect reality. For example, the -sync, -vendor,
+and -verify flags all effectively imply -fix. And because the module
+graph defines the meaning of import statements, any commands
+that load packages—'go build', 'go test', 'go list', and so on—also
+effectively imply 'go mod -fix'.
+
+The -sync flag synchronizes go.mod with the source code in the module.
+It adds any missing modules necessary to build the current module's
+packages and dependencies, and it removes unused modules that
+don't provide any relevant packages.
+
+The -vendor flag resets the module's vendor directory to include all
+packages needed to build and test all the module's packages and
+their dependencies.
+
+The -verify flag checks that the dependencies of the current module,
+which are stored in a local downloaded source cache, have not been
+modified since being downloaded. If all the modules are unmodified,
+-verify prints "all modules verified." Otherwise it reports which
+modules have been changed and causes 'go mod' to exit with a
+non-zero status.
+	`,
+}
+
+var (
+	modFmt      = CmdMod.Flag.Bool("fmt", false, "")
+	modFix      = CmdMod.Flag.Bool("fix", false, "")
+	modJSON     = CmdMod.Flag.Bool("json", false, "")
+	modPackages = CmdMod.Flag.Bool("packages", false, "")
+	modSync     = CmdMod.Flag.Bool("sync", false, "")
+	modVendor   = CmdMod.Flag.Bool("vendor", false, "")
+	modVerify   = CmdMod.Flag.Bool("verify", false, "")
+
+	modEdits []func(*modfile.File) // edits specified in flags
+)
+
+type flagFunc func(string)
+
+func (f flagFunc) String() string     { return "" }
+func (f flagFunc) Set(s string) error { f(s); return nil }
+
+func init() {
+	CmdMod.Run = runMod // break init cycle
+
+	CmdMod.Flag.BoolVar(&vgo.CmdModInit, "init", vgo.CmdModInit, "")
+	CmdMod.Flag.StringVar(&vgo.CmdModModule, "module", vgo.CmdModModule, "")
+
+	CmdMod.Flag.Var(flagFunc(flagAddRequire), "addrequire", "")
+	CmdMod.Flag.Var(flagFunc(flagDropRequire), "droprequire", "")
+	CmdMod.Flag.Var(flagFunc(flagAddExclude), "addexclude", "")
+	CmdMod.Flag.Var(flagFunc(flagDropReplace), "dropreplace", "")
+	CmdMod.Flag.Var(flagFunc(flagAddReplace), "addreplace", "")
+	CmdMod.Flag.Var(flagFunc(flagDropExclude), "dropexclude", "")
+}
+
+func runMod(cmd *base.Command, args []string) {
+	if vgo.Init(); !vgo.Enabled() {
+		base.Fatalf("vgo mod: cannot use outside module")
+	}
+	if len(args) != 0 {
+		base.Fatalf("vgo mod: mod takes no arguments")
+	}
+
+	anyFlags :=
+		vgo.CmdModInit ||
+			vgo.CmdModModule != "" ||
+			*modVendor ||
+			*modVerify ||
+			*modJSON ||
+			*modFmt ||
+			*modFix ||
+			*modPackages ||
+			*modSync ||
+			len(modEdits) > 0
+
+	if !anyFlags {
+		base.Fatalf("vgo mod: no flags specified (see 'go help mod').")
+	}
+
+	if vgo.CmdModModule != "" {
+		if err := module.CheckPath(vgo.CmdModModule); err != nil {
+			base.Fatalf("vgo mod: invalid -module: %v", err)
+		}
+	}
+
+	if vgo.CmdModInit {
+		if _, err := os.Stat("go.mod"); err == nil {
+			base.Fatalf("vgo mod -init: go.mod already exists")
+		}
+	}
+	vgo.InitMod()
+
+	// Syntactic edits.
+
+	modFile := vgo.ModFile()
+	if vgo.CmdModModule != "" {
+		modFile.AddModuleStmt(vgo.CmdModModule)
+	}
+
+	if len(modEdits) > 0 {
+		for _, edit := range modEdits {
+			edit(modFile)
+		}
+	}
+	vgo.WriteGoMod() // write back syntactic changes
+
+	// Semantic edits.
+
+	needBuildList := *modFix
+
+	if *modSync || *modVendor || needBuildList {
+		if *modSync || *modVendor {
+			fmt.Println(vgo.ImportPaths([]string{"ALL"}))
+		} else {
+			vgo.LoadBuildList()
+		}
+		if *modSync {
+			// ImportPaths(ALL) already added missing modules.
+			// Remove unused modules.
+			panic("TODO sync unused")
+		}
+		vgo.WriteGoMod()
+		if *modVendor {
+			panic("TODO: move runVendor over")
+		}
+	}
+
+	// Read-only queries, processed only after updating go.mod.
+
+	if *modJSON {
+		modPrintJSON()
+	}
+
+	if *modPackages {
+		for _, pkg := range vgo.TargetPackages() {
+			fmt.Printf("%s\n", pkg)
+		}
+	}
+
+	if *modVerify {
+		panic("TODO: move runVerify over")
+	}
+}
+
+// parsePathVersion parses -flag=arg expecting arg to be path@version.
+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)
+	}
+	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)
+	}
+
+	// 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
+	// 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)
+	}
+
+	return path, version
+}
+
+// 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)
+	}
+	path = arg
+	if err := module.CheckPath(path); err != nil {
+		base.Fatalf("vgo mod: -%s=%s: invalid path: %v", flag, arg, err)
+	}
+	return path
+}
+
+// flagAddRequire implements the -addrequire flag.
+func flagAddRequire(arg string) {
+	path, version := parsePathVersion("addrequire", arg)
+	modEdits = append(modEdits, func(f *modfile.File) {
+		if err := f.AddRequire(path, version); err != nil {
+			base.Fatalf("vgo mod: -addrequire=%s: %v", arg, err)
+		}
+	})
+}
+
+// flagDropRequire implements the -droprequire flag.
+func flagDropRequire(arg string) {
+	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)
+		}
+	})
+}
+
+// flagAddExclude implements the -addexclude flag.
+func flagAddExclude(arg string) {
+	path, version := parsePathVersion("addexclude", arg)
+	modEdits = append(modEdits, func(f *modfile.File) {
+		if err := f.AddExclude(path, version); err != nil {
+			base.Fatalf("vgo mod: -addexclude=%s: %v", arg, err)
+		}
+	})
+}
+
+// flagDropExclude implements the -dropexclude flag.
+func flagDropExclude(arg string) {
+	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)
+		}
+	})
+}
+
+// flagAddReplace implements the -addreplace flag.
+func flagAddReplace(arg string) {
+	var i int
+	if i = strings.Index(arg, "=>"); i < 0 {
+		base.Fatalf("vgo mod: -addreplace=%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: -addreplace=%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: -addreplace=%s: invalid old path: %v", arg, err)
+	}
+	if modfile.MustQuote(oldVersion) {
+		base.Fatalf("vgo mod: -addreplace=%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: -addreplace=%s: invalid new path: %v", arg, err)
+		}
+		if modfile.MustQuote(newVersion) {
+			base.Fatalf("vgo mod: -addreplace=%s: invalid new version %q", arg, newVersion)
+		}
+	} else {
+		if !modfile.IsDirectoryPath(new) {
+			base.Fatalf("vgo mod: -addreplace=%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: -addreplace=%s: %v", arg, err)
+		}
+	})
+}
+
+// flagDropReplace implements the -dropreplace flag.
+func flagDropReplace(arg string) {
+	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)
+		}
+	})
+}
+
+// fileJSON is the -json output data structure.
+type fileJSON struct {
+	Module  module.Version
+	Require []module.Version
+	Exclude []module.Version
+	Replace []replaceJSON
+}
+
+type replaceJSON struct {
+	Old module.Version
+	New module.Version
+}
+
+// modPrintJSON prints the -json output.
+func modPrintJSON() {
+	modFile := vgo.ModFile()
+
+	var f fileJSON
+	f.Module = modFile.Module.Mod
+	for _, r := range modFile.Require {
+		f.Require = append(f.Require, r.Mod)
+	}
+	for _, x := range modFile.Exclude {
+		f.Exclude = append(f.Exclude, x.Mod)
+	}
+	for _, r := range modFile.Replace {
+		f.Replace = append(f.Replace, replaceJSON{r.Old, r.New})
+	}
+	data, err := json.MarshalIndent(&f, "", "\t")
+	if err != nil {
+		base.Fatalf("vgo mod -json: internal error: %v", err)
+	}
+	data = append(data, '\n')
+	os.Stdout.Write(data)
+}
diff --git a/vendor/cmd/go/internal/modfile/read.go b/vendor/cmd/go/internal/modfile/read.go
index f4a3926..8963fc2 100644
--- a/vendor/cmd/go/internal/modfile/read.go
+++ b/vendor/cmd/go/internal/modfile/read.go
@@ -89,6 +89,130 @@
 	return start, end
 }
 
+func (x *FileSyntax) addLine(hint Expr, tokens ...string) *Line {
+	if hint == nil {
+		// If no hint given, add to the first statement of the given type.
+	Loop:
+		for _, stmt := range x.Stmt {
+			switch stmt := stmt.(type) {
+			case *Line:
+				if stmt.Token != nil && stmt.Token[0] == tokens[0] {
+					hint = stmt
+					break Loop
+				}
+			case *LineBlock:
+				if stmt.Token[0] == tokens[0] {
+					hint = stmt
+					break Loop
+				}
+			}
+		}
+	}
+
+	if hint != nil {
+		for i, stmt := range x.Stmt {
+			switch stmt := stmt.(type) {
+			case *Line:
+				if stmt == hint {
+					// Convert line to line block.
+					stmt.InBlock = true
+					block := &LineBlock{Token: stmt.Token[:1], Line: []*Line{stmt}}
+					stmt.Token = stmt.Token[1:]
+					x.Stmt[i] = block
+					new := &Line{Token: tokens[1:], InBlock: true}
+					block.Line = append(block.Line, new)
+					return new
+				}
+			case *LineBlock:
+				if stmt == hint {
+					new := &Line{Token: tokens[1:], InBlock: true}
+					stmt.Line = append(stmt.Line, new)
+					return new
+				}
+				for j, line := range stmt.Line {
+					if line == hint {
+						// Add new line after hint.
+						stmt.Line = append(stmt.Line, nil)
+						copy(stmt.Line[j+2:], stmt.Line[j+1:])
+						new := &Line{Token: tokens[1:], InBlock: true}
+						stmt.Line[j+1] = new
+						return new
+					}
+				}
+			}
+		}
+	}
+
+	new := &Line{Token: tokens}
+	x.Stmt = append(x.Stmt, new)
+	return new
+}
+
+func (x *FileSyntax) updateLine(line *Line, tokens ...string) {
+	if line.InBlock {
+		tokens = tokens[1:]
+	}
+	line.Token = tokens
+}
+
+func (x *FileSyntax) removeLine(line *Line) {
+	line.Token = nil
+}
+
+// Cleanup cleans up the file syntax x after any edit operations.
+// To avoid quadratic behavior, removeLine marks the line as dead
+// by setting line.Token = nil but does not remove it from the slice
+// in which it appears. After edits have all been indicated,
+// calling Cleanup cleans out the dead lines.
+func (x *FileSyntax) Cleanup() {
+	w := 0
+	for _, stmt := range x.Stmt {
+		switch stmt := stmt.(type) {
+		case *Line:
+			if stmt.Token == nil {
+				continue
+			}
+		case *LineBlock:
+			ww := 0
+			for _, line := range stmt.Line {
+				if line.Token != nil {
+					stmt.Line[ww] = line
+					ww++
+				}
+			}
+			if ww == 0 {
+				continue
+			}
+			if ww == 1 {
+				// Collapse block into single line.
+				line := &Line{
+					Comments: Comments{
+						Before: commentsAdd(stmt.Before, stmt.Line[0].Before),
+						Suffix: commentsAdd(stmt.Line[0].Suffix, stmt.Suffix),
+						After:  commentsAdd(stmt.Line[0].After, stmt.After),
+					},
+					Token: stringsAdd(stmt.Token, stmt.Line[0].Token),
+				}
+				x.Stmt[w] = line
+				w++
+				continue
+			}
+			stmt.Line = stmt.Line[:ww]
+		}
+		x.Stmt[w] = stmt
+		w++
+	}
+	x.Stmt = x.Stmt[:w]
+}
+
+func commentsAdd(x, y []Comment) []Comment {
+	return append(x[:len(x):len(x)], y...)
+}
+
+func stringsAdd(x, y []string) []string {
+	return append(x[:len(x):len(x)], y...)
+}
+
 // A CommentBlock represents a top-level block of comments separate
 // from any rule.
 type CommentBlock struct {
@@ -103,9 +227,10 @@
 // A Line is a single line of tokens.
 type Line struct {
 	Comments
-	Start Position
-	Token []string
-	End   Position
+	Start   Position
+	Token   []string
+	InBlock bool
+	End     Position
 }
 
 func (x *Line) Span() (start, end Position) {
@@ -680,9 +805,10 @@
 		switch tok {
 		case '\n', _EOF, _EOL:
 			return &Line{
-				Start: start,
-				Token: token,
-				End:   end,
+				Start:   start,
+				Token:   token,
+				End:     end,
+				InBlock: true,
 			}
 		default:
 			token = append(token, sym.text)
diff --git a/vendor/cmd/go/internal/modfile/rule.go b/vendor/cmd/go/internal/modfile/rule.go
index 5a784a3..3170146 100644
--- a/vendor/cmd/go/internal/modfile/rule.go
+++ b/vendor/cmd/go/internal/modfile/rule.go
@@ -18,6 +18,7 @@
 	"cmd/go/internal/semver"
 )
 
+// A File is the parsed, interpreted form of a go.mod file.
 type File struct {
 	Module  *Module
 	Require []*Require
@@ -27,38 +28,45 @@
 	Syntax *FileSyntax
 }
 
+// A Module is the module statement.
 type Module struct {
-	Mod   module.Version
-	Major string
+	Mod    module.Version
+	Syntax *Line
 }
 
+// A Require is a single require statement.
 type Require struct {
 	Mod    module.Version
 	Syntax *Line
 }
 
+// An Exclude is a single exclude statement.
 type Exclude struct {
 	Mod    module.Version
 	Syntax *Line
 }
 
+// A Replace is a single replace statement.
 type Replace struct {
-	Old module.Version
-	New module.Version
-
+	Old    module.Version
+	New    module.Version
 	Syntax *Line
 }
 
-func (f *File) AddModuleStmt(path string) {
-	f.Module = &Module{
-		Mod: module.Version{Path: path},
-	}
+func (f *File) AddModuleStmt(path string) error {
 	if f.Syntax == nil {
 		f.Syntax = new(FileSyntax)
 	}
-	f.Syntax.Stmt = append(f.Syntax.Stmt, &Line{
-		Token: []string{"module", AutoQuote(path)},
-	})
+	if f.Module == nil {
+		f.Module = &Module{
+			Mod:    module.Version{Path: path},
+			Syntax: f.Syntax.addLine(nil, "module", AutoQuote(path)),
+		}
+	} else {
+		f.Module.Mod.Path = path
+		f.Syntax.updateLine(f.Module.Syntax, "module", AutoQuote(path))
+	}
+	return nil
 }
 
 func (f *File) AddComment(text string) {
@@ -135,7 +143,7 @@
 			fmt.Fprintf(errs, "%s:%d: repeated module statement\n", f.Syntax.Name, line.Start.Line)
 			return
 		}
-		f.Module = new(Module)
+		f.Module = &Module{Syntax: line}
 		if len(args) != 1 {
 
 			fmt.Fprintf(errs, "%s:%d: usage: module module/path [version]\n", f.Syntax.Name, line.Start.Line)
@@ -215,7 +223,7 @@
 		}
 		nv := ""
 		if len(args) == 4 {
-			if !isDirectoryPath(ns) {
+			if !IsDirectoryPath(ns) {
 				fmt.Fprintf(errs, "%s:%d: replacement module without version must be directory path (rooted or starting with ./ or ../)", f.Syntax.Name, line.Start.Line)
 				return
 			}
@@ -231,7 +239,7 @@
 				fmt.Fprintf(errs, "%s:%d: invalid module version %v: %v\n", f.Syntax.Name, line.Start.Line, old, err)
 				return
 			}
-			if isDirectoryPath(ns) {
+			if IsDirectoryPath(ns) {
 				fmt.Fprintf(errs, "%s:%d: replacement module directory path %q cannot have version", f.Syntax.Name, line.Start.Line, ns)
 				return
 			}
@@ -245,7 +253,10 @@
 	}
 }
 
-func isDirectoryPath(ns string) bool {
+// IsDirectoryPath reports whether the given path should be interpreted
+// as a directory path. Just like on the go command line, relative paths
+// and rooted paths are directory paths; the rest are module paths.
+func IsDirectoryPath(ns string) bool {
 	// Because go.mod files can move from one system to another,
 	// we check all known path syntaxes, both Unix and Windows.
 	return strings.HasPrefix(ns, "./") || strings.HasPrefix(ns, "../") || strings.HasPrefix(ns, "/") ||
@@ -253,19 +264,21 @@
 		len(ns) >= 2 && ('A' <= ns[0] && ns[0] <= 'Z' || 'a' <= ns[0] && ns[0] <= 'z') && ns[1] == ':'
 }
 
-func mustQuote(t string) bool {
-	for _, r := range t {
+// MustQuote reports whether s must be quoted in order to appear as
+// a single token in a go.mod line.
+func MustQuote(s string) bool {
+	for _, r := range s {
 		if !unicode.IsPrint(r) || r == ' ' || r == '"' || r == '\'' || r == '`' {
 			return true
 		}
 	}
-	return t == "" || strings.Contains(t, "//") || strings.Contains(t, "/*")
+	return s == "" || strings.Contains(s, "//") || strings.Contains(s, "/*")
 }
 
 // AutoQuote returns s or, if quoting is required for s to appear in a go.mod,
 // the quotation of s.
 func AutoQuote(s string) string {
-	if mustQuote(s) {
+	if MustQuote(s) {
 		return strconv.Quote(s)
 	}
 	return s
@@ -339,39 +352,64 @@
 	return Format(f.Syntax), nil
 }
 
-func (x *File) AddRequire(path, vers string) {
-	var syntax *Line
+// Cleanup cleans up the file f after any edit operations.
+// To avoid quadratic behavior, modifications like DropRequire
+// clear the entry but do not remove it from the slice.
+// Cleanup cleans out all the cleared entries.
+func (f *File) Cleanup() {
+	w := 0
+	for _, r := range f.Require {
+		if r.Mod.Path != "" {
+			f.Require[w] = r
+			w++
+		}
+	}
+	f.Require = f.Require[:w]
 
-	for i, stmt := range x.Syntax.Stmt {
-		switch stmt := stmt.(type) {
-		case *LineBlock:
-			if len(stmt.Token) > 0 && stmt.Token[0] == "require" {
-				syntax = &Line{Token: []string{AutoQuote(path), vers}}
-				stmt.Line = append(stmt.Line, syntax)
-				goto End
-			}
-		case *Line:
-			if len(stmt.Token) > 0 && stmt.Token[0] == "require" {
-				stmt.Token = stmt.Token[1:]
-				syntax = &Line{Token: []string{AutoQuote(path), vers}}
-				x.Syntax.Stmt[i] = &LineBlock{
-					Comments: stmt.Comments,
-					Token:    []string{"require"},
-					Line: []*Line{
-						stmt,
-						syntax,
-					},
-				}
-				goto End
+	w = 0
+	for _, x := range f.Exclude {
+		if x.Mod.Path != "" {
+			f.Exclude[w] = x
+			w++
+		}
+	}
+	f.Exclude = f.Exclude[:w]
+
+	w = 0
+	for _, r := range f.Replace {
+		if r.Old.Path != "" {
+			f.Replace[w] = r
+			w++
+		}
+	}
+	f.Replace = f.Replace[:w]
+
+	f.Syntax.Cleanup()
+}
+
+func (f *File) AddRequire(path, vers string) error {
+	need := true
+	for _, r := range f.Require {
+		if r.Mod.Path == path {
+			if need {
+				r.Mod.Version = vers
+				f.Syntax.updateLine(r.Syntax, "require", AutoQuote(path), vers)
+				need = false
+			} else {
+				f.Syntax.removeLine(r.Syntax)
+				*r = Require{}
 			}
 		}
 	}
 
-	syntax = &Line{Token: []string{"require", AutoQuote(path), vers}}
-	x.Syntax.Stmt = append(x.Syntax.Stmt, syntax)
+	if need {
+		f.AddNewRequire(path, vers)
+	}
+	return nil
+}
 
-End:
-	x.Require = append(x.Require, &Require{module.Version{Path: path, Version: vers}, syntax})
+func (f *File) AddNewRequire(path, vers string) {
+	f.Require = append(f.Require, &Require{module.Version{Path: path, Version: vers}, f.Syntax.addLine(nil, "require", AutoQuote(path), vers)})
 }
 
 func (f *File) SetRequire(req []module.Version) {
@@ -420,11 +458,89 @@
 	f.Syntax.Stmt = newStmts
 
 	for path, vers := range need {
-		f.AddRequire(path, vers)
+		f.AddNewRequire(path, vers)
 	}
 	f.SortBlocks()
 }
 
+func (f *File) DropRequire(path string) error {
+	for _, r := range f.Require {
+		if r.Mod.Path == path {
+			f.Syntax.removeLine(r.Syntax)
+			*r = Require{}
+		}
+	}
+	return nil
+}
+
+func (f *File) AddExclude(path, vers string) error {
+	var hint *Line
+	for _, x := range f.Exclude {
+		if x.Mod.Path == path && x.Mod.Version == vers {
+			return nil
+		}
+		if x.Mod.Path == path {
+			hint = x.Syntax
+		}
+	}
+
+	f.Exclude = append(f.Exclude, &Exclude{Mod: module.Version{Path: path, Version: vers}, Syntax: f.Syntax.addLine(hint, "exclude", AutoQuote(path), vers)})
+	return nil
+}
+
+func (f *File) DropExclude(path, vers string) error {
+	for _, x := range f.Exclude {
+		if x.Mod.Path == path && x.Mod.Version == vers {
+			f.Syntax.removeLine(x.Syntax)
+			*x = Exclude{}
+		}
+	}
+	return nil
+}
+
+func (f *File) AddReplace(oldPath, oldVers, newPath, newVers string) error {
+	need := true
+	old := module.Version{Path: oldPath, Version: oldVers}
+	new := module.Version{Path: newPath, Version: newVers}
+	tokens := []string{"replace", AutoQuote(oldPath), oldVers, "=>", AutoQuote(newPath)}
+	if newVers != "" {
+		tokens = append(tokens, newVers)
+	}
+
+	var hint *Line
+	for _, r := range f.Replace {
+		if r.Old == old {
+			if need {
+				// Found replacement for old; update to use new.
+				r.New = new
+				f.Syntax.updateLine(r.Syntax, tokens...)
+				need = false
+				continue
+			}
+			// Already added; delete other replacements for same.
+			f.Syntax.removeLine(r.Syntax)
+			*r = Replace{}
+		}
+		if r.Old.Path == oldPath {
+			hint = r.Syntax
+		}
+	}
+	if need {
+		f.Replace = append(f.Replace, &Replace{Old: old, New: new, Syntax: f.Syntax.addLine(hint, tokens...)})
+	}
+	return nil
+}
+
+func (f *File) DropReplace(oldPath, oldVers string) error {
+	for _, r := range f.Replace {
+		if r.Old.Path == oldPath && r.Old.Version == oldVers {
+			f.Syntax.removeLine(r.Syntax)
+			*r = Replace{}
+		}
+	}
+	return nil
+}
+
 func (f *File) SortBlocks() {
 	f.removeDups() // otherwise sorting is unsafe
 
diff --git a/vendor/cmd/go/internal/vgo/get.go b/vendor/cmd/go/internal/vgo/get.go
index b61f7bc..988e50d 100644
--- a/vendor/cmd/go/internal/vgo/get.go
+++ b/vendor/cmd/go/internal/vgo/get.go
@@ -141,7 +141,7 @@
 			}
 		*/
 	}
-	writeGoMod()
+	WriteGoMod()
 
 	if len(args) > 0 {
 		InstallHook(args)
diff --git a/vendor/cmd/go/internal/vgo/init.go b/vendor/cmd/go/internal/vgo/init.go
index 826dfd8..1b6beb4 100644
--- a/vendor/cmd/go/internal/vgo/init.go
+++ b/vendor/cmd/go/internal/vgo/init.go
@@ -41,8 +41,29 @@
 
 	gopath string
 	srcV   string
+
+	CmdModInit   bool   // go mod -init flag
+	CmdModModule string // go mod -module flag
+
 )
 
+// TargetPackages returns the list of packages in the target (top-level) module.
+func TargetPackages() []string {
+	return matchPackages("ALL", []module.Version{Target})
+}
+
+// ModFile returns the parsed go.mod file.
+//
+// Note that after calling ImportPaths or LoadBuildList,
+// the require statements in the modfile.File are no longer
+// the source of truth and will be ignored: edits made directly
+// will be lost at the next call to WriteGoMod.
+// To make permanent changes to the require statements
+// in go.mod, edit it before calling ImportPaths or LoadBuildList.
+func ModFile() *modfile.File {
+	return modFile
+}
+
 func BinDir() string {
 	if !Enabled() {
 		panic("vgo.Bin")
@@ -110,17 +131,23 @@
 		base.Fatalf("go: %v", err)
 	}
 
-	root, _ := FindModuleRoot(cwd, "", MustBeVgo)
-	if root == "" {
-		// If invoked as vgo, insist on a mod file.
-		if MustBeVgo {
-			base.Fatalf("cannot determine module root; please create a go.mod file there")
+	if CmdModInit {
+		// Running 'go mod -init': go.mod will be created in current directory.
+		ModRoot = cwd
+	} else {
+		root, _ := FindModuleRoot(cwd, "", MustBeVgo)
+		if root == "" {
+			// If invoked as vgo, insist on a mod file.
+			if MustBeVgo {
+				base.Fatalf("cannot determine module root; please create a go.mod file there")
+			}
+			return
 		}
-		return
+		ModRoot = root
 	}
+
 	enabled = true
-	ModRoot = root
-	search.SetModRoot(root)
+	search.SetModRoot(ModRoot)
 }
 
 func Enabled() bool {
@@ -146,11 +173,21 @@
 	srcV = filepath.Join(list[0], "src/v")
 	codehost.WorkRoot = filepath.Join(srcV, "cache/vcswork")
 
+	if CmdModInit {
+		// Running go mod -init: do legacy module conversion
+		// (go.mod does not exist yet).
+		legacyModInit()
+		return
+	}
+
 	gomod := filepath.Join(ModRoot, "go.mod")
 	data, err := ioutil.ReadFile(gomod)
 	if err != nil {
-		legacyModInit()
-		return
+		if os.IsNotExist(err) {
+			legacyModInit()
+			return
+		}
+		base.Fatalf("vgo: %v", err)
 	}
 
 	f, err := modfile.Parse(gomod, data, fixVersion)
@@ -180,7 +217,7 @@
 		excluded[x.Mod] = true
 	}
 	Target = f.Module.Mod
-	writeGoMod()
+	WriteGoMod()
 }
 
 func allowed(m module.Version) bool {
@@ -282,6 +319,10 @@
 
 // Exported only for testing.
 func FindModulePath(dir string) (string, error) {
+	if CmdModModule != "" {
+		// Running go mod -init -module=x/y/z; return x/y/z.
+		return CmdModModule, nil
+	}
 	for _, gpdir := range filepath.SplitList(cfg.BuildContext.GOPATH) {
 		src := filepath.Join(gpdir, "src") + string(filepath.Separator)
 		if strings.HasPrefix(dir, src) {
@@ -358,7 +399,8 @@
 	return path
 }
 
-func writeGoMod() {
+// WriteGoMod writes the current build list back to go.mod.
+func WriteGoMod() {
 	writeModHash()
 
 	if buildList != nil {
@@ -371,6 +413,7 @@
 
 	file := filepath.Join(ModRoot, "go.mod")
 	old, _ := ioutil.ReadFile(file)
+	modFile.Cleanup() // clean file after edits
 	new, err := modFile.Format()
 	if err != nil {
 		base.Fatalf("vgo: %v", err)
diff --git a/vendor/cmd/go/internal/vgo/load.go b/vendor/cmd/go/internal/vgo/load.go
index d650bf2..c56838f 100644
--- a/vendor/cmd/go/internal/vgo/load.go
+++ b/vendor/cmd/go/internal/vgo/load.go
@@ -60,7 +60,26 @@
 		ld.importList(imports, levelBuild)
 		ld.importList(testImports, levelBuild)
 	})
-	writeGoMod()
+	WriteGoMod()
+}
+
+// LoadBuildList loads the build list from go.mod.
+// The loading of the build list happens automatically in ImportPaths:
+// LoadBuildList need only be called if ImportPaths is not
+// (typically in commands that care about the module but
+// no particular package).
+func LoadBuildList() {
+	if Init(); !Enabled() {
+		base.Fatalf("vgo: LoadBuildList called but vgo not enabled")
+	}
+	InitMod()
+	iterate(func(*loader) {})
+	WriteGoMod()
+}
+
+// PkgMod returns a map from package import path to the module supplying that package.
+func PkgMod() map[string]module.Version {
+	return pkgmod
 }
 
 func ImportPaths(args []string) []string {
@@ -70,7 +89,7 @@
 	InitMod()
 
 	paths := importPaths(args)
-	writeGoMod()
+	WriteGoMod()
 	return paths
 }
 
diff --git a/vendor/cmd/go/internal/vgo/verify.go b/vendor/cmd/go/internal/vgo/verify.go
index d21c9d7..0938092 100644
--- a/vendor/cmd/go/internal/vgo/verify.go
+++ b/vendor/cmd/go/internal/vgo/verify.go
@@ -44,9 +44,7 @@
 	}
 
 	// Make go.mod consistent but don't load any packages.
-	InitMod()
-	iterate(func(*loader) {})
-	writeGoMod()
+	LoadBuildList()
 
 	ok := true
 	for _, mod := range buildList[1:] {
diff --git a/vendor/cmd/go/main.go b/vendor/cmd/go/main.go
index 0604990..d8c6b22 100644
--- a/vendor/cmd/go/main.go
+++ b/vendor/cmd/go/main.go
@@ -27,6 +27,7 @@
 	"cmd/go/internal/get"
 	"cmd/go/internal/help"
 	"cmd/go/internal/list"
+	"cmd/go/internal/modcmd"
 	"cmd/go/internal/run"
 	"cmd/go/internal/test"
 	"cmd/go/internal/tool"
@@ -49,6 +50,7 @@
 		get.CmdGet,
 		work.CmdInstall,
 		list.CmdList,
+		modcmd.CmdMod,
 		run.CmdRun,
 		test.CmdTest,
 		tool.CmdTool,
@@ -124,9 +126,16 @@
 		os.Exit(2)
 	}
 
-	vgo.Init()
-	if !vgo.MustBeVgo {
-		if vgo.Enabled() {
+	// Run vgo.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.
+	//
+	// If we should be vgo (if the command is named vgo or if invoked as go -vgo),
+	// and there is no go.mod file, vgo.Init will treat that as a fatal error.
+	// Normally that's fine, but if this is 'go mod -init' we need to give it a
+	// chance to create that go.mod file, so skip the init dance for 'go mod'.
+	if args[0] != "mod" {
+		vgo.Init()
+		if !vgo.MustBeVgo && vgo.Enabled() {
 			// Didn't do this above, so do it now.
 			*get.CmdGet = *vgo.CmdGet
 		}
diff --git a/vendor/cmd/go/vgo_test.go b/vendor/cmd/go/vgo_test.go
index 54ad36f..10e0d6b 100644
--- a/vendor/cmd/go/vgo_test.go
+++ b/vendor/cmd/go/vgo_test.go
@@ -5,8 +5,7 @@
 package Main_test
 
 import (
-	"cmd/go/internal/modconv"
-	"cmd/go/internal/vgo"
+	"bytes"
 	"internal/testenv"
 	"io/ioutil"
 	"os"
@@ -14,6 +13,9 @@
 	"runtime"
 	"sort"
 	"testing"
+
+	"cmd/go/internal/modconv"
+	"cmd/go/internal/vgo"
 )
 
 func TestVGOROOT(t *testing.T) {
@@ -80,6 +82,146 @@
 	}
 }
 
+func TestModEdit(t *testing.T) {
+	// Test that local replacements work
+	// and that they can use a dummy name
+	// that isn't resolvable and need not even
+	// include a dot. See golang.org/issue/24100.
+	tg := testgo(t)
+	defer tg.cleanup()
+	tg.makeTempdir()
+	tg.cd(tg.path("."))
+	tg.must(os.MkdirAll(tg.path("w"), 0777))
+	tg.must(ioutil.WriteFile(tg.path("x.go"), []byte("package x\n"), 0666))
+	tg.must(ioutil.WriteFile(tg.path("w/w.go"), []byte("package w\n"), 0666))
+
+	mustHaveGoMod := func(text string) {
+		data, err := ioutil.ReadFile(tg.path("go.mod"))
+		tg.must(err)
+		if string(data) != text {
+			t.Fatalf("go.mod mismatch:\nhave:<<<\n%s>>>\nwant:<<<\n%s\n", string(data), text)
+		}
+	}
+
+	tg.runFail("-vgo", "mod", "-init")
+	tg.grepStderr(`cannot determine module path`, "")
+	_, err := os.Stat(tg.path("go.mod"))
+	if err == nil {
+		t.Fatalf("failed go mod -init created go.mod")
+	}
+
+	tg.run("-vgo", "mod", "-init", "-module", "x.x/y/z")
+	tg.grepStderr("creating new go.mod: module x.x/y/z", "")
+	mustHaveGoMod(`module x.x/y/z
+`)
+
+	tg.runFail("-vgo", "mod", "-init")
+	mustHaveGoMod(`module x.x/y/z
+`)
+
+	tg.run("-vgo", "mod",
+		"-droprequire=x.1",
+		"-addrequire=x.1@v1.0.0",
+		"-addrequire=x.2@v1.1.0",
+		"-droprequire=x.2",
+		"-addexclude=x.1 @ v1.2.0",
+		"-addexclude=x.1@v1.2.1",
+		"-addreplace=x.1@v1.3.0=>y.1@v1.4.0",
+		"-addreplace=x.1@v1.4.0 => ../z",
+	)
+	mustHaveGoMod(`module x.x/y/z
+
+require x.1 v1.0.0
+
+exclude (
+	x.1 v1.2.0
+	x.1 v1.2.1
+)
+
+replace (
+	x.1 v1.3.0 => y.1 v1.4.0
+	x.1 v1.4.0 => ../z
+)
+`)
+
+	tg.run("-vgo", "mod",
+		"-droprequire=x.1",
+		"-dropexclude=x.1@v1.2.1",
+		"-dropreplace=x.1@v1.3.0",
+		"-addrequire=x.3@v1.99.0",
+	)
+	mustHaveGoMod(`module x.x/y/z
+
+exclude x.1 v1.2.0
+
+replace x.1 v1.4.0 => ../z
+
+require x.3 v1.99.0
+`)
+
+	tg.run("-vgo", "mod", "-json")
+	want := `{
+	"Module": {
+		"Path": "x.x/y/z",
+		"Version": ""
+	},
+	"Require": [
+		{
+			"Path": "x.3",
+			"Version": "v1.99.0"
+		}
+	],
+	"Exclude": [
+		{
+			"Path": "x.1",
+			"Version": "v1.2.0"
+		}
+	],
+	"Replace": [
+		{
+			"Old": {
+				"Path": "x.1",
+				"Version": "v1.4.0"
+			},
+			"New": {
+				"Path": "../z",
+				"Version": ""
+			}
+		}
+	]
+}
+`
+	if have := tg.getStdout(); have != want {
+		t.Fatalf("go mod -json mismatch:\nhave:<<<\n%s>>>\nwant:<<<\n%s\n", have, want)
+	}
+
+	tg.run("-vgo", "mod", "-packages")
+	want = `x.x/y/z
+x.x/y/z/w
+`
+	if have := tg.getStdout(); have != want {
+		t.Fatalf("go mod -packages mismatch:\nhave:<<<\n%s>>>\nwant:<<<\n%s\n", have, want)
+	}
+
+	data, err := ioutil.ReadFile(tg.path("go.mod"))
+	tg.must(err)
+	data = bytes.Replace(data, []byte("\n"), []byte("\r\n"), -1)
+	data = append(data, "    \n"...)
+	tg.must(ioutil.WriteFile(tg.path("go.mod"), data, 0666))
+
+	tg.run("-vgo", "mod", "-fmt")
+	mustHaveGoMod(`module x.x/y/z
+
+exclude x.1 v1.2.0
+
+replace x.1 v1.4.0 => ../z
+
+require x.3 v1.99.0
+`)
+}
+
+// TODO(rsc): Test mod -sync, mod -fix (network required).
+
 func TestLocalModule(t *testing.T) {
 	// Test that local replacements work
 	// and that they can use a dummy name