updated dependencies

go.mod

@@ -1,6 +1,6 @@
 module github.com/paulbsd/go-aptproxy
 
-go 1.19
+go 1.20
 
 require (
 	github.com/fsnotify/fsnotify v1.6.0
@@ -14,5 +14,5 @@ require (
 	golang.org/x/mod v0.6.0 // indirect
 	golang.org/x/net v0.1.0 // indirect
 	golang.org/x/sys v0.1.0 // indirect
-	golang.org/x/tools v0.2.0 // indirect
+	golang.org/x/tools v0.1.12 // indirect
 )

go.sum

@@ -31,8 +31,8 @@ golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.1.0 h1:hZ/3BUoy5aId7sCpA/Tc5lt8DkFgdVS2onTpJsZ/fl0=
 golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -51,8 +51,8 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.2.0 h1:G6AHpWxTMGY1KyEYoAQ5WTtIekUUvDNjan3ugu60JvE=
-golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA=
+golang.org/x/tools v0.1.12 h1:VveCTK38A2rkS8ZqFY25HIDFscX5X9OoEhJd3quQmXU=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

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

@@ -87,11 +87,7 @@ func NewReader(r io.Reader) (io.Reader, error) {
 
 // Read reads export data from in, decodes it, and returns type
 // information for the package.
-//
-// The package path (effectively its linker symbol prefix) is
-// specified by path, since unlike the package name, this information
-// may not be recorded in the export data.
-//
+// The package name is specified by path.
 // File position information is added to fset.
 //
 // Read may inspect and add to the imports map to ensure that references

vendor/golang.org/x/tools/go/internal/gcimporter/iimport.go

@@ -51,8 +51,6 @@ const (
 	iexportVersionPosCol   = 1
 	iexportVersionGo1_18   = 2
 	iexportVersionGenerics = 2
-
-	iexportVersionCurrent = 2
 )
 
 type ident struct {
@@ -98,7 +96,7 @@ func IImportBundle(fset *token.FileSet, imports map[string]*types.Package, data
 }
 
 func iimportCommon(fset *token.FileSet, imports map[string]*types.Package, data []byte, bundle bool, path string) (pkgs []*types.Package, err error) {
-	const currentVersion = iexportVersionCurrent
+	const currentVersion = 1
 	version := int64(-1)
 	if !debug {
 		defer func() {

vendor/golang.org/x/tools/go/internal/gcimporter/ureader_yes.go

@@ -36,12 +36,6 @@ type pkgReader struct {
 	// laterFns holds functions that need to be invoked at the end of
 	// import reading.
 	laterFns []func()
-	// laterFors is used in case of 'type A B' to ensure that B is processed before A.
-	laterFors map[types.Type]int
-
-	// ifaces holds a list of constructed Interfaces, which need to have
-	// Complete called after importing is done.
-	ifaces []*types.Interface
 }
 
 // later adds a function to be invoked at the end of import reading.
@@ -69,15 +63,6 @@ func UImportData(fset *token.FileSet, imports map[string]*types.Package, data []
 	return
 }
 
-// laterFor adds a function to be invoked at the end of import reading, and records the type that function is finishing.
-func (pr *pkgReader) laterFor(t types.Type, fn func()) {
-	if pr.laterFors == nil {
-		pr.laterFors = make(map[types.Type]int)
-	}
-	pr.laterFors[t] = len(pr.laterFns)
-	pr.laterFns = append(pr.laterFns, fn)
-}
-
 // readUnifiedPackage reads a package description from the given
 // unified IR export data decoder.
 func readUnifiedPackage(fset *token.FileSet, ctxt *types.Context, imports map[string]*types.Package, input pkgbits.PkgDecoder) *types.Package {
@@ -117,10 +102,6 @@ func readUnifiedPackage(fset *token.FileSet, ctxt *types.Context, imports map[st
 		fn()
 	}
 
-	for _, iface := range pr.ifaces {
-		iface.Complete()
-	}
-
 	pkg.MarkComplete()
 	return pkg
 }
@@ -250,35 +231,11 @@ func (r *reader) doPkg() *types.Package {
 	for i := range imports {
 		imports[i] = r.pkg()
 	}
-	pkg.SetImports(flattenImports(imports))
+	pkg.SetImports(imports)
 
 	return pkg
 }
 
-// flattenImports returns the transitive closure of all imported
-// packages rooted from pkgs.
-func flattenImports(pkgs []*types.Package) []*types.Package {
-	var res []*types.Package
-
-	seen := make(map[*types.Package]bool)
-	var add func(pkg *types.Package)
-	add = func(pkg *types.Package) {
-		if seen[pkg] {
-			return
-		}
-		seen[pkg] = true
-		res = append(res, pkg)
-		for _, imp := range pkg.Imports() {
-			add(imp)
-		}
-	}
-
-	for _, pkg := range pkgs {
-		add(pkg)
-	}
-	return res
-}
-
 // @@@ Types
 
 func (r *reader) typ() types.Type {
@@ -415,16 +372,6 @@ func (r *reader) interfaceType() *types.Interface {
 	if implicit {
 		iface.MarkImplicit()
 	}
-
-	// We need to call iface.Complete(), but if there are any embedded
-	// defined types, then we may not have set their underlying
-	// interface type yet. So we need to defer calling Complete until
-	// after we've called SetUnderlying everywhere.
-	//
-	// TODO(mdempsky): After CL 424876 lands, it should be safe to call
-	// iface.Complete() immediately.
-	r.p.ifaces = append(r.p.ifaces, iface)
-
 	return iface
 }
 
@@ -530,41 +477,13 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 
 			named.SetTypeParams(r.typeParamNames())
 
+			// TODO(mdempsky): Rewrite receiver types to underlying is an
+			// Interface? The go/types importer does this (I think because
+			// unit tests expected that), but cmd/compile doesn't care
+			// about it, so maybe we can avoid worrying about that here.
 			rhs := r.typ()
-			pk := r.p
-			pk.laterFor(named, func() {
-				// First be sure that the rhs is initialized, if it needs to be initialized.
-				delete(pk.laterFors, named) // prevent cycles
-				if i, ok := pk.laterFors[rhs]; ok {
-					f := pk.laterFns[i]
-					pk.laterFns[i] = func() {} // function is running now, so replace it with a no-op
-					f()                        // initialize RHS
-				}
+			r.p.later(func() {
 				underlying := rhs.Underlying()
-
-				// If the underlying type is an interface, we need to
-				// duplicate its methods so we can replace the receiver
-				// parameter's type (#49906).
-				if iface, ok := underlying.(*types.Interface); ok && iface.NumExplicitMethods() != 0 {
-					methods := make([]*types.Func, iface.NumExplicitMethods())
-					for i := range methods {
-						fn := iface.ExplicitMethod(i)
-						sig := fn.Type().(*types.Signature)
-
-						recv := types.NewVar(fn.Pos(), fn.Pkg(), "", named)
-						methods[i] = types.NewFunc(fn.Pos(), fn.Pkg(), fn.Name(), types.NewSignature(recv, sig.Params(), sig.Results(), sig.Variadic()))
-					}
-
-					embeds := make([]types.Type, iface.NumEmbeddeds())
-					for i := range embeds {
-						embeds[i] = iface.EmbeddedType(i)
-					}
-
-					newIface := types.NewInterfaceType(methods, embeds)
-					r.p.ifaces = append(r.p.ifaces, newIface)
-					underlying = newIface
-				}
-
 				named.SetUnderlying(underlying)
 			})
 

vendor/golang.org/x/tools/go/internal/pkgbits/decoder.go

@@ -9,7 +9,6 @@ import (
 	"fmt"
 	"go/constant"
 	"go/token"
-	"io"
 	"math/big"
 	"os"
 	"runtime"
@@ -95,7 +94,7 @@ func NewPkgDecoder(pkgPath, input string) PkgDecoder {
 	pr.elemEnds = make([]uint32, pr.elemEndsEnds[len(pr.elemEndsEnds)-1])
 	assert(binary.Read(r, binary.LittleEndian, pr.elemEnds[:]) == nil)
 
-	pos, err := r.Seek(0, io.SeekCurrent)
+	pos, err := r.Seek(0, os.SEEK_CUR)
 	assert(err == nil)
 
 	pr.elemData = input[pos:]
@@ -238,7 +237,7 @@ func (r *Decoder) Sync(mWant SyncMarker) {
 		return
 	}
 
-	pos, _ := r.Data.Seek(0, io.SeekCurrent)
+	pos, _ := r.Data.Seek(0, os.SEEK_CUR) // TODO(mdempsky): io.SeekCurrent after #44505 is resolved
 	mHave := SyncMarker(r.rawUvarint())
 	writerPCs := make([]int, r.rawUvarint())
 	for i := range writerPCs {

vendor/golang.org/x/tools/go/internal/pkgbits/encoder.go

@@ -147,9 +147,8 @@ func (pw *PkgEncoder) NewEncoderRaw(k RelocKind) Encoder {
 type Encoder struct {
 	p *PkgEncoder
 
-	Relocs   []RelocEnt
-	RelocMap map[RelocEnt]uint32
-	Data     bytes.Buffer // accumulated element bitstream data
+	Relocs []RelocEnt
+	Data   bytes.Buffer // accumulated element bitstream data
 
 	encodingRelocHeader bool
 
@@ -211,18 +210,15 @@ func (w *Encoder) rawVarint(x int64) {
 }
 
 func (w *Encoder) rawReloc(r RelocKind, idx Index) int {
-	e := RelocEnt{r, idx}
-	if w.RelocMap != nil {
-		if i, ok := w.RelocMap[e]; ok {
-			return int(i)
+	// TODO(mdempsky): Use map for lookup; this takes quadratic time.
+	for i, rEnt := range w.Relocs {
+		if rEnt.Kind == r && rEnt.Idx == idx {
+			return i
 		}
-	} else {
-		w.RelocMap = make(map[RelocEnt]uint32)
 	}
 
 	i := len(w.Relocs)
-	w.RelocMap[e] = uint32(i)
-	w.Relocs = append(w.Relocs, e)
+	w.Relocs = append(w.Relocs, RelocEnt{r, idx})
 	return i
 }
 

vendor/golang.org/x/tools/go/internal/pkgbits/reloc.go

@@ -5,11 +5,11 @@
 package pkgbits
 
 // A RelocKind indicates a particular section within a unified IR export.
-type RelocKind int32
+type RelocKind int
 
 // An Index represents a bitstream element index within a particular
 // section.
-type Index int32
+type Index int
 
 // A relocEnt (relocation entry) is an entry in an element's local
 // reference table.

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

@@ -60,7 +60,6 @@ func (r *responseDeduper) addAll(dr *driverResponse) {
 	for _, root := range dr.Roots {
 		r.addRoot(root)
 	}
-	r.dr.GoVersion = dr.GoVersion
 }
 
 func (r *responseDeduper) addPackage(p *Package) {
@@ -455,14 +454,11 @@ func (state *golistState) createDriverResponse(words ...string) (*driverResponse
 	if err != nil {
 		return nil, err
 	}
-
 	seen := make(map[string]*jsonPackage)
 	pkgs := make(map[string]*Package)
 	additionalErrors := make(map[string][]Error)
 	// Decode the JSON and convert it to Package form.
-	response := &driverResponse{
-		GoVersion: goVersion,
-	}
+	var response driverResponse
 	for dec := json.NewDecoder(buf); dec.More(); {
 		p := new(jsonPackage)
 		if err := dec.Decode(p); err != nil {
@@ -734,7 +730,7 @@ func (state *golistState) createDriverResponse(words ...string) (*driverResponse
 	}
 	sort.Slice(response.Packages, func(i, j int) bool { return response.Packages[i].ID < response.Packages[j].ID })
 
-	return response, nil
+	return &response, nil
 }
 
 func (state *golistState) shouldAddFilenameFromError(p *jsonPackage) bool {
@@ -760,7 +756,6 @@ func (state *golistState) shouldAddFilenameFromError(p *jsonPackage) bool {
 	return len(p.Error.ImportStack) == 0 || p.Error.ImportStack[len(p.Error.ImportStack)-1] == p.ImportPath
 }
 
-// getGoVersion returns the effective minor version of the go command.
 func (state *golistState) getGoVersion() (int, error) {
 	state.goVersionOnce.Do(func() {
 		state.goVersion, state.goVersionError = gocommand.GoVersion(state.ctx, state.cfgInvocation(), state.cfg.gocmdRunner)

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

@@ -19,7 +19,6 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"sync"
 	"time"
@@ -234,11 +233,6 @@ type driverResponse struct {
 	// Imports will be connected and then type and syntax information added in a
 	// later pass (see refine).
 	Packages []*Package
-
-	// GoVersion is the minor version number used by the driver
-	// (e.g. the go command on the PATH) when selecting .go files.
-	// Zero means unknown.
-	GoVersion int
 }
 
 // Load loads and returns the Go packages named by the given patterns.
@@ -262,7 +256,7 @@ func Load(cfg *Config, patterns ...string) ([]*Package, error) {
 		return nil, err
 	}
 	l.sizes = response.Sizes
-	return l.refine(response)
+	return l.refine(response.Roots, response.Packages...)
 }
 
 // defaultDriver is a driver that implements go/packages' fallback behavior.
@@ -538,7 +532,6 @@ type loaderPackage struct {
 	needsrc      bool  // load from source (Mode >= LoadTypes)
 	needtypes    bool  // type information is either requested or depended on
 	initial      bool  // package was matched by a pattern
-	goVersion    int   // minor version number of go command on PATH
 }
 
 // loader holds the working state of a single call to load.
@@ -625,8 +618,7 @@ func newLoader(cfg *Config) *loader {
 
 // refine connects the supplied packages into a graph and then adds type and
 // and syntax information as requested by the LoadMode.
-func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
-	roots := response.Roots
+func (ld *loader) refine(roots []string, list ...*Package) ([]*Package, error) {
 	rootMap := make(map[string]int, len(roots))
 	for i, root := range roots {
 		rootMap[root] = i
@@ -634,7 +626,7 @@ func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
 	ld.pkgs = make(map[string]*loaderPackage)
 	// first pass, fixup and build the map and roots
 	var initial = make([]*loaderPackage, len(roots))
-	for _, pkg := range response.Packages {
+	for _, pkg := range list {
 		rootIndex := -1
 		if i, found := rootMap[pkg.ID]; found {
 			rootIndex = i
@@ -656,7 +648,6 @@ func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
 			Package:   pkg,
 			needtypes: needtypes,
 			needsrc:   needsrc,
-			goVersion: response.GoVersion,
 		}
 		ld.pkgs[lpkg.ID] = lpkg
 		if rootIndex >= 0 {
@@ -932,33 +923,6 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
 		lpkg.Errors = append(lpkg.Errors, errs...)
 	}
 
-	// If the go command on the PATH is newer than the runtime,
-	// then the go/{scanner,ast,parser,types} packages from the
-	// standard library may be unable to process the files
-	// selected by go list.
-	//
-	// There is currently no way to downgrade the effective
-	// version of the go command (see issue 52078), so we proceed
-	// with the newer go command but, in case of parse or type
-	// errors, we emit an additional diagnostic.
-	//
-	// See:
-	// - golang.org/issue/52078 (flag to set release tags)
-	// - golang.org/issue/50825 (gopls legacy version support)
-	// - golang.org/issue/55883 (go/packages confusing error)
-	var runtimeVersion int
-	if _, err := fmt.Sscanf(runtime.Version(), "go1.%d", &runtimeVersion); err == nil && runtimeVersion < lpkg.goVersion {
-		defer func() {
-			if len(lpkg.Errors) > 0 {
-				appendError(Error{
-					Pos:  "-",
-					Msg:  fmt.Sprintf("This application uses version go1.%d of the source-processing packages but runs version go1.%d of 'go list'. It may fail to process source files that rely on newer language features. If so, rebuild the application using a newer version of Go.", runtimeVersion, lpkg.goVersion),
-					Kind: UnknownError,
-				})
-			}
-		}()
-	}
-
 	if ld.Config.Mode&NeedTypes != 0 && len(lpkg.CompiledGoFiles) == 0 && lpkg.ExportFile != "" {
 		// The config requested loading sources and types, but sources are missing.
 		// Add an error to the package and fall back to loading from export data.

vendor/golang.org/x/tools/internal/gocommand/invoke.go

@@ -10,10 +10,8 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"log"
 	"os"
 	"regexp"
-	"runtime"
 	"strconv"
 	"strings"
 	"sync"
@@ -234,12 +232,6 @@ func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
 	return runCmdContext(ctx, cmd)
 }
 
-// DebugHangingGoCommands may be set by tests to enable additional
-// instrumentation (including panics) for debugging hanging Go commands.
-//
-// See golang/go#54461 for details.
-var DebugHangingGoCommands = false
-
 // runCmdContext is like exec.CommandContext except it sends os.Interrupt
 // before os.Kill.
 func runCmdContext(ctx context.Context, cmd *exec.Cmd) error {
@@ -251,24 +243,11 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) error {
 		resChan <- cmd.Wait()
 	}()
 
-	// If we're interested in debugging hanging Go commands, stop waiting after a
-	// minute and panic with interesting information.
-	if DebugHangingGoCommands {
-		select {
-		case err := <-resChan:
-			return err
-		case <-time.After(1 * time.Minute):
-			HandleHangingGoCommand(cmd.Process)
-		case <-ctx.Done():
-		}
-	} else {
-		select {
-		case err := <-resChan:
-			return err
-		case <-ctx.Done():
-		}
+	select {
+	case err := <-resChan:
+		return err
+	case <-ctx.Done():
 	}
-
 	// Cancelled. Interrupt and see if it ends voluntarily.
 	cmd.Process.Signal(os.Interrupt)
 	select {
@@ -276,63 +255,11 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) error {
 		return err
 	case <-time.After(time.Second):
 	}
-
 	// Didn't shut down in response to interrupt. Kill it hard.
-	// TODO(rfindley): per advice from bcmills@, it may be better to send SIGQUIT
-	// on certain platforms, such as unix.
-	if err := cmd.Process.Kill(); err != nil && DebugHangingGoCommands {
-		// Don't panic here as this reliably fails on windows with EINVAL.
-		log.Printf("error killing the Go command: %v", err)
-	}
-
-	// See above: don't wait indefinitely if we're debugging hanging Go commands.
-	if DebugHangingGoCommands {
-		select {
-		case err := <-resChan:
-			return err
-		case <-time.After(10 * time.Second): // a shorter wait as resChan should return quickly following Kill
-			HandleHangingGoCommand(cmd.Process)
-		}
-	}
+	cmd.Process.Kill()
 	return <-resChan
 }
 
-func HandleHangingGoCommand(proc *os.Process) {
-	switch runtime.GOOS {
-	case "linux", "darwin", "freebsd", "netbsd":
-		fmt.Fprintln(os.Stderr, `DETECTED A HANGING GO COMMAND
-
-The gopls test runner has detected a hanging go command. In order to debug
-this, the output of ps and lsof/fstat is printed below.
-
-See golang/go#54461 for more details.`)
-
-		fmt.Fprintln(os.Stderr, "\nps axo ppid,pid,command:")
-		fmt.Fprintln(os.Stderr, "-------------------------")
-		psCmd := exec.Command("ps", "axo", "ppid,pid,command")
-		psCmd.Stdout = os.Stderr
-		psCmd.Stderr = os.Stderr
-		if err := psCmd.Run(); err != nil {
-			panic(fmt.Sprintf("running ps: %v", err))
-		}
-
-		listFiles := "lsof"
-		if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" {
-			listFiles = "fstat"
-		}
-
-		fmt.Fprintln(os.Stderr, "\n"+listFiles+":")
-		fmt.Fprintln(os.Stderr, "-----")
-		listFilesCmd := exec.Command(listFiles)
-		listFilesCmd.Stdout = os.Stderr
-		listFilesCmd.Stderr = os.Stderr
-		if err := listFilesCmd.Run(); err != nil {
-			panic(fmt.Sprintf("running %s: %v", listFiles, err))
-		}
-	}
-	panic(fmt.Sprintf("detected hanging go command (pid %d): see golang/go#54461 for more details", proc.Pid))
-}
-
 func cmdDebugStr(cmd *exec.Cmd) string {
 	env := make(map[string]string)
 	for _, kv := range cmd.Env {

vendor/golang.org/x/tools/internal/gocommand/version.go

@@ -10,15 +10,8 @@ import (
 	"strings"
 )
 
-// GoVersion reports the minor version number of the highest release
-// tag built into the go command on the PATH.
-//
-// Note that this may be higher than the version of the go tool used
-// to build this application, and thus the versions of the standard
-// go/{scanner,parser,ast,types} packages that are linked into it.
-// In that case, callers should either downgrade to the version of
-// go used to build the application, or report an error that the
-// application is too old to use the go command on the PATH.
+// GoVersion checks the go version by running "go list" with modules off.
+// It returns the X in Go 1.X.
 func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error) {
 	inv.Verb = "list"
 	inv.Args = []string{"-e", "-f", `{{context.ReleaseTags}}`, `--`, `unsafe`}
@@ -45,7 +38,7 @@ func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error) {
 	if len(stdout) < 3 {
 		return 0, fmt.Errorf("bad ReleaseTags output: %q", stdout)
 	}
-	// Split up "[go1.1 go1.15]" and return highest go1.X value.
+	// Split up "[go1.1 go1.15]"
 	tags := strings.Fields(stdout[1 : len(stdout)-2])
 	for i := len(tags) - 1; i >= 0; i-- {
 		var version int

vendor/modules.txt

@@ -29,7 +29,7 @@ golang.org/x/sys/execabs
 golang.org/x/sys/internal/unsafeheader
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-# golang.org/x/tools v0.2.0
+# golang.org/x/tools v0.1.12
 ## explicit; go 1.18
 golang.org/x/tools/go/gcexportdata
 golang.org/x/tools/go/internal/gcimporter
@@ -44,5 +44,3 @@ golang.org/x/tools/internal/gocommand
 golang.org/x/tools/internal/packagesinternal
 golang.org/x/tools/internal/typeparams
 golang.org/x/tools/internal/typesinternal
-# golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2
-## explicit; go 1.17