diff --git a/tools/go.mod b/tools/go.mod
index f5176a20fe..e6593069cb 100644
--- a/tools/go.mod
+++ b/tools/go.mod
@@ -6,7 +6,7 @@ require (
 	github.com/cfergeau/gomod2rpmdeps v0.0.0-20210223144124-2042c4850ca8
 	github.com/golangci/golangci-lint/v2 v2.5.0
 	github.com/randall77/makefat v0.0.0-20210315173500-7ddd0e42c844
-	golang.org/x/tools v0.37.0
+	golang.org/x/tools v0.38.0
 )
 
 require (
@@ -203,10 +203,10 @@ require (
 	go.uber.org/multierr v1.10.0 // indirect
 	go.uber.org/zap v1.27.0 // indirect
 	golang.org/x/exp/typeparams v0.0.0-20250911091902-df9299821621 // indirect
-	golang.org/x/mod v0.28.0 // indirect
+	golang.org/x/mod v0.29.0 // indirect
 	golang.org/x/sync v0.17.0 // indirect
-	golang.org/x/sys v0.36.0 // indirect
-	golang.org/x/telemetry v0.0.0-20250908211612-aef8a434d053 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8 // indirect
 	golang.org/x/text v0.29.0 // indirect
 	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect
diff --git a/tools/go.sum b/tools/go.sum
index 2eb56780bc..4748ba208c 100644
--- a/tools/go.sum
+++ b/tools/go.sum
@@ -688,8 +688,8 @@ golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/mod v0.28.0 h1:gQBtGhjxykdjY9YhZpSlZIsbnaE2+PgjfLWUQTnoZ1U=
-golang.org/x/mod v0.28.0/go.mod h1:yfB/L0NOf/kmEbXjzCPOx1iK1fRutOydrCMsqRhEBxI=
+golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=
+golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -728,8 +728,8 @@ golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
 golang.org/x/net v0.16.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
+golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
+golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -804,10 +804,10 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
-golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/telemetry v0.0.0-20250908211612-aef8a434d053 h1:dHQOQddU4YHS5gY33/6klKjq7Gp3WwMyOXGNp5nzRj8=
-golang.org/x/telemetry v0.0.0-20250908211612-aef8a434d053/go.mod h1:+nZKN+XVh4LCiA9DV3ywrzN4gumyCnKjau3NGb9SGoE=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8 h1:LvzTn0GQhWuvKH/kVRS3R3bVAsdQWI7hvfLHGgh9+lU=
+golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8/go.mod h1:Pi4ztBfryZoJEkyFTI5/Ocsu2jXyDr6iSdgJiYE/uwE=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
@@ -879,8 +879,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
 golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg=
-golang.org/x/tools v0.37.0 h1:DVSRzp7FwePZW356yEAChSdNcQo6Nsp+fex1SUW09lE=
-golang.org/x/tools v0.37.0/go.mod h1:MBN5QPQtLMHVdvsbtarmTNukZDdgwdwlO5qGacAzF0w=
+golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ=
+golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
 golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM=
 golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY=
 golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated h1:1h2MnaIAIXISqTFKdENegdpAgUXz6NrPEsbIeWaBRvM=
diff --git a/tools/vendor/golang.org/x/sys/unix/affinity_linux.go b/tools/vendor/golang.org/x/sys/unix/affinity_linux.go
index 3c7a6d6e2f..3ea470387b 100644
--- a/tools/vendor/golang.org/x/sys/unix/affinity_linux.go
+++ b/tools/vendor/golang.org/x/sys/unix/affinity_linux.go
@@ -41,6 +41,15 @@ func (s *CPUSet) Zero() {
 	clear(s[:])
 }
 
+// Fill adds all possible CPU bits to the set s. On Linux, [SchedSetaffinity]
+// will silently ignore any invalid CPU bits in [CPUSet] so this is an
+// efficient way of resetting the CPU affinity of a process.
+func (s *CPUSet) Fill() {
+	for i := range s {
+		s[i] = ^cpuMask(0)
+	}
+}
+
 func cpuBitsIndex(cpu int) int {
 	return cpu / _NCPUBITS
 }
diff --git a/tools/vendor/golang.org/x/sys/unix/fdset.go b/tools/vendor/golang.org/x/sys/unix/fdset.go
index 9e83d18cd0..62ed12645f 100644
--- a/tools/vendor/golang.org/x/sys/unix/fdset.go
+++ b/tools/vendor/golang.org/x/sys/unix/fdset.go
@@ -23,7 +23,5 @@ func (fds *FdSet) IsSet(fd int) bool {
 
 // Zero clears the set fds.
 func (fds *FdSet) Zero() {
-	for i := range fds.Bits {
-		fds.Bits[i] = 0
-	}
+	clear(fds.Bits[:])
 }
diff --git a/tools/vendor/golang.org/x/sys/unix/ifreq_linux.go b/tools/vendor/golang.org/x/sys/unix/ifreq_linux.go
index 848840ae4c..309f5a2b0c 100644
--- a/tools/vendor/golang.org/x/sys/unix/ifreq_linux.go
+++ b/tools/vendor/golang.org/x/sys/unix/ifreq_linux.go
@@ -111,9 +111,7 @@ func (ifr *Ifreq) SetUint32(v uint32) {
 // clear zeroes the ifreq's union field to prevent trailing garbage data from
 // being sent to the kernel if an ifreq is reused.
 func (ifr *Ifreq) clear() {
-	for i := range ifr.raw.Ifru {
-		ifr.raw.Ifru[i] = 0
-	}
+	clear(ifr.raw.Ifru[:])
 }
 
 // TODO(mdlayher): export as IfreqData? For now we can provide helpers such as
diff --git a/tools/vendor/golang.org/x/sys/unix/mkall.sh b/tools/vendor/golang.org/x/sys/unix/mkall.sh
index e6f31d374d..d0ed611912 100644
--- a/tools/vendor/golang.org/x/sys/unix/mkall.sh
+++ b/tools/vendor/golang.org/x/sys/unix/mkall.sh
@@ -49,6 +49,7 @@ esac
 if [[ "$GOOS" = "linux" ]]; then
 	# Use the Docker-based build system
 	# Files generated through docker (use $cmd so you can Ctl-C the build or run)
+	set -e
 	$cmd docker build --tag generate:$GOOS $GOOS
 	$cmd docker run --interactive --tty --volume $(cd -- "$(dirname -- "$0")/.." && pwd):/build generate:$GOOS
 	exit
diff --git a/tools/vendor/golang.org/x/sys/unix/syscall_linux.go b/tools/vendor/golang.org/x/sys/unix/syscall_linux.go
index 4958a65708..9439af961d 100644
--- a/tools/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/tools/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -801,9 +801,7 @@ func (sa *SockaddrPPPoE) sockaddr() (unsafe.Pointer, _Socklen, error) {
 	// one. The kernel expects SID to be in network byte order.
 	binary.BigEndian.PutUint16(sa.raw[6:8], sa.SID)
 	copy(sa.raw[8:14], sa.Remote)
-	for i := 14; i < 14+IFNAMSIZ; i++ {
-		sa.raw[i] = 0
-	}
+	clear(sa.raw[14 : 14+IFNAMSIZ])
 	copy(sa.raw[14:], sa.Dev)
 	return unsafe.Pointer(&sa.raw), SizeofSockaddrPPPoX, nil
 }
diff --git a/tools/vendor/golang.org/x/sys/unix/syscall_netbsd.go b/tools/vendor/golang.org/x/sys/unix/syscall_netbsd.go
index 88162099af..34a4676973 100644
--- a/tools/vendor/golang.org/x/sys/unix/syscall_netbsd.go
+++ b/tools/vendor/golang.org/x/sys/unix/syscall_netbsd.go
@@ -248,6 +248,23 @@ func Statvfs(path string, buf *Statvfs_t) (err error) {
 	return Statvfs1(path, buf, ST_WAIT)
 }
 
+func Getvfsstat(buf []Statvfs_t, flags int) (n int, err error) {
+	var (
+		_p0     unsafe.Pointer
+		bufsize uintptr
+	)
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+		bufsize = unsafe.Sizeof(Statvfs_t{}) * uintptr(len(buf))
+	}
+	r0, _, e1 := Syscall(SYS_GETVFSSTAT, uintptr(_p0), bufsize, uintptr(flags))
+	n = int(r0)
+	if e1 != 0 {
+		err = e1
+	}
+	return
+}
+
 /*
  * Exposed directly
  */
diff --git a/tools/vendor/golang.org/x/sys/windows/syscall_windows.go b/tools/vendor/golang.org/x/sys/windows/syscall_windows.go
index 640f6b153f..bd51337306 100644
--- a/tools/vendor/golang.org/x/sys/windows/syscall_windows.go
+++ b/tools/vendor/golang.org/x/sys/windows/syscall_windows.go
@@ -321,6 +321,8 @@ func NewCallbackCDecl(fn interface{}) uintptr {
 //sys	SetConsoleOutputCP(cp uint32) (err error) = kernel32.SetConsoleOutputCP
 //sys	WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW
 //sys	ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW
+//sys	GetNumberOfConsoleInputEvents(console Handle, numevents *uint32) (err error) = kernel32.GetNumberOfConsoleInputEvents
+//sys	FlushConsoleInputBuffer(console Handle) (err error) = kernel32.FlushConsoleInputBuffer
 //sys	resizePseudoConsole(pconsole Handle, size uint32) (hr error) = kernel32.ResizePseudoConsole
 //sys	CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.CreateToolhelp32Snapshot
 //sys	Module32First(snapshot Handle, moduleEntry *ModuleEntry32) (err error) = kernel32.Module32FirstW
diff --git a/tools/vendor/golang.org/x/sys/windows/types_windows.go b/tools/vendor/golang.org/x/sys/windows/types_windows.go
index 993a2297db..358be3c7f5 100644
--- a/tools/vendor/golang.org/x/sys/windows/types_windows.go
+++ b/tools/vendor/golang.org/x/sys/windows/types_windows.go
@@ -65,6 +65,22 @@ var signals = [...]string{
 	15: "terminated",
 }
 
+// File flags for [os.OpenFile]. The O_ prefix is used to indicate
+// that these flags are specific to the OpenFile function.
+const (
+	O_FILE_FLAG_OPEN_NO_RECALL     = FILE_FLAG_OPEN_NO_RECALL
+	O_FILE_FLAG_OPEN_REPARSE_POINT = FILE_FLAG_OPEN_REPARSE_POINT
+	O_FILE_FLAG_SESSION_AWARE      = FILE_FLAG_SESSION_AWARE
+	O_FILE_FLAG_POSIX_SEMANTICS    = FILE_FLAG_POSIX_SEMANTICS
+	O_FILE_FLAG_BACKUP_SEMANTICS   = FILE_FLAG_BACKUP_SEMANTICS
+	O_FILE_FLAG_DELETE_ON_CLOSE    = FILE_FLAG_DELETE_ON_CLOSE
+	O_FILE_FLAG_SEQUENTIAL_SCAN    = FILE_FLAG_SEQUENTIAL_SCAN
+	O_FILE_FLAG_RANDOM_ACCESS      = FILE_FLAG_RANDOM_ACCESS
+	O_FILE_FLAG_NO_BUFFERING       = FILE_FLAG_NO_BUFFERING
+	O_FILE_FLAG_OVERLAPPED         = FILE_FLAG_OVERLAPPED
+	O_FILE_FLAG_WRITE_THROUGH      = FILE_FLAG_WRITE_THROUGH
+)
+
 const (
 	FILE_READ_DATA        = 0x00000001
 	FILE_READ_ATTRIBUTES  = 0x00000080
diff --git a/tools/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/tools/vendor/golang.org/x/sys/windows/zsyscall_windows.go
index 641a5f4b77..426151a019 100644
--- a/tools/vendor/golang.org/x/sys/windows/zsyscall_windows.go
+++ b/tools/vendor/golang.org/x/sys/windows/zsyscall_windows.go
@@ -238,6 +238,7 @@ var (
 	procFindResourceW                                        = modkernel32.NewProc("FindResourceW")
 	procFindVolumeClose                                      = modkernel32.NewProc("FindVolumeClose")
 	procFindVolumeMountPointClose                            = modkernel32.NewProc("FindVolumeMountPointClose")
+	procFlushConsoleInputBuffer                              = modkernel32.NewProc("FlushConsoleInputBuffer")
 	procFlushFileBuffers                                     = modkernel32.NewProc("FlushFileBuffers")
 	procFlushViewOfFile                                      = modkernel32.NewProc("FlushViewOfFile")
 	procFormatMessageW                                       = modkernel32.NewProc("FormatMessageW")
@@ -284,6 +285,7 @@ var (
 	procGetNamedPipeHandleStateW                             = modkernel32.NewProc("GetNamedPipeHandleStateW")
 	procGetNamedPipeInfo                                     = modkernel32.NewProc("GetNamedPipeInfo")
 	procGetNamedPipeServerProcessId                          = modkernel32.NewProc("GetNamedPipeServerProcessId")
+	procGetNumberOfConsoleInputEvents                        = modkernel32.NewProc("GetNumberOfConsoleInputEvents")
 	procGetOverlappedResult                                  = modkernel32.NewProc("GetOverlappedResult")
 	procGetPriorityClass                                     = modkernel32.NewProc("GetPriorityClass")
 	procGetProcAddress                                       = modkernel32.NewProc("GetProcAddress")
@@ -2111,6 +2113,14 @@ func FindVolumeMountPointClose(findVolumeMountPoint Handle) (err error) {
 	return
 }
 
+func FlushConsoleInputBuffer(console Handle) (err error) {
+	r1, _, e1 := syscall.SyscallN(procFlushConsoleInputBuffer.Addr(), uintptr(console))
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func FlushFileBuffers(handle Handle) (err error) {
 	r1, _, e1 := syscall.SyscallN(procFlushFileBuffers.Addr(), uintptr(handle))
 	if r1 == 0 {
@@ -2481,6 +2491,14 @@ func GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err erro
 	return
 }
 
+func GetNumberOfConsoleInputEvents(console Handle, numevents *uint32) (err error) {
+	r1, _, e1 := syscall.SyscallN(procGetNumberOfConsoleInputEvents.Addr(), uintptr(console), uintptr(unsafe.Pointer(numevents)))
+	if r1 == 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
 func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) {
 	var _p0 uint32
 	if wait {
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/asmdecl/asmdecl.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/asmdecl/asmdecl.go
index 1aa7afb9c2..efbf05d596 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/asmdecl/asmdecl.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/asmdecl/asmdecl.go
@@ -237,7 +237,7 @@ Files:
 					// so accumulate them all and then prefer the one that
 					// matches build.Default.GOARCH.
 					var archCandidates []*asmArch
-					for _, fld := range strings.Fields(m[1]) {
+					for fld := range strings.FieldsSeq(m[1]) {
 						for _, a := range arches {
 							if a.name == fld {
 								archCandidates = append(archCandidates, a)
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/assign/assign.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/assign/assign.go
index 1914bb4761..dfe68d9b15 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/assign/assign.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/assign/assign.go
@@ -19,7 +19,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/astutil"
 )
 
 //go:embed doc.go
@@ -66,8 +66,8 @@ func run(pass *analysis.Pass) (any, error) {
 				!isMapIndex(pass.TypesInfo, lhs) &&
 				reflect.TypeOf(lhs) == reflect.TypeOf(rhs) { // short-circuit the heavy-weight gofmt check
 
-				le = analysisinternal.Format(pass.Fset, lhs)
-				re := analysisinternal.Format(pass.Fset, rhs)
+				le = astutil.Format(pass.Fset, lhs)
+				re := astutil.Format(pass.Fset, rhs)
 				if le == re {
 					isSelfAssign = true
 				}
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/atomic/atomic.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/atomic/atomic.go
index 82d5439ce5..ddd875b23b 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/atomic/atomic.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/atomic/atomic.go
@@ -14,7 +14,8 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/astutil"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -30,7 +31,7 @@ var Analyzer = &analysis.Analyzer{
 }
 
 func run(pass *analysis.Pass) (any, error) {
-	if !analysisinternal.Imports(pass.Pkg, "sync/atomic") {
+	if !typesinternal.Imports(pass.Pkg, "sync/atomic") {
 		return nil, nil // doesn't directly import sync/atomic
 	}
 
@@ -54,7 +55,7 @@ func run(pass *analysis.Pass) (any, error) {
 				continue
 			}
 			obj := typeutil.Callee(pass.TypesInfo, call)
-			if analysisinternal.IsFunctionNamed(obj, "sync/atomic", "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr") {
+			if typesinternal.IsFunctionNamed(obj, "sync/atomic", "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr") {
 				checkAtomicAddAssignment(pass, n.Lhs[i], call)
 			}
 		}
@@ -72,7 +73,7 @@ func checkAtomicAddAssignment(pass *analysis.Pass, left ast.Expr, call *ast.Call
 	arg := call.Args[0]
 	broken := false
 
-	gofmt := func(e ast.Expr) string { return analysisinternal.Format(pass.Fset, e) }
+	gofmt := func(e ast.Expr) string { return astutil.Format(pass.Fset, e) }
 
 	if uarg, ok := arg.(*ast.UnaryExpr); ok && uarg.Op == token.AND {
 		broken = gofmt(left) == gofmt(uarg.X)
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/atomicalign/atomicalign.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/atomicalign/atomicalign.go
index 2508b41f66..84699dd035 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/atomicalign/atomicalign.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/atomicalign/atomicalign.go
@@ -18,7 +18,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 const Doc = "check for non-64-bits-aligned arguments to sync/atomic functions"
@@ -35,7 +35,7 @@ func run(pass *analysis.Pass) (any, error) {
 	if 8*pass.TypesSizes.Sizeof(types.Typ[types.Uintptr]) == 64 {
 		return nil, nil // 64-bit platform
 	}
-	if !analysisinternal.Imports(pass.Pkg, "sync/atomic") {
+	if !typesinternal.Imports(pass.Pkg, "sync/atomic") {
 		return nil, nil // doesn't directly import sync/atomic
 	}
 
@@ -54,7 +54,7 @@ func run(pass *analysis.Pass) (any, error) {
 	inspect.Preorder(nodeFilter, func(node ast.Node) {
 		call := node.(*ast.CallExpr)
 		obj := typeutil.Callee(pass.TypesInfo, call)
-		if analysisinternal.IsFunctionNamed(obj, "sync/atomic", funcNames...) {
+		if typesinternal.IsFunctionNamed(obj, "sync/atomic", funcNames...) {
 			// For all the listed functions, the expression to check is always the first function argument.
 			check64BitAlignment(pass, obj.Name(), call.Args[0])
 		}
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/bools/bools.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/bools/bools.go
index e1cf9f9b7a..3c2a82dce3 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/bools/bools.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/bools/bools.go
@@ -15,7 +15,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/astutil"
 )
 
 const Doc = "check for common mistakes involving boolean operators"
@@ -104,7 +104,7 @@ func (op boolOp) commutativeSets(info *types.Info, e *ast.BinaryExpr, seen map[*
 func (op boolOp) checkRedundant(pass *analysis.Pass, exprs []ast.Expr) {
 	seen := make(map[string]bool)
 	for _, e := range exprs {
-		efmt := analysisinternal.Format(pass.Fset, e)
+		efmt := astutil.Format(pass.Fset, e)
 		if seen[efmt] {
 			pass.ReportRangef(e, "redundant %s: %s %s %s", op.name, efmt, op.tok, efmt)
 		} else {
@@ -150,8 +150,8 @@ func (op boolOp) checkSuspect(pass *analysis.Pass, exprs []ast.Expr) {
 		}
 
 		// e is of the form 'x != c' or 'x == c'.
-		xfmt := analysisinternal.Format(pass.Fset, x)
-		efmt := analysisinternal.Format(pass.Fset, e)
+		xfmt := astutil.Format(pass.Fset, x)
+		efmt := astutil.Format(pass.Fset, e)
 		if prev, found := seen[xfmt]; found {
 			// checkRedundant handles the case in which efmt == prev.
 			if efmt != prev {
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
index 6c7a0df585..91aac67625 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
@@ -15,6 +15,8 @@ import (
 
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
+	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/versions"
 )
 
 const Doc = "check //go:build and // +build directives"
@@ -55,7 +57,6 @@ func runBuildTag(pass *analysis.Pass) (any, error) {
 func checkGoFile(pass *analysis.Pass, f *ast.File) {
 	var check checker
 	check.init(pass)
-	defer check.finish()
 
 	for _, group := range f.Comments {
 		// A +build comment is ignored after or adjoining the package declaration.
@@ -77,6 +78,27 @@ func checkGoFile(pass *analysis.Pass, f *ast.File) {
 			check.comment(c.Slash, c.Text)
 		}
 	}
+
+	check.finish()
+
+	// For Go 1.18+ files, offer a fix to remove the +build lines
+	// if they passed all consistency checks.
+	if check.crossCheck && !versions.Before(pass.TypesInfo.FileVersions[f], "go1.18") {
+		for _, rng := range check.plusBuildRanges {
+			check.pass.Report(analysis.Diagnostic{
+				Pos:     rng.Pos(),
+				End:     rng.End(),
+				Message: "+build line is no longer needed",
+				SuggestedFixes: []analysis.SuggestedFix{{
+					Message: "Remove obsolete +build line",
+					TextEdits: []analysis.TextEdit{{
+						Pos: rng.Pos(),
+						End: rng.End(),
+					}},
+				}},
+			})
+		}
+	}
 }
 
 func checkOtherFile(pass *analysis.Pass, filename string) error {
@@ -96,15 +118,15 @@ func checkOtherFile(pass *analysis.Pass, filename string) error {
 }
 
 type checker struct {
-	pass         *analysis.Pass
-	plusBuildOK  bool            // "+build" lines still OK
-	goBuildOK    bool            // "go:build" lines still OK
-	crossCheck   bool            // cross-check go:build and +build lines when done reading file
-	inStar       bool            // currently in a /* */ comment
-	goBuildPos   token.Pos       // position of first go:build line found
-	plusBuildPos token.Pos       // position of first "+build" line found
-	goBuild      constraint.Expr // go:build constraint found
-	plusBuild    constraint.Expr // AND of +build constraints found
+	pass            *analysis.Pass
+	plusBuildOK     bool             // "+build" lines still OK
+	goBuildOK       bool             // "go:build" lines still OK
+	crossCheck      bool             // cross-check go:build and +build lines when done reading file
+	inStar          bool             // currently in a /* */ comment
+	goBuildPos      token.Pos        // position of first go:build line found
+	plusBuildRanges []analysis.Range // range of each "+build" line found
+	goBuild         constraint.Expr  // go:build constraint found
+	plusBuild       constraint.Expr  // AND of +build constraints found
 }
 
 func (check *checker) init(pass *analysis.Pass) {
@@ -272,6 +294,8 @@ func (check *checker) goBuildLine(pos token.Pos, line string) {
 }
 
 func (check *checker) plusBuildLine(pos token.Pos, line string) {
+	plusBuildRange := analysisinternal.Range(pos, pos+token.Pos(len(line)))
+
 	line = strings.TrimSpace(line)
 	if !constraint.IsPlusBuild(line) {
 		// Comment with +build but not at beginning.
@@ -286,9 +310,7 @@ func (check *checker) plusBuildLine(pos token.Pos, line string) {
 		check.crossCheck = false
 	}
 
-	if check.plusBuildPos == token.NoPos {
-		check.plusBuildPos = pos
-	}
+	check.plusBuildRanges = append(check.plusBuildRanges, plusBuildRange)
 
 	// testing hack: stop at // ERROR
 	if i := strings.Index(line, " // ERROR "); i >= 0 {
@@ -298,7 +320,7 @@ func (check *checker) plusBuildLine(pos token.Pos, line string) {
 	fields := strings.Fields(line[len("//"):])
 	// IsPlusBuildConstraint check above implies fields[0] == "+build"
 	for _, arg := range fields[1:] {
-		for _, elem := range strings.Split(arg, ",") {
+		for elem := range strings.SplitSeq(arg, ",") {
 			if strings.HasPrefix(elem, "!!") {
 				check.pass.Reportf(pos, "invalid double negative in build constraint: %s", arg)
 				check.crossCheck = false
@@ -336,19 +358,19 @@ func (check *checker) plusBuildLine(pos token.Pos, line string) {
 }
 
 func (check *checker) finish() {
-	if !check.crossCheck || check.plusBuildPos == token.NoPos || check.goBuildPos == token.NoPos {
+	if !check.crossCheck || len(check.plusBuildRanges) == 0 || check.goBuildPos == token.NoPos {
 		return
 	}
 
 	// Have both //go:build and // +build,
 	// with no errors found (crossCheck still true).
 	// Check they match.
-	var want constraint.Expr
 	lines, err := constraint.PlusBuildLines(check.goBuild)
 	if err != nil {
 		check.pass.Reportf(check.goBuildPos, "%v", err)
 		return
 	}
+	var want constraint.Expr
 	for _, line := range lines {
 		y, err := constraint.Parse(line)
 		if err != nil {
@@ -363,7 +385,8 @@ func (check *checker) finish() {
 		}
 	}
 	if want.String() != check.plusBuild.String() {
-		check.pass.Reportf(check.plusBuildPos, "+build lines do not match //go:build condition")
+		check.pass.ReportRangef(check.plusBuildRanges[0], "+build lines do not match //go:build condition")
+		check.crossCheck = false // don't offer fix to remove +build
 		return
 	}
 }
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/cgocall/cgocall.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/cgocall/cgocall.go
index d9189b5b69..bf1202b92b 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/cgocall/cgocall.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/cgocall/cgocall.go
@@ -18,7 +18,7 @@ import (
 	"strconv"
 
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 const debug = false
@@ -41,7 +41,7 @@ var Analyzer = &analysis.Analyzer{
 }
 
 func run(pass *analysis.Pass) (any, error) {
-	if !analysisinternal.Imports(pass.Pkg, "runtime/cgo") {
+	if !typesinternal.Imports(pass.Pkg, "runtime/cgo") {
 		return nil, nil // doesn't use cgo
 	}
 
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go
index a4e455d9b3..4190cc5900 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go
@@ -16,8 +16,9 @@ import (
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/astutil"
 	"golang.org/x/tools/internal/typeparams"
+	"golang.org/x/tools/internal/typesinternal"
 	"golang.org/x/tools/internal/versions"
 )
 
@@ -86,7 +87,7 @@ func checkCopyLocksAssign(pass *analysis.Pass, assign *ast.AssignStmt, goversion
 	lhs := assign.Lhs
 	for i, x := range assign.Rhs {
 		if path := lockPathRhs(pass, x); path != nil {
-			pass.ReportRangef(x, "assignment copies lock value to %v: %v", analysisinternal.Format(pass.Fset, assign.Lhs[i]), path)
+			pass.ReportRangef(x, "assignment copies lock value to %v: %v", astutil.Format(pass.Fset, assign.Lhs[i]), path)
 			lhs = nil // An lhs has been reported. We prefer the assignment warning and do not report twice.
 		}
 	}
@@ -100,7 +101,7 @@ func checkCopyLocksAssign(pass *analysis.Pass, assign *ast.AssignStmt, goversion
 				if id, ok := l.(*ast.Ident); ok && id.Name != "_" {
 					if obj := pass.TypesInfo.Defs[id]; obj != nil && obj.Type() != nil {
 						if path := lockPath(pass.Pkg, obj.Type(), nil); path != nil {
-							pass.ReportRangef(l, "for loop iteration copies lock value to %v: %v", analysisinternal.Format(pass.Fset, l), path)
+							pass.ReportRangef(l, "for loop iteration copies lock value to %v: %v", astutil.Format(pass.Fset, l), path)
 						}
 					}
 				}
@@ -132,7 +133,7 @@ func checkCopyLocksCompositeLit(pass *analysis.Pass, cl *ast.CompositeLit) {
 			x = node.Value
 		}
 		if path := lockPathRhs(pass, x); path != nil {
-			pass.ReportRangef(x, "literal copies lock value from %v: %v", analysisinternal.Format(pass.Fset, x), path)
+			pass.ReportRangef(x, "literal copies lock value from %v: %v", astutil.Format(pass.Fset, x), path)
 		}
 	}
 }
@@ -157,13 +158,16 @@ func checkCopyLocksCallExpr(pass *analysis.Pass, ce *ast.CallExpr) {
 	}
 	if fun, ok := pass.TypesInfo.Uses[id].(*types.Builtin); ok {
 		switch fun.Name() {
-		case "new", "len", "cap", "Sizeof", "Offsetof", "Alignof":
+		case "len", "cap", "Sizeof", "Offsetof", "Alignof":
+			// The argument of this operation is used only
+			// for its type (e.g. len(array)), or the operation
+			// does not copy a lock (e.g. len(slice)).
 			return
 		}
 	}
 	for _, x := range ce.Args {
 		if path := lockPathRhs(pass, x); path != nil {
-			pass.ReportRangef(x, "call of %s copies lock value: %v", analysisinternal.Format(pass.Fset, ce.Fun), path)
+			pass.ReportRangef(x, "call of %s copies lock value: %v", astutil.Format(pass.Fset, ce.Fun), path)
 		}
 	}
 }
@@ -230,7 +234,7 @@ func checkCopyLocksRangeVar(pass *analysis.Pass, rtok token.Token, e ast.Expr) {
 		return
 	}
 	if path := lockPath(pass.Pkg, typ, nil); path != nil {
-		pass.Reportf(e.Pos(), "range var %s copies lock: %v", analysisinternal.Format(pass.Fset, e), path)
+		pass.Reportf(e.Pos(), "range var %s copies lock: %v", astutil.Format(pass.Fset, e), path)
 	}
 }
 
@@ -350,7 +354,7 @@ func lockPath(tpkg *types.Package, typ types.Type, seen map[types.Type]bool) typ
 	// In go1.10, sync.noCopy did not implement Locker.
 	// (The Unlock method was added only in CL 121876.)
 	// TODO(adonovan): remove workaround when we drop go1.10.
-	if analysisinternal.IsTypeNamed(typ, "sync", "noCopy") {
+	if typesinternal.IsTypeNamed(typ, "sync", "noCopy") {
 		return []string{typ.String()}
 	}
 
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/deepequalerrors/deepequalerrors.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/deepequalerrors/deepequalerrors.go
index d15e3bc59b..5e3d1a3535 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/deepequalerrors/deepequalerrors.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/deepequalerrors/deepequalerrors.go
@@ -14,7 +14,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 const Doc = `check for calls of reflect.DeepEqual on error values
@@ -35,7 +35,7 @@ var Analyzer = &analysis.Analyzer{
 }
 
 func run(pass *analysis.Pass) (any, error) {
-	if !analysisinternal.Imports(pass.Pkg, "reflect") {
+	if !typesinternal.Imports(pass.Pkg, "reflect") {
 		return nil, nil // doesn't directly import reflect
 	}
 
@@ -47,7 +47,7 @@ func run(pass *analysis.Pass) (any, error) {
 	inspect.Preorder(nodeFilter, func(n ast.Node) {
 		call := n.(*ast.CallExpr)
 		obj := typeutil.Callee(pass.TypesInfo, call)
-		if analysisinternal.IsFunctionNamed(obj, "reflect", "DeepEqual") && hasError(pass, call.Args[0]) && hasError(pass, call.Args[1]) {
+		if typesinternal.IsFunctionNamed(obj, "reflect", "DeepEqual") && hasError(pass, call.Args[0]) && hasError(pass, call.Args[1]) {
 			pass.ReportRangef(call, "avoid using reflect.DeepEqual with errors")
 		}
 	})
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/defers/defers.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/defers/defers.go
index e11957f2d0..bf62d327d9 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/defers/defers.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/defers/defers.go
@@ -13,7 +13,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -29,14 +29,14 @@ var Analyzer = &analysis.Analyzer{
 }
 
 func run(pass *analysis.Pass) (any, error) {
-	if !analysisinternal.Imports(pass.Pkg, "time") {
+	if !typesinternal.Imports(pass.Pkg, "time") {
 		return nil, nil
 	}
 
 	checkDeferCall := func(node ast.Node) bool {
 		switch v := node.(type) {
 		case *ast.CallExpr:
-			if analysisinternal.IsFunctionNamed(typeutil.Callee(pass.TypesInfo, v), "time", "Since") {
+			if typesinternal.IsFunctionNamed(typeutil.Callee(pass.TypesInfo, v), "time", "Since") {
 				pass.Reportf(v.Pos(), "call to time.Since is not deferred")
 			}
 		case *ast.FuncLit:
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/errorsas/errorsas.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/errorsas/errorsas.go
index b8d29d019d..b3df99929d 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/errorsas/errorsas.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/errorsas/errorsas.go
@@ -12,22 +12,20 @@ import (
 	"go/types"
 
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
-	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	typeindexanalyzer "golang.org/x/tools/internal/analysisinternal/typeindex"
+	"golang.org/x/tools/internal/typesinternal/typeindex"
 )
 
 const Doc = `report passing non-pointer or non-error values to errors.As
 
-The errorsas analysis reports calls to errors.As where the type
+The errorsas analyzer reports calls to errors.As where the type
 of the second argument is not a pointer to a type implementing error.`
 
 var Analyzer = &analysis.Analyzer{
 	Name:     "errorsas",
 	Doc:      Doc,
 	URL:      "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/errorsas",
-	Requires: []*analysis.Analyzer{inspect.Analyzer},
+	Requires: []*analysis.Analyzer{typeindexanalyzer.Analyzer},
 	Run:      run,
 }
 
@@ -39,38 +37,31 @@ func run(pass *analysis.Pass) (any, error) {
 		return nil, nil
 	}
 
-	if !analysisinternal.Imports(pass.Pkg, "errors") {
-		return nil, nil // doesn't directly import errors
-	}
-
-	inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	var (
+		index = pass.ResultOf[typeindexanalyzer.Analyzer].(*typeindex.Index)
+		info  = pass.TypesInfo
+	)
 
-	nodeFilter := []ast.Node{
-		(*ast.CallExpr)(nil),
-	}
-	inspect.Preorder(nodeFilter, func(n ast.Node) {
-		call := n.(*ast.CallExpr)
-		obj := typeutil.Callee(pass.TypesInfo, call)
-		if !analysisinternal.IsFunctionNamed(obj, "errors", "As") {
-			return
-		}
+	for curCall := range index.Calls(index.Object("errors", "As")) {
+		call := curCall.Node().(*ast.CallExpr)
 		if len(call.Args) < 2 {
-			return // not enough arguments, e.g. called with return values of another function
+			continue // spread call: errors.As(pair())
 		}
-		if err := checkAsTarget(pass, call.Args[1]); err != nil {
+
+		// Check for incorrect arguments.
+		if err := checkAsTarget(info, call.Args[1]); err != nil {
 			pass.ReportRangef(call, "%v", err)
+			continue
 		}
-	})
+	}
 	return nil, nil
 }
 
-var errorType = types.Universe.Lookup("error").Type()
-
 // checkAsTarget reports an error if the second argument to errors.As is invalid.
-func checkAsTarget(pass *analysis.Pass, e ast.Expr) error {
-	t := pass.TypesInfo.Types[e].Type
-	if it, ok := t.Underlying().(*types.Interface); ok && it.NumMethods() == 0 {
-		// A target of interface{} is always allowed, since it often indicates
+func checkAsTarget(info *types.Info, e ast.Expr) error {
+	t := info.Types[e].Type
+	if types.Identical(t.Underlying(), anyType) {
+		// A target of any is always allowed, since it often indicates
 		// a value forwarded from another source.
 		return nil
 	}
@@ -78,12 +69,16 @@ func checkAsTarget(pass *analysis.Pass, e ast.Expr) error {
 	if !ok {
 		return errors.New("second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type")
 	}
-	if pt.Elem() == errorType {
+	if types.Identical(pt.Elem(), errorType) {
 		return errors.New("second argument to errors.As should not be *error")
 	}
-	_, ok = pt.Elem().Underlying().(*types.Interface)
-	if ok || types.Implements(pt.Elem(), errorType.Underlying().(*types.Interface)) {
-		return nil
+	if !types.IsInterface(pt.Elem()) && !types.AssignableTo(pt.Elem(), errorType) {
+		return errors.New("second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type")
 	}
-	return errors.New("second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type")
+	return nil
 }
+
+var (
+	anyType   = types.Universe.Lookup("any").Type()
+	errorType = types.Universe.Lookup("error").Type()
+)
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/hostport/hostport.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/hostport/hostport.go
index e808b1aa1b..07f154963e 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/hostport/hostport.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/hostport/hostport.go
@@ -10,7 +10,9 @@ import (
 	"fmt"
 	"go/ast"
 	"go/constant"
+	"go/token"
 	"go/types"
+	"strconv"
 
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
@@ -57,13 +59,16 @@ func run(pass *analysis.Pass) (any, error) {
 	}
 
 	// checkAddr reports a diagnostic (and returns true) if e
-	// is a call of the form fmt.Sprintf("%d:%d", ...).
+	// is a call of the form fmt.Sprintf("%s:%d", ...).
 	// The diagnostic includes a fix.
 	//
 	// dialCall is non-nil if the Dial call is non-local
 	// but within the same file.
 	checkAddr := func(e ast.Expr, dialCall *ast.CallExpr) {
-		if call, ok := e.(*ast.CallExpr); ok && typeutil.Callee(info, call) == fmtSprintf {
+		if call, ok := e.(*ast.CallExpr); ok &&
+			len(call.Args) == 3 &&
+			typeutil.Callee(info, call) == fmtSprintf {
+
 			// Examine format string.
 			formatArg := call.Args[0]
 			if tv := info.Types[formatArg]; tv.Value != nil {
@@ -99,21 +104,41 @@ func run(pass *analysis.Pass) (any, error) {
 
 				// Turn numeric port into a string.
 				if numericPort {
-					//  port => fmt.Sprintf("%d", port)
-					//   123 => "123"
 					port := call.Args[2]
-					newPort := fmt.Sprintf(`fmt.Sprintf("%%d", %s)`, port)
-					if port := info.Types[port].Value; port != nil {
-						if i, ok := constant.Int64Val(port); ok {
-							newPort = fmt.Sprintf(`"%d"`, i) // numeric constant
+
+					// Is port an integer literal?
+					//
+					// (Don't allow arbitrary constants k otherwise the
+					// transformation k => fmt.Sprintf("%d", "123")
+					// loses the symbolic connection to k.)
+					var kPort int64 = -1
+					if lit, ok := port.(*ast.BasicLit); ok && lit.Kind == token.INT {
+						if v, err := strconv.ParseInt(lit.Value, 0, 64); err == nil {
+							kPort = v
 						}
 					}
-
-					edits = append(edits, analysis.TextEdit{
-						Pos:     port.Pos(),
-						End:     port.End(),
-						NewText: []byte(newPort),
-					})
+					if kPort >= 0 {
+						// literal: 0x7B  => "123"
+						edits = append(edits, analysis.TextEdit{
+							Pos:     port.Pos(),
+							End:     port.End(),
+							NewText: fmt.Appendf(nil, `"%d"`, kPort), // (decimal)
+						})
+					} else {
+						// non-literal: port => fmt.Sprintf("%d", port)
+						edits = append(edits, []analysis.TextEdit{
+							{
+								Pos:     port.Pos(),
+								End:     port.Pos(),
+								NewText: []byte(`fmt.Sprintf("%d", `),
+							},
+							{
+								Pos:     port.End(),
+								End:     port.End(),
+								NewText: []byte(`)`),
+							},
+						}...)
+					}
 				}
 
 				// Refer to Dial call, if not adjacent.
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/httpmux/httpmux.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/httpmux/httpmux.go
index 655b78fd1c..a4f00e2c56 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/httpmux/httpmux.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/httpmux/httpmux.go
@@ -17,7 +17,6 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/typesinternal"
 )
 
@@ -46,7 +45,7 @@ func run(pass *analysis.Pass) (any, error) {
 			return nil, nil
 		}
 	}
-	if !analysisinternal.Imports(pass.Pkg, "net/http") {
+	if !typesinternal.Imports(pass.Pkg, "net/http") {
 		return nil, nil
 	}
 	// Look for calls to ServeMux.Handle or ServeMux.HandleFunc.
@@ -79,7 +78,7 @@ func isServeMuxRegisterCall(pass *analysis.Pass, call *ast.CallExpr) bool {
 	if fn == nil {
 		return false
 	}
-	if analysisinternal.IsFunctionNamed(fn, "net/http", "Handle", "HandleFunc") {
+	if typesinternal.IsFunctionNamed(fn, "net/http", "Handle", "HandleFunc") {
 		return true
 	}
 	if !isMethodNamed(fn, "net/http", "Handle", "HandleFunc") {
@@ -87,7 +86,7 @@ func isServeMuxRegisterCall(pass *analysis.Pass, call *ast.CallExpr) bool {
 	}
 	recv := fn.Type().(*types.Signature).Recv() // isMethodNamed() -> non-nil
 	isPtr, named := typesinternal.ReceiverNamed(recv)
-	return isPtr && analysisinternal.IsTypeNamed(named, "net/http", "ServeMux")
+	return isPtr && typesinternal.IsTypeNamed(named, "net/http", "ServeMux")
 }
 
 // isMethodNamed reports when a function f is a method,
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/httpresponse/httpresponse.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/httpresponse/httpresponse.go
index e9acd96547..37ecb6523b 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/httpresponse/httpresponse.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/httpresponse/httpresponse.go
@@ -13,7 +13,6 @@ import (
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/typesinternal"
 )
 
@@ -46,7 +45,7 @@ func run(pass *analysis.Pass) (any, error) {
 
 	// Fast path: if the package doesn't import net/http,
 	// skip the traversal.
-	if !analysisinternal.Imports(pass.Pkg, "net/http") {
+	if !typesinternal.Imports(pass.Pkg, "net/http") {
 		return nil, nil
 	}
 
@@ -118,7 +117,7 @@ func isHTTPFuncOrMethodOnClient(info *types.Info, expr *ast.CallExpr) bool {
 		return false // the function called does not return two values.
 	}
 	isPtr, named := typesinternal.ReceiverNamed(res.At(0))
-	if !isPtr || named == nil || !analysisinternal.IsTypeNamed(named, "net/http", "Response") {
+	if !isPtr || named == nil || !typesinternal.IsTypeNamed(named, "net/http", "Response") {
 		return false // the first return type is not *http.Response.
 	}
 
@@ -133,11 +132,11 @@ func isHTTPFuncOrMethodOnClient(info *types.Info, expr *ast.CallExpr) bool {
 		return ok && id.Name == "http" // function in net/http package.
 	}
 
-	if analysisinternal.IsTypeNamed(typ, "net/http", "Client") {
+	if typesinternal.IsTypeNamed(typ, "net/http", "Client") {
 		return true // method on http.Client.
 	}
 	ptr, ok := types.Unalias(typ).(*types.Pointer)
-	return ok && analysisinternal.IsTypeNamed(ptr.Elem(), "net/http", "Client") // method on *http.Client.
+	return ok && typesinternal.IsTypeNamed(ptr.Elem(), "net/http", "Client") // method on *http.Client.
 }
 
 // restOfBlock, given a traversal stack, finds the innermost containing
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go
index 2580a0ac21..8432e963c6 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/loopclosure/loopclosure.go
@@ -14,7 +14,6 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/typesinternal"
 	"golang.org/x/tools/internal/versions"
 )
@@ -369,5 +368,5 @@ func isMethodCall(info *types.Info, expr ast.Expr, pkgPath, typeName, method str
 	// Check that the receiver is a <pkgPath>.<typeName> or
 	// *<pkgPath>.<typeName>.
 	_, named := typesinternal.ReceiverNamed(recv)
-	return analysisinternal.IsTypeNamed(named, pkgPath, typeName)
+	return typesinternal.IsTypeNamed(named, pkgPath, typeName)
 }
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go
index c0746789e9..cc0bf0fd31 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go
@@ -16,8 +16,8 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/cfg"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/astutil"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -50,7 +50,7 @@ var contextPackage = "context"
 // checkLostCancel analyzes a single named or literal function.
 func run(pass *analysis.Pass) (any, error) {
 	// Fast path: bypass check if file doesn't use context.WithCancel.
-	if !analysisinternal.Imports(pass.Pkg, contextPackage) {
+	if !typesinternal.Imports(pass.Pkg, contextPackage) {
 		return nil, nil
 	}
 
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/nilness/nilness.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/nilness/nilness.go
index af61ae6088..8f1cca8f12 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/nilness/nilness.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/nilness/nilness.go
@@ -52,7 +52,7 @@ func runFunc(pass *analysis.Pass, fn *ssa.Function) {
 	// notNil reports an error if v is provably nil.
 	notNil := func(stack []fact, instr ssa.Instruction, v ssa.Value, descr string) {
 		if nilnessOf(stack, v) == isnil {
-			reportf("nilderef", instr.Pos(), descr)
+			reportf("nilderef", instr.Pos(), "%s", descr)
 		}
 	}
 
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/pkgfact/pkgfact.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/pkgfact/pkgfact.go
index 31748795da..2b8add3014 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/pkgfact/pkgfact.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/pkgfact/pkgfact.go
@@ -41,7 +41,7 @@ var Analyzer = &analysis.Analyzer{
 	URL:        "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/pkgfact",
 	Run:        run,
 	FactTypes:  []analysis.Fact{new(pairsFact)},
-	ResultType: reflect.TypeOf(map[string]string{}),
+	ResultType: reflect.TypeFor[map[string]string](),
 }
 
 // A pairsFact is a package-level fact that records
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go
index eebf40208d..f04e441434 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go
@@ -82,6 +82,16 @@
 //		...
 //	}
 //
+// A local function may also be inferred as a printf wrapper. If it
+// is assigned to a variable, each call made through that variable will
+// be checked just like a call to a function:
+//
+//	logf := func(format string, args ...any) {
+//		message := fmt.Sprintf(format, args...)
+//		log.Printf("%s: %s", prefix, message)
+//	}
+//	logf("%s", 123) // logf format %s has arg 123 of wrong type int
+//
 // # Specifying printf wrappers by flag
 //
 // The -funcs flag specifies a comma-separated list of names of
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
index 9ad18a041e..d94e592cf1 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
@@ -19,12 +19,14 @@ import (
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
+	"golang.org/x/tools/go/ast/edge"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
 	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/astutil"
 	"golang.org/x/tools/internal/fmtstr"
 	"golang.org/x/tools/internal/typeparams"
+	"golang.org/x/tools/internal/typesinternal"
 	"golang.org/x/tools/internal/versions"
 )
 
@@ -41,7 +43,7 @@ var Analyzer = &analysis.Analyzer{
 	URL:        "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/printf",
 	Requires:   []*analysis.Analyzer{inspect.Analyzer},
 	Run:        run,
-	ResultType: reflect.TypeOf((*Result)(nil)),
+	ResultType: reflect.TypeFor[*Result](),
 	FactTypes:  []analysis.Fact{new(isWrapper)},
 }
 
@@ -70,7 +72,7 @@ func (kind Kind) String() string {
 // Result is the printf analyzer's result type. Clients may query the result
 // to learn whether a function behaves like fmt.Print or fmt.Printf.
 type Result struct {
-	funcs map[*types.Func]Kind
+	funcs map[types.Object]Kind
 }
 
 // Kind reports whether fn behaves like fmt.Print or fmt.Printf.
@@ -111,149 +113,210 @@ func (f *isWrapper) String() string {
 
 func run(pass *analysis.Pass) (any, error) {
 	res := &Result{
-		funcs: make(map[*types.Func]Kind),
+		funcs: make(map[types.Object]Kind),
 	}
-	findPrintfLike(pass, res)
-	checkCalls(pass)
+	findPrintLike(pass, res)
+	checkCalls(pass, res)
 	return res, nil
 }
 
-type printfWrapper struct {
-	obj     *types.Func
-	fdecl   *ast.FuncDecl
-	format  *types.Var
-	args    *types.Var
+// A wrapper is a candidate print/printf wrapper function.
+//
+// We represent functions generally as types.Object, not *Func, so
+// that we can analyze anonymous functions such as
+//
+//	printf := func(format string, args ...any) {...},
+//
+// representing them by the *types.Var symbol for the local variable
+// 'printf'.
+type wrapper struct {
+	obj     types.Object     // *Func or *Var
+	curBody inspector.Cursor // for *ast.BlockStmt
+	format  *types.Var       // optional "format string" parameter in the Func{Decl,Lit}
+	args    *types.Var       // "args ...any" parameter in the Func{Decl,Lit}
 	callers []printfCaller
-	failed  bool // if true, not a printf wrapper
 }
 
 type printfCaller struct {
-	w    *printfWrapper
+	w    *wrapper
 	call *ast.CallExpr
 }
 
-// maybePrintfWrapper decides whether decl (a declared function) may be a wrapper
-// around a fmt.Printf or fmt.Print function. If so it returns a printfWrapper
-// function describing the declaration. Later processing will analyze the
-// graph of potential printf wrappers to pick out the ones that are true wrappers.
-// A function may be a Printf or Print wrapper if its last argument is ...interface{}.
-// If the next-to-last argument is a string, then this may be a Printf wrapper.
-// Otherwise it may be a Print wrapper.
-func maybePrintfWrapper(info *types.Info, decl ast.Decl) *printfWrapper {
-	// Look for functions with final argument type ...interface{}.
-	fdecl, ok := decl.(*ast.FuncDecl)
-	if !ok || fdecl.Body == nil {
-		return nil
-	}
-	fn, ok := info.Defs[fdecl.Name].(*types.Func)
-	// Type information may be incomplete.
-	if !ok {
-		return nil
-	}
-
-	sig := fn.Type().(*types.Signature)
+// formatArgsParams returns the "format string" and "args ...any"
+// parameters of a potential print or printf wrapper function.
+// (The format is nil in the print-like case.)
+func formatArgsParams(sig *types.Signature) (format, args *types.Var) {
 	if !sig.Variadic() {
-		return nil // not variadic
+		return nil, nil // not variadic
 	}
 
 	params := sig.Params()
 	nparams := params.Len() // variadic => nonzero
 
-	// Check final parameter is "args ...interface{}".
-	args := params.At(nparams - 1)
-	iface, ok := types.Unalias(args.Type().(*types.Slice).Elem()).(*types.Interface)
-	if !ok || !iface.Empty() {
-		return nil
-	}
-
 	// Is second last param 'format string'?
-	var format *types.Var
 	if nparams >= 2 {
 		if p := params.At(nparams - 2); p.Type() == types.Typ[types.String] {
 			format = p
 		}
 	}
 
-	return &printfWrapper{
-		obj:    fn,
-		fdecl:  fdecl,
-		format: format,
-		args:   args,
+	// Check final parameter is "args ...any".
+	// (variadic => slice)
+	args = params.At(nparams - 1)
+	iface, ok := types.Unalias(args.Type().(*types.Slice).Elem()).(*types.Interface)
+	if !ok || !iface.Empty() {
+		return nil, nil
 	}
+
+	return format, args
 }
 
-// findPrintfLike scans the entire package to find printf-like functions.
-func findPrintfLike(pass *analysis.Pass, res *Result) (any, error) {
-	// Gather potential wrappers and call graph between them.
-	byObj := make(map[*types.Func]*printfWrapper)
-	var wrappers []*printfWrapper
-	for _, file := range pass.Files {
-		for _, decl := range file.Decls {
-			w := maybePrintfWrapper(pass.TypesInfo, decl)
-			if w == nil {
-				continue
+// findPrintLike scans the entire package to find print or printf-like functions.
+// When it returns, all such functions have been identified.
+func findPrintLike(pass *analysis.Pass, res *Result) {
+	var (
+		inspect = pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+		info    = pass.TypesInfo
+	)
+
+	// Pass 1: gather candidate wrapper functions (and populate wrappers).
+	var (
+		wrappers []*wrapper
+		byObj    = make(map[types.Object]*wrapper)
+	)
+	for cur := range inspect.Root().Preorder((*ast.FuncDecl)(nil), (*ast.FuncLit)(nil)) {
+		var (
+			curBody inspector.Cursor // for *ast.BlockStmt
+			sig     *types.Signature
+			obj     types.Object
+		)
+		switch f := cur.Node().(type) {
+		case *ast.FuncDecl:
+			// named function or method:
+			//
+			//    func wrapf(format string, args ...any) {...}
+			if f.Body != nil {
+				curBody = cur.ChildAt(edge.FuncDecl_Body, -1)
+				obj = info.Defs[f.Name]
+				sig = obj.Type().(*types.Signature)
 			}
-			byObj[w.obj] = w
-			wrappers = append(wrappers, w)
-		}
-	}
 
-	// Walk the graph to figure out which are really printf wrappers.
-	for _, w := range wrappers {
-		// Scan function for calls that could be to other printf-like functions.
-		ast.Inspect(w.fdecl.Body, func(n ast.Node) bool {
-			if w.failed {
-				return false
+		case *ast.FuncLit:
+			// anonymous function directly assigned to a variable:
+			//
+			//    var wrapf = func(format string, args ...any) {...}
+			//    wrapf    := func(format string, args ...any) {...}
+			//    wrapf     = func(format string, args ...any) {...}
+			//
+			// The LHS may also be a struct field x.wrapf or
+			// an imported var pkg.Wrapf.
+			//
+			sig = info.TypeOf(f).(*types.Signature)
+			curBody = cur.ChildAt(edge.FuncLit_Body, -1)
+			var lhs ast.Expr
+			switch ek, idx := cur.ParentEdge(); ek {
+			case edge.ValueSpec_Values:
+				curName := cur.Parent().ChildAt(edge.ValueSpec_Names, idx)
+				lhs = curName.Node().(*ast.Ident)
+			case edge.AssignStmt_Rhs:
+				curLhs := cur.Parent().ChildAt(edge.AssignStmt_Lhs, idx)
+				lhs = curLhs.Node().(ast.Expr)
 			}
 
-			// TODO: Relax these checks; issue 26555.
-			if assign, ok := n.(*ast.AssignStmt); ok {
-				for _, lhs := range assign.Lhs {
-					if match(pass.TypesInfo, lhs, w.format) ||
-						match(pass.TypesInfo, lhs, w.args) {
-						// Modifies the format
-						// string or args in
-						// some way, so not a
-						// simple wrapper.
-						w.failed = true
-						return false
-					}
+			switch lhs := lhs.(type) {
+			case *ast.Ident:
+				// variable: wrapf = func(...)
+				obj = info.ObjectOf(lhs).(*types.Var)
+			case *ast.SelectorExpr:
+				if sel, ok := info.Selections[lhs]; ok {
+					// struct field: x.wrapf = func(...)
+					obj = sel.Obj().(*types.Var)
+				} else {
+					// imported var: pkg.Wrapf = func(...)
+					obj = info.Uses[lhs.Sel].(*types.Var)
 				}
 			}
-			if un, ok := n.(*ast.UnaryExpr); ok && un.Op == token.AND {
-				if match(pass.TypesInfo, un.X, w.format) ||
-					match(pass.TypesInfo, un.X, w.args) {
-					// Taking the address of the
-					// format string or args,
-					// so not a simple wrapper.
-					w.failed = true
-					return false
+		}
+		if obj != nil {
+			format, args := formatArgsParams(sig)
+			if args != nil {
+				// obj (the symbol for a function/method, or variable
+				// assigned to an anonymous function) is a potential
+				// print or printf wrapper.
+				//
+				// Later processing will analyze the graph of potential
+				// wrappers and their function bodies to pick out the
+				// ones that are true wrappers.
+				w := &wrapper{
+					obj:     obj,
+					curBody: curBody,
+					format:  format, // non-nil => printf
+					args:    args,
 				}
+				byObj[w.obj] = w
+				wrappers = append(wrappers, w)
 			}
+		}
+	}
 
-			call, ok := n.(*ast.CallExpr)
-			if !ok || len(call.Args) == 0 || !match(pass.TypesInfo, call.Args[len(call.Args)-1], w.args) {
-				return true
-			}
+	// Pass 2: scan the body of each wrapper function
+	// for calls to other printf-like functions.
+	//
+	// Also, reject tricky cases where the parameters
+	// are potentially mutated by AssignStmt or UnaryExpr.
+	// TODO: Relax these checks; issue 26555.
+	for _, w := range wrappers {
+	scan:
+		for cur := range w.curBody.Preorder(
+			(*ast.AssignStmt)(nil),
+			(*ast.UnaryExpr)(nil),
+			(*ast.CallExpr)(nil),
+		) {
+			switch n := cur.Node().(type) {
+			case *ast.AssignStmt:
+				// If the wrapper updates format or args
+				// it is not a simple wrapper.
+				for _, lhs := range n.Lhs {
+					if w.format != nil && match(info, lhs, w.format) ||
+						match(info, lhs, w.args) {
+						break scan
+					}
+				}
 
-			fn, kind := printfNameAndKind(pass, call)
-			if kind != 0 {
-				checkPrintfFwd(pass, w, call, kind, res)
-				return true
-			}
+			case *ast.UnaryExpr:
+				// If the wrapper computes &format or &args,
+				// it is not a simple wrapper.
+				if n.Op == token.AND &&
+					(w.format != nil && match(info, n.X, w.format) ||
+						match(info, n.X, w.args)) {
+					break scan
+				}
 
-			// If the call is to another function in this package,
-			// maybe we will find out it is printf-like later.
-			// Remember this call for later checking.
-			if fn != nil && fn.Pkg() == pass.Pkg && byObj[fn] != nil {
-				callee := byObj[fn]
-				callee.callers = append(callee.callers, printfCaller{w, call})
+			case *ast.CallExpr:
+				if len(n.Args) > 0 && match(info, n.Args[len(n.Args)-1], w.args) {
+					if callee := typeutil.Callee(pass.TypesInfo, n); callee != nil {
+
+						// Call from one wrapper candidate to another?
+						// Record the edge so that if callee is found to be
+						// a true wrapper, w will be too.
+						if w2, ok := byObj[callee]; ok {
+							w2.callers = append(w2.callers, printfCaller{w, n})
+						}
+
+						// Is the candidate a true wrapper, because it calls
+						// a known print{,f}-like function from the allowlist
+						// or an imported fact, or another wrapper found
+						// to be a true wrapper?
+						// If so, convert all w's callers to kind.
+						kind := callKind(pass, callee, res)
+						if kind != KindNone {
+							checkForward(pass, w, n, kind, res)
+						}
+					}
+				}
 			}
-
-			return true
-		})
+		}
 	}
-	return nil, nil
 }
 
 func match(info *types.Info, arg ast.Expr, param *types.Var) bool {
@@ -261,9 +324,9 @@ func match(info *types.Info, arg ast.Expr, param *types.Var) bool {
 	return ok && info.ObjectOf(id) == param
 }
 
-// checkPrintfFwd checks that a printf-forwarding wrapper is forwarding correctly.
+// checkForward checks that a forwarding wrapper is forwarding correctly.
 // It diagnoses writing fmt.Printf(format, args) instead of fmt.Printf(format, args...).
-func checkPrintfFwd(pass *analysis.Pass, w *printfWrapper, call *ast.CallExpr, kind Kind, res *Result) {
+func checkForward(pass *analysis.Pass, w *wrapper, call *ast.CallExpr, kind Kind, res *Result) {
 	matched := kind == KindPrint ||
 		kind != KindNone && len(call.Args) >= 2 && match(pass.TypesInfo, call.Args[len(call.Args)-2], w.format)
 	if !matched {
@@ -292,18 +355,39 @@ func checkPrintfFwd(pass *analysis.Pass, w *printfWrapper, call *ast.CallExpr, k
 		pass.ReportRangef(call, "missing ... in args forwarded to %s-like function", desc)
 		return
 	}
-	fn := w.obj
-	var fact isWrapper
-	if !pass.ImportObjectFact(fn, &fact) {
-		fact.Kind = kind
-		pass.ExportObjectFact(fn, &fact)
-		res.funcs[fn] = kind
+
+	// If the candidate's print{,f} status becomes known,
+	// propagate it back to all its so-far known callers.
+	if res.funcs[w.obj] != kind {
+		res.funcs[w.obj] = kind
+
+		// Export a fact.
+		// (This is a no-op for local symbols.)
+		// We can't export facts on a symbol of another package,
+		// but we can treat the symbol as a wrapper within
+		// the current analysis unit.
+		if w.obj.Pkg() == pass.Pkg {
+			// Facts are associated with origins.
+			pass.ExportObjectFact(origin(w.obj), &isWrapper{Kind: kind})
+		}
+
+		// Propagate kind back to known callers.
 		for _, caller := range w.callers {
-			checkPrintfFwd(pass, caller.w, caller.call, kind, res)
+			checkForward(pass, caller.w, caller.call, kind, res)
 		}
 	}
 }
 
+func origin(obj types.Object) types.Object {
+	switch obj := obj.(type) {
+	case *types.Func:
+		return obj.Origin()
+	case *types.Var:
+		return obj.Origin()
+	}
+	return obj
+}
+
 // isPrint records the print functions.
 // If a key ends in 'f' then it is assumed to be a formatted print.
 //
@@ -412,7 +496,7 @@ func stringConstantExpr(pass *analysis.Pass, expr ast.Expr) (string, bool) {
 
 // checkCalls triggers the print-specific checks for calls that invoke a print
 // function.
-func checkCalls(pass *analysis.Pass) {
+func checkCalls(pass *analysis.Pass, res *Result) {
 	inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
 	nodeFilter := []ast.Node{
 		(*ast.File)(nil),
@@ -426,48 +510,60 @@ func checkCalls(pass *analysis.Pass) {
 			fileVersion = versions.Lang(versions.FileVersion(pass.TypesInfo, n))
 
 		case *ast.CallExpr:
-			fn, kind := printfNameAndKind(pass, n)
-			switch kind {
-			case KindPrintf, KindErrorf:
-				checkPrintf(pass, fileVersion, kind, n, fn.FullName())
-			case KindPrint:
-				checkPrint(pass, n, fn.FullName())
+			if callee := typeutil.Callee(pass.TypesInfo, n); callee != nil {
+				kind := callKind(pass, callee, res)
+				switch kind {
+				case KindPrintf, KindErrorf:
+					checkPrintf(pass, fileVersion, kind, n, fullname(callee))
+				case KindPrint:
+					checkPrint(pass, n, fullname(callee))
+				}
 			}
 		}
 	})
 }
 
-func printfNameAndKind(pass *analysis.Pass, call *ast.CallExpr) (fn *types.Func, kind Kind) {
-	fn, _ = typeutil.Callee(pass.TypesInfo, call).(*types.Func)
-	if fn == nil {
-		return nil, 0
+func fullname(obj types.Object) string {
+	if fn, ok := obj.(*types.Func); ok {
+		return fn.FullName()
 	}
+	return obj.Name()
+}
 
-	// Facts are associated with generic declarations, not instantiations.
-	fn = fn.Origin()
-
-	_, ok := isPrint[fn.FullName()]
+// callKind returns the symbol of the called function
+// and its print/printf kind, if any.
+// (The symbol may be a var for an anonymous function.)
+// The result is memoized in res.funcs.
+func callKind(pass *analysis.Pass, obj types.Object, res *Result) Kind {
+	kind, ok := res.funcs[obj]
 	if !ok {
-		// Next look up just "printf", for use with -printf.funcs.
-		_, ok = isPrint[strings.ToLower(fn.Name())]
-	}
-	if ok {
-		if fn.FullName() == "fmt.Errorf" {
-			kind = KindErrorf
-		} else if strings.HasSuffix(fn.Name(), "f") {
-			kind = KindPrintf
+		// cache miss
+		_, ok := isPrint[fullname(obj)]
+		if !ok {
+			// Next look up just "printf", for use with -printf.funcs.
+			_, ok = isPrint[strings.ToLower(obj.Name())]
+		}
+		if ok {
+			// well-known printf functions
+			if fullname(obj) == "fmt.Errorf" {
+				kind = KindErrorf
+			} else if strings.HasSuffix(obj.Name(), "f") {
+				kind = KindPrintf
+			} else {
+				kind = KindPrint
+			}
 		} else {
-			kind = KindPrint
+			// imported wrappers
+			// Facts are associated with generic declarations, not instantiations.
+			obj = origin(obj)
+			var fact isWrapper
+			if pass.ImportObjectFact(obj, &fact) {
+				kind = fact.Kind
+			}
 		}
-		return fn, kind
+		res.funcs[obj] = kind // cache
 	}
-
-	var fact isWrapper
-	if pass.ImportObjectFact(fn, &fact) {
-		return fn, fact.Kind
-	}
-
-	return fn, KindNone
+	return kind
 }
 
 // isFormatter reports whether t could satisfy fmt.Formatter.
@@ -490,7 +586,7 @@ func isFormatter(typ types.Type) bool {
 	sig := fn.Type().(*types.Signature)
 	return sig.Params().Len() == 2 &&
 		sig.Results().Len() == 0 &&
-		analysisinternal.IsTypeNamed(sig.Params().At(0).Type(), "fmt", "State") &&
+		typesinternal.IsTypeNamed(sig.Params().At(0).Type(), "fmt", "State") &&
 		types.Identical(sig.Params().At(1).Type(), types.Typ[types.Rune])
 }
 
@@ -729,7 +825,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, rng analysis.Range, ma
 			if reason != "" {
 				details = " (" + reason + ")"
 			}
-			pass.ReportRangef(rng, "%s format %s uses non-int %s%s as argument of *", name, operation.Text, analysisinternal.Format(pass.Fset, arg), details)
+			pass.ReportRangef(rng, "%s format %s uses non-int %s%s as argument of *", name, operation.Text, astutil.Format(pass.Fset, arg), details)
 			return false
 		}
 	}
@@ -756,7 +852,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, rng analysis.Range, ma
 	}
 	arg := call.Args[verbArgIndex]
 	if isFunctionValue(pass, arg) && verb != 'p' && verb != 'T' {
-		pass.ReportRangef(rng, "%s format %s arg %s is a func value, not called", name, operation.Text, analysisinternal.Format(pass.Fset, arg))
+		pass.ReportRangef(rng, "%s format %s arg %s is a func value, not called", name, operation.Text, astutil.Format(pass.Fset, arg))
 		return false
 	}
 	if reason, ok := matchArgType(pass, v.typ, arg); !ok {
@@ -768,14 +864,14 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, rng analysis.Range, ma
 		if reason != "" {
 			details = " (" + reason + ")"
 		}
-		pass.ReportRangef(rng, "%s format %s has arg %s of wrong type %s%s", name, operation.Text, analysisinternal.Format(pass.Fset, arg), typeString, details)
+		pass.ReportRangef(rng, "%s format %s has arg %s of wrong type %s%s", name, operation.Text, astutil.Format(pass.Fset, arg), typeString, details)
 		return false
 	}
 	// Detect recursive formatting via value's String/Error methods.
 	// The '#' flag suppresses the methods, except with %x, %X, and %q.
 	if v.typ&argString != 0 && v.verb != 'T' && (!strings.Contains(operation.Flags, "#") || strings.ContainsRune("qxX", v.verb)) {
 		if methodName, ok := recursiveStringer(pass, arg); ok {
-			pass.ReportRangef(rng, "%s format %s with arg %s causes recursive %s method call", name, operation.Text, analysisinternal.Format(pass.Fset, arg), methodName)
+			pass.ReportRangef(rng, "%s format %s with arg %s causes recursive %s method call", name, operation.Text, astutil.Format(pass.Fset, arg), methodName)
 			return false
 		}
 	}
@@ -927,7 +1023,7 @@ func checkPrint(pass *analysis.Pass, call *ast.CallExpr, name string) {
 		if sel, ok := call.Args[0].(*ast.SelectorExpr); ok {
 			if x, ok := sel.X.(*ast.Ident); ok {
 				if x.Name == "os" && strings.HasPrefix(sel.Sel.Name, "Std") {
-					pass.ReportRangef(call, "%s does not take io.Writer but has first arg %s", name, analysisinternal.Format(pass.Fset, call.Args[0]))
+					pass.ReportRangef(call, "%s does not take io.Writer but has first arg %s", name, astutil.Format(pass.Fset, call.Args[0]))
 				}
 			}
 		}
@@ -961,10 +1057,10 @@ func checkPrint(pass *analysis.Pass, call *ast.CallExpr, name string) {
 	}
 	for _, arg := range args {
 		if isFunctionValue(pass, arg) {
-			pass.ReportRangef(call, "%s arg %s is a func value, not called", name, analysisinternal.Format(pass.Fset, arg))
+			pass.ReportRangef(call, "%s arg %s is a func value, not called", name, astutil.Format(pass.Fset, arg))
 		}
 		if methodName, ok := recursiveStringer(pass, arg); ok {
-			pass.ReportRangef(call, "%s arg %s causes recursive call to %s method", name, analysisinternal.Format(pass.Fset, arg), methodName)
+			pass.ReportRangef(call, "%s arg %s causes recursive call to %s method", name, astutil.Format(pass.Fset, arg), methodName)
 		}
 	}
 }
@@ -992,7 +1088,7 @@ func (ss stringSet) String() string {
 }
 
 func (ss stringSet) Set(flag string) error {
-	for _, name := range strings.Split(flag, ",") {
+	for name := range strings.SplitSeq(flag, ",") {
 		if len(name) == 0 {
 			return fmt.Errorf("empty string")
 		}
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/reflectvaluecompare/reflectvaluecompare.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/reflectvaluecompare/reflectvaluecompare.go
index d0632dbdaf..5626ac1c12 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/reflectvaluecompare/reflectvaluecompare.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/reflectvaluecompare/reflectvaluecompare.go
@@ -14,7 +14,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -50,7 +50,7 @@ func run(pass *analysis.Pass) (any, error) {
 			}
 		case *ast.CallExpr:
 			obj := typeutil.Callee(pass.TypesInfo, n)
-			if analysisinternal.IsFunctionNamed(obj, "reflect", "DeepEqual") && (isReflectValue(pass, n.Args[0]) || isReflectValue(pass, n.Args[1])) {
+			if typesinternal.IsFunctionNamed(obj, "reflect", "DeepEqual") && (isReflectValue(pass, n.Args[0]) || isReflectValue(pass, n.Args[1])) {
 				pass.ReportRangef(n, "avoid using reflect.DeepEqual with reflect.Value")
 			}
 		}
@@ -65,7 +65,7 @@ func isReflectValue(pass *analysis.Pass, e ast.Expr) bool {
 		return false
 	}
 	// See if the type is reflect.Value
-	if !analysisinternal.IsTypeNamed(tv.Type, "reflect", "Value") {
+	if !typesinternal.IsTypeNamed(tv.Type, "reflect", "Value") {
 		return false
 	}
 	if _, ok := e.(*ast.CompositeLit); ok {
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go
index 57987b3d20..366927326f 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go
@@ -20,7 +20,7 @@ import (
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/astutil"
 	"golang.org/x/tools/internal/typeparams"
 )
 
@@ -123,7 +123,7 @@ func checkLongShift(pass *analysis.Pass, node ast.Node, x, y ast.Expr) {
 		}
 	}
 	if amt >= minSize {
-		ident := analysisinternal.Format(pass.Fset, x)
+		ident := astutil.Format(pass.Fset, x)
 		qualifier := ""
 		if len(sizes) > 1 {
 			qualifier = "may be "
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
index 78a2fa5ea3..c339fa064d 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/sigchanyzer/sigchanyzer.go
@@ -20,7 +20,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -36,7 +36,7 @@ var Analyzer = &analysis.Analyzer{
 }
 
 func run(pass *analysis.Pass) (any, error) {
-	if !analysisinternal.Imports(pass.Pkg, "os/signal") {
+	if !typesinternal.Imports(pass.Pkg, "os/signal") {
 		return nil, nil // doesn't directly import signal
 	}
 
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/slog/slog.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/slog/slog.go
index c1ac960435..cc58396a02 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/slog/slog.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/slog/slog.go
@@ -20,7 +20,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/astutil"
 	"golang.org/x/tools/internal/typesinternal"
 )
 
@@ -115,10 +115,10 @@ func run(pass *analysis.Pass) (any, error) {
 				default:
 					if unknownArg == nil {
 						pass.ReportRangef(arg, "%s arg %q should be a string or a slog.Attr (possible missing key or value)",
-							shortName(fn), analysisinternal.Format(pass.Fset, arg))
+							shortName(fn), astutil.Format(pass.Fset, arg))
 					} else {
 						pass.ReportRangef(arg, "%s arg %q should probably be a string or a slog.Attr (previous arg %q cannot be a key)",
-							shortName(fn), analysisinternal.Format(pass.Fset, arg), analysisinternal.Format(pass.Fset, unknownArg))
+							shortName(fn), astutil.Format(pass.Fset, arg), astutil.Format(pass.Fset, unknownArg))
 					}
 					// Stop here so we report at most one missing key per call.
 					return
@@ -158,7 +158,7 @@ func run(pass *analysis.Pass) (any, error) {
 }
 
 func isAttr(t types.Type) bool {
-	return analysisinternal.IsTypeNamed(t, "log/slog", "Attr")
+	return typesinternal.IsTypeNamed(t, "log/slog", "Attr")
 }
 
 // shortName returns a name for the function that is shorter than FullName.
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/sortslice/analyzer.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/sortslice/analyzer.go
index 9fe0d20928..2b1882041e 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/sortslice/analyzer.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/sortslice/analyzer.go
@@ -17,7 +17,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 const Doc = `check the argument type of sort.Slice
@@ -34,7 +34,7 @@ var Analyzer = &analysis.Analyzer{
 }
 
 func run(pass *analysis.Pass) (any, error) {
-	if !analysisinternal.Imports(pass.Pkg, "sort") {
+	if !typesinternal.Imports(pass.Pkg, "sort") {
 		return nil, nil // doesn't directly import sort
 	}
 
@@ -47,7 +47,7 @@ func run(pass *analysis.Pass) (any, error) {
 	inspect.Preorder(nodeFilter, func(n ast.Node) {
 		call := n.(*ast.CallExpr)
 		obj := typeutil.Callee(pass.TypesInfo, call)
-		if !analysisinternal.IsFunctionNamed(obj, "sort", "Slice", "SliceStable", "SliceIsSorted") {
+		if !typesinternal.IsFunctionNamed(obj, "sort", "Slice", "SliceStable", "SliceIsSorted") {
 			return
 		}
 		callee := obj.(*types.Func)
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go
index 429125a8b7..3147219561 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go
@@ -10,7 +10,6 @@ import (
 	"go/ast"
 	"go/build"
 	"go/types"
-	"regexp"
 	"slices"
 
 	"golang.org/x/tools/go/analysis"
@@ -114,11 +113,6 @@ func run(pass *analysis.Pass) (any, error) {
 	return nil, nil
 }
 
-// Matches cgo generated comment as well as the proposed standard:
-//
-//	https://golang.org/s/generatedcode
-var generatedRx = regexp.MustCompile(`// .*DO NOT EDIT\.?`)
-
 // origin returns the original uninstantiated symbol for obj.
 func origin(obj types.Object) types.Object {
 	switch obj := obj.(type) {
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
index 7dbff1e4d8..7a02d85ce7 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
@@ -15,7 +15,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/refactor"
 	"golang.org/x/tools/internal/typeparams"
 	"golang.org/x/tools/internal/typesinternal"
 )
@@ -198,7 +198,7 @@ func run(pass *analysis.Pass) (any, error) {
 		// the type has methods, as some {String,GoString,Format}
 		// may change the behavior of fmt.Sprint.
 		if len(ttypes) == 1 && len(vtypes) == 1 && types.NewMethodSet(V0).Len() == 0 {
-			_, prefix, importEdits := analysisinternal.AddImport(pass.TypesInfo, file, "fmt", "fmt", "Sprint", arg.Pos())
+			prefix, importEdits := refactor.AddImport(pass.TypesInfo, file, "fmt", "fmt", "Sprint", arg.Pos())
 			if types.Identical(T0, types.Typ[types.String]) {
 				// string(x) -> fmt.Sprint(x)
 				addFix("Format the number as a decimal", append(importEdits,
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
index cc90f7335e..826add2c44 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
@@ -17,6 +17,8 @@ import (
 	"strconv"
 	"strings"
 
+	"fmt"
+
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/ast/inspector"
@@ -100,7 +102,11 @@ func checkCanonicalFieldTag(pass *analysis.Pass, field *types.Var, tag string, s
 	}
 
 	if err := validateStructTag(tag); err != nil {
-		pass.Reportf(field.Pos(), "struct field tag %#q not compatible with reflect.StructTag.Get: %s", tag, err)
+		pass.Report(analysis.Diagnostic{
+			Pos:     field.Pos(),
+			End:     field.Pos() + token.Pos(len(field.Name())),
+			Message: fmt.Sprintf("struct field tag %#q not compatible with reflect.StructTag.Get: %s", tag, err),
+		})
 	}
 
 	// Check for use of json or xml tags with unexported fields.
@@ -122,7 +128,11 @@ func checkCanonicalFieldTag(pass *analysis.Pass, field *types.Var, tag string, s
 		// ignored.
 		case "", "-":
 		default:
-			pass.Reportf(field.Pos(), "struct field %s has %s tag but is not exported", field.Name(), enc)
+			pass.Report(analysis.Diagnostic{
+				Pos:     field.Pos(),
+				End:     field.Pos() + token.Pos(len(field.Name())),
+				Message: fmt.Sprintf("struct field %s has %s tag but is not exported", field.Name(), enc),
+			})
 			return
 		}
 	}
@@ -190,7 +200,11 @@ func checkTagDuplicates(pass *analysis.Pass, tag, key string, nearest, field *ty
 			alsoPos.Filename = rel
 		}
 
-		pass.Reportf(nearest.Pos(), "struct field %s repeats %s tag %q also at %s", field.Name(), key, val, alsoPos)
+		pass.Report(analysis.Diagnostic{
+			Pos:     nearest.Pos(),
+			End:     nearest.Pos() + token.Pos(len(nearest.Name())),
+			Message: fmt.Sprintf("struct field %s repeats %s tag %q also at %s", field.Name(), key, val, alsoPos),
+		})
 	} else {
 		seen.Set(key, val, level, field.Pos())
 	}
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go
index 360ba0e74d..400a6960c6 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go
@@ -16,7 +16,6 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
 	"golang.org/x/tools/internal/typesinternal"
 )
 
@@ -40,7 +39,7 @@ var Analyzer = &analysis.Analyzer{
 func run(pass *analysis.Pass) (any, error) {
 	inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
 
-	if !analysisinternal.Imports(pass.Pkg, "testing") {
+	if !typesinternal.Imports(pass.Pkg, "testing") {
 		return nil, nil
 	}
 
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go
index d4e9b02532..1c0e92d01d 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go
@@ -17,6 +17,7 @@ import (
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -258,7 +259,7 @@ func isTestingType(typ types.Type, testingType string) bool {
 	if !ok {
 		return false
 	}
-	return analysisinternal.IsTypeNamed(ptr.Elem(), "testing", testingType)
+	return typesinternal.IsTypeNamed(ptr.Elem(), "testing", testingType)
 }
 
 // Validate that fuzz target function's arguments are of accepted types.
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/timeformat/timeformat.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/timeformat/timeformat.go
index 4fdbb2b541..db91d37c12 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/timeformat/timeformat.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/timeformat/timeformat.go
@@ -19,7 +19,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 const badFormat = "2006-02-01"
@@ -50,8 +50,8 @@ func run(pass *analysis.Pass) (any, error) {
 	inspect.Preorder(nodeFilter, func(n ast.Node) {
 		call := n.(*ast.CallExpr)
 		obj := typeutil.Callee(pass.TypesInfo, call)
-		if !analysisinternal.IsMethodNamed(obj, "time", "Time", "Format") &&
-			!analysisinternal.IsFunctionNamed(obj, "time", "Parse") {
+		if !typesinternal.IsMethodNamed(obj, "time", "Time", "Format") &&
+			!typesinternal.IsFunctionNamed(obj, "time", "Parse") {
 			return
 		}
 		if len(call.Args) > 0 {
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/unsafeptr/unsafeptr.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/unsafeptr/unsafeptr.go
index 57c6da64ff..778010bc0d 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/unsafeptr/unsafeptr.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/unsafeptr/unsafeptr.go
@@ -16,7 +16,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/inspect"
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -105,7 +105,7 @@ func isSafeUintptr(info *types.Info, x ast.Expr) bool {
 		}
 		switch sel.Sel.Name {
 		case "Pointer", "UnsafeAddr":
-			if analysisinternal.IsTypeNamed(info.Types[sel.X].Type, "reflect", "Value") {
+			if typesinternal.IsTypeNamed(info.Types[sel.X].Type, "reflect", "Value") {
 				return true
 			}
 		}
@@ -153,5 +153,5 @@ func hasBasicType(info *types.Info, x ast.Expr, kind types.BasicKind) bool {
 
 // isReflectHeader reports whether t is reflect.SliceHeader or reflect.StringHeader.
 func isReflectHeader(t types.Type) bool {
-	return analysisinternal.IsTypeNamed(t, "reflect", "SliceHeader", "StringHeader")
+	return typesinternal.IsTypeNamed(t, "reflect", "SliceHeader", "StringHeader")
 }
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go
index 556ffed7d9..ed4cf7ae0b 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go
@@ -188,7 +188,7 @@ func (ss *stringSetFlag) String() string {
 func (ss *stringSetFlag) Set(s string) error {
 	m := make(map[string]bool) // clobber previous value
 	if s != "" {
-		for _, name := range strings.Split(s, ",") {
+		for name := range strings.SplitSeq(s, ",") {
 			if name == "" {
 				continue // TODO: report error? proceed?
 			}
diff --git a/tools/vendor/golang.org/x/tools/go/analysis/passes/waitgroup/waitgroup.go b/tools/vendor/golang.org/x/tools/go/analysis/passes/waitgroup/waitgroup.go
index 14c6986eab..5ed1814f77 100644
--- a/tools/vendor/golang.org/x/tools/go/analysis/passes/waitgroup/waitgroup.go
+++ b/tools/vendor/golang.org/x/tools/go/analysis/passes/waitgroup/waitgroup.go
@@ -16,7 +16,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 //go:embed doc.go
@@ -31,7 +31,7 @@ var Analyzer = &analysis.Analyzer{
 }
 
 func run(pass *analysis.Pass) (any, error) {
-	if !analysisinternal.Imports(pass.Pkg, "sync") {
+	if !typesinternal.Imports(pass.Pkg, "sync") {
 		return nil, nil // doesn't directly import sync
 	}
 
@@ -44,7 +44,7 @@ func run(pass *analysis.Pass) (any, error) {
 		if push {
 			call := n.(*ast.CallExpr)
 			obj := typeutil.Callee(pass.TypesInfo, call)
-			if analysisinternal.IsMethodNamed(obj, "sync", "WaitGroup", "Add") &&
+			if typesinternal.IsMethodNamed(obj, "sync", "WaitGroup", "Add") &&
 				hasSuffix(stack, wantSuffix) &&
 				backindex(stack, 1) == backindex(stack, 2).(*ast.BlockStmt).List[0] { // ExprStmt must be Block's first stmt
 
diff --git a/tools/vendor/golang.org/x/tools/go/ast/astutil/imports.go b/tools/vendor/golang.org/x/tools/go/ast/astutil/imports.go
index 5e5601aa46..5bacc0fa49 100644
--- a/tools/vendor/golang.org/x/tools/go/ast/astutil/imports.go
+++ b/tools/vendor/golang.org/x/tools/go/ast/astutil/imports.go
@@ -209,48 +209,46 @@ func DeleteImport(fset *token.FileSet, f *ast.File, path string) (deleted bool)
 // DeleteNamedImport deletes the import with the given name and path from the file f, if present.
 // If there are duplicate import declarations, all matching ones are deleted.
 func DeleteNamedImport(fset *token.FileSet, f *ast.File, name, path string) (deleted bool) {
-	var delspecs []*ast.ImportSpec
-	var delcomments []*ast.CommentGroup
+	var (
+		delspecs    = make(map[*ast.ImportSpec]bool)
+		delcomments = make(map[*ast.CommentGroup]bool)
+	)
 
 	// Find the import nodes that import path, if any.
 	for i := 0; i < len(f.Decls); i++ {
-		decl := f.Decls[i]
-		gen, ok := decl.(*ast.GenDecl)
+		gen, ok := f.Decls[i].(*ast.GenDecl)
 		if !ok || gen.Tok != token.IMPORT {
 			continue
 		}
 		for j := 0; j < len(gen.Specs); j++ {
-			spec := gen.Specs[j]
-			impspec := spec.(*ast.ImportSpec)
+			impspec := gen.Specs[j].(*ast.ImportSpec)
 			if importName(impspec) != name || importPath(impspec) != path {
 				continue
 			}
 
 			// We found an import spec that imports path.
 			// Delete it.
-			delspecs = append(delspecs, impspec)
+			delspecs[impspec] = true
 			deleted = true
-			copy(gen.Specs[j:], gen.Specs[j+1:])
-			gen.Specs = gen.Specs[:len(gen.Specs)-1]
+			gen.Specs = slices.Delete(gen.Specs, j, j+1)
 
 			// If this was the last import spec in this decl,
 			// delete the decl, too.
 			if len(gen.Specs) == 0 {
-				copy(f.Decls[i:], f.Decls[i+1:])
-				f.Decls = f.Decls[:len(f.Decls)-1]
+				f.Decls = slices.Delete(f.Decls, i, i+1)
 				i--
 				break
 			} else if len(gen.Specs) == 1 {
 				if impspec.Doc != nil {
-					delcomments = append(delcomments, impspec.Doc)
+					delcomments[impspec.Doc] = true
 				}
 				if impspec.Comment != nil {
-					delcomments = append(delcomments, impspec.Comment)
+					delcomments[impspec.Comment] = true
 				}
 				for _, cg := range f.Comments {
 					// Found comment on the same line as the import spec.
 					if cg.End() < impspec.Pos() && fset.Position(cg.End()).Line == fset.Position(impspec.Pos()).Line {
-						delcomments = append(delcomments, cg)
+						delcomments[cg] = true
 						break
 					}
 				}
@@ -294,38 +292,21 @@ func DeleteNamedImport(fset *token.FileSet, f *ast.File, name, path string) (del
 	}
 
 	// Delete imports from f.Imports.
-	for i := 0; i < len(f.Imports); i++ {
-		imp := f.Imports[i]
-		for j, del := range delspecs {
-			if imp == del {
-				copy(f.Imports[i:], f.Imports[i+1:])
-				f.Imports = f.Imports[:len(f.Imports)-1]
-				copy(delspecs[j:], delspecs[j+1:])
-				delspecs = delspecs[:len(delspecs)-1]
-				i--
-				break
-			}
-		}
+	before := len(f.Imports)
+	f.Imports = slices.DeleteFunc(f.Imports, func(imp *ast.ImportSpec) bool {
+		_, ok := delspecs[imp]
+		return ok
+	})
+	if len(f.Imports)+len(delspecs) != before {
+		// This can happen when the AST is invalid (i.e. imports differ between f.Decls and f.Imports).
+		panic(fmt.Sprintf("deleted specs from Decls but not Imports: %v", delspecs))
 	}
 
 	// Delete comments from f.Comments.
-	for i := 0; i < len(f.Comments); i++ {
-		cg := f.Comments[i]
-		for j, del := range delcomments {
-			if cg == del {
-				copy(f.Comments[i:], f.Comments[i+1:])
-				f.Comments = f.Comments[:len(f.Comments)-1]
-				copy(delcomments[j:], delcomments[j+1:])
-				delcomments = delcomments[:len(delcomments)-1]
-				i--
-				break
-			}
-		}
-	}
-
-	if len(delspecs) > 0 {
-		panic(fmt.Sprintf("deleted specs from Decls but not Imports: %v", delspecs))
-	}
+	f.Comments = slices.DeleteFunc(f.Comments, func(cg *ast.CommentGroup) bool {
+		_, ok := delcomments[cg]
+		return ok
+	})
 
 	return
 }
diff --git a/tools/vendor/golang.org/x/tools/go/buildutil/allpackages.go b/tools/vendor/golang.org/x/tools/go/buildutil/allpackages.go
index 32886a7175..8a7f0fccc6 100644
--- a/tools/vendor/golang.org/x/tools/go/buildutil/allpackages.go
+++ b/tools/vendor/golang.org/x/tools/go/buildutil/allpackages.go
@@ -175,7 +175,7 @@ func ExpandPatterns(ctxt *build.Context, patterns []string) map[string]bool {
 			for _, pkg := range all {
 				doPkg(pkg, neg)
 			}
-		} else if dir := strings.TrimSuffix(arg, "/..."); dir != arg {
+		} else if dir, ok := strings.CutSuffix(arg, "/..."); ok {
 			// dir/... matches all packages beneath dir
 			for _, pkg := range all {
 				if strings.HasPrefix(pkg, dir) &&
diff --git a/tools/vendor/golang.org/x/tools/go/buildutil/tags.go b/tools/vendor/golang.org/x/tools/go/buildutil/tags.go
index 410c8e72d4..f66cd5df28 100644
--- a/tools/vendor/golang.org/x/tools/go/buildutil/tags.go
+++ b/tools/vendor/golang.org/x/tools/go/buildutil/tags.go
@@ -43,7 +43,7 @@ func (v *TagsFlag) Set(s string) error {
 
 	// Starting in Go 1.13, the -tags flag is a comma-separated list of build tags.
 	*v = []string{}
-	for _, s := range strings.Split(s, ",") {
+	for s := range strings.SplitSeq(s, ",") {
 		if s != "" {
 			*v = append(*v, s)
 		}
diff --git a/tools/vendor/golang.org/x/tools/go/cfg/cfg.go b/tools/vendor/golang.org/x/tools/go/cfg/cfg.go
index 1f20871605..29a39f698c 100644
--- a/tools/vendor/golang.org/x/tools/go/cfg/cfg.go
+++ b/tools/vendor/golang.org/x/tools/go/cfg/cfg.go
@@ -53,7 +53,6 @@ import (
 //
 // The entry point is Blocks[0]; there may be multiple return blocks.
 type CFG struct {
-	fset   *token.FileSet
 	Blocks []*Block // block[0] is entry; order otherwise undefined
 }
 
diff --git a/tools/vendor/golang.org/x/tools/go/packages/golist.go b/tools/vendor/golang.org/x/tools/go/packages/golist.go
index 89f89dd2dc..680a70ca8f 100644
--- a/tools/vendor/golang.org/x/tools/go/packages/golist.go
+++ b/tools/vendor/golang.org/x/tools/go/packages/golist.go
@@ -364,12 +364,6 @@ type jsonPackage struct {
 	DepsErrors []*packagesinternal.PackageError
 }
 
-type jsonPackageError struct {
-	ImportStack []string
-	Pos         string
-	Err         string
-}
-
 func otherFiles(p *jsonPackage) [][]string {
 	return [][]string{p.CFiles, p.CXXFiles, p.MFiles, p.HFiles, p.FFiles, p.SFiles, p.SwigFiles, p.SwigCXXFiles, p.SysoFiles}
 }
diff --git a/tools/vendor/golang.org/x/tools/go/ssa/builder.go b/tools/vendor/golang.org/x/tools/go/ssa/builder.go
index a5ef8fb40d..41857ffbb9 100644
--- a/tools/vendor/golang.org/x/tools/go/ssa/builder.go
+++ b/tools/vendor/golang.org/x/tools/go/ssa/builder.go
@@ -380,7 +380,13 @@ func (b *builder) builtin(fn *Function, obj *types.Builtin, args []ast.Expr, typ
 		}
 
 	case "new":
-		return emitNew(fn, typeparams.MustDeref(typ), pos, "new")
+		alloc := emitNew(fn, typeparams.MustDeref(typ), pos, "new")
+		if !fn.info.Types[args[0]].IsType() {
+			// new(expr), requires go1.26
+			v := b.expr(fn, args[0])
+			emitStore(fn, alloc, v, pos)
+		}
+		return alloc
 
 	case "len", "cap":
 		// Special case: len or cap of an array or *array is
diff --git a/tools/vendor/golang.org/x/tools/go/ssa/subst.go b/tools/vendor/golang.org/x/tools/go/ssa/subst.go
index 362dce1267..2c465ec0ae 100644
--- a/tools/vendor/golang.org/x/tools/go/ssa/subst.go
+++ b/tools/vendor/golang.org/x/tools/go/ssa/subst.go
@@ -567,76 +567,3 @@ func (subst *subster) signature(t *types.Signature) types.Type {
 	}
 	return t
 }
-
-// reaches returns true if a type t reaches any type t' s.t. c[t'] == true.
-// It updates c to cache results.
-//
-// reaches is currently only part of the wellFormed debug logic, and
-// in practice c is initially only type parameters. It is not currently
-// relied on in production.
-func reaches(t types.Type, c map[types.Type]bool) (res bool) {
-	if c, ok := c[t]; ok {
-		return c
-	}
-
-	// c is populated with temporary false entries as types are visited.
-	// This avoids repeat visits and break cycles.
-	c[t] = false
-	defer func() {
-		c[t] = res
-	}()
-
-	switch t := t.(type) {
-	case *types.TypeParam, *types.Basic:
-		return false
-	case *types.Array:
-		return reaches(t.Elem(), c)
-	case *types.Slice:
-		return reaches(t.Elem(), c)
-	case *types.Pointer:
-		return reaches(t.Elem(), c)
-	case *types.Tuple:
-		for i := 0; i < t.Len(); i++ {
-			if reaches(t.At(i).Type(), c) {
-				return true
-			}
-		}
-	case *types.Struct:
-		for i := 0; i < t.NumFields(); i++ {
-			if reaches(t.Field(i).Type(), c) {
-				return true
-			}
-		}
-	case *types.Map:
-		return reaches(t.Key(), c) || reaches(t.Elem(), c)
-	case *types.Chan:
-		return reaches(t.Elem(), c)
-	case *types.Signature:
-		if t.Recv() != nil && reaches(t.Recv().Type(), c) {
-			return true
-		}
-		return reaches(t.Params(), c) || reaches(t.Results(), c)
-	case *types.Union:
-		for i := 0; i < t.Len(); i++ {
-			if reaches(t.Term(i).Type(), c) {
-				return true
-			}
-		}
-	case *types.Interface:
-		for i := 0; i < t.NumEmbeddeds(); i++ {
-			if reaches(t.Embedded(i), c) {
-				return true
-			}
-		}
-		for i := 0; i < t.NumExplicitMethods(); i++ {
-			if reaches(t.ExplicitMethod(i).Type(), c) {
-				return true
-			}
-		}
-	case *types.Named, *types.Alias:
-		return reaches(t.Underlying(), c)
-	default:
-		panic("unreachable")
-	}
-	return false
-}
diff --git a/tools/vendor/golang.org/x/tools/imports/forward.go b/tools/vendor/golang.org/x/tools/imports/forward.go
index cb6db8893f..22ae777726 100644
--- a/tools/vendor/golang.org/x/tools/imports/forward.go
+++ b/tools/vendor/golang.org/x/tools/imports/forward.go
@@ -69,9 +69,3 @@ func Process(filename string, src []byte, opt *Options) ([]byte, error) {
 	}
 	return intimp.Process(filename, src, intopt)
 }
-
-// VendorlessPath returns the devendorized version of the import path ipath.
-// For example, VendorlessPath("foo/bar/vendor/a/b") returns "a/b".
-func VendorlessPath(ipath string) string {
-	return intimp.VendorlessPath(ipath)
-}
diff --git a/tools/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go b/tools/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go
index e48dc3f336..2b4a8ebb6e 100644
--- a/tools/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go
+++ b/tools/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go
@@ -7,96 +7,23 @@
 package analysisinternal
 
 import (
-	"bytes"
 	"cmp"
 	"fmt"
 	"go/ast"
-	"go/printer"
-	"go/scanner"
 	"go/token"
 	"go/types"
-	"iter"
-	pathpkg "path"
 	"slices"
 	"strings"
 
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/internal/moreiters"
-	"golang.org/x/tools/internal/typesinternal"
 )
 
-// Deprecated: this heuristic is ill-defined.
-// TODO(adonovan): move to sole use in gopls/internal/cache.
-func TypeErrorEndPos(fset *token.FileSet, src []byte, start token.Pos) token.Pos {
-	// Get the end position for the type error.
-	file := fset.File(start)
-	if file == nil {
-		return start
-	}
-	if offset := file.PositionFor(start, false).Offset; offset > len(src) {
-		return start
-	} else {
-		src = src[offset:]
-	}
-
-	// Attempt to find a reasonable end position for the type error.
-	//
-	// TODO(rfindley): the heuristic implemented here is unclear. It looks like
-	// it seeks the end of the primary operand starting at start, but that is not
-	// quite implemented (for example, given a func literal this heuristic will
-	// return the range of the func keyword).
-	//
-	// We should formalize this heuristic, or deprecate it by finally proposing
-	// to add end position to all type checker errors.
-	//
-	// Nevertheless, ensure that the end position at least spans the current
-	// token at the cursor (this was golang/go#69505).
-	end := start
-	{
-		var s scanner.Scanner
-		fset := token.NewFileSet()
-		f := fset.AddFile("", fset.Base(), len(src))
-		s.Init(f, src, nil /* no error handler */, scanner.ScanComments)
-		pos, tok, lit := s.Scan()
-		if tok != token.SEMICOLON && token.Pos(f.Base()) <= pos && pos <= token.Pos(f.Base()+f.Size()) {
-			off := file.Offset(pos) + len(lit)
-			src = src[off:]
-			end += token.Pos(off)
-		}
-	}
-
-	// Look for bytes that might terminate the current operand. See note above:
-	// this is imprecise.
-	if width := bytes.IndexAny(src, " \n,():;[]+-*/"); width > 0 {
-		end += token.Pos(width)
-	}
-	return end
-}
-
-// WalkASTWithParent walks the AST rooted at n. The semantics are
-// similar to ast.Inspect except it does not call f(nil).
-func WalkASTWithParent(n ast.Node, f func(n ast.Node, parent ast.Node) bool) {
-	var ancestors []ast.Node
-	ast.Inspect(n, func(n ast.Node) (recurse bool) {
-		if n == nil {
-			ancestors = ancestors[:len(ancestors)-1]
-			return false
-		}
-
-		var parent ast.Node
-		if len(ancestors) > 0 {
-			parent = ancestors[len(ancestors)-1]
-		}
-		ancestors = append(ancestors, n)
-		return f(n, parent)
-	})
-}
-
 // MatchingIdents finds the names of all identifiers in 'node' that match any of the given types.
 // 'pos' represents the position at which the identifiers may be inserted. 'pos' must be within
 // the scope of each of identifier we select. Otherwise, we will insert a variable at 'pos' that
 // is unrecognized.
+//
+// TODO(adonovan): this is only used by gopls/internal/analysis/fill{returns,struct}. Move closer.
 func MatchingIdents(typs []types.Type, node ast.Node, pos token.Pos, info *types.Info, pkg *types.Package) map[types.Type][]string {
 
 	// Initialize matches to contain the variable types we are searching for.
@@ -212,185 +139,6 @@ func CheckReadable(pass *analysis.Pass, filename string) error {
 	return fmt.Errorf("Pass.ReadFile: %s is not among OtherFiles, IgnoredFiles, or names of Files", filename)
 }
 
-// AddImport checks whether this file already imports pkgpath and
-// that import is in scope at pos. If so, it returns the name under
-// which it was imported and a zero edit. Otherwise, it adds a new
-// import of pkgpath, using a name derived from the preferred name,
-// and returns the chosen name, a prefix to be concatenated with member
-// to form a qualified name, and the edit for the new import.
-//
-// In the special case that pkgpath is dot-imported then member, the
-// identifier for which the import is being added, is consulted. If
-// member is not shadowed at pos, AddImport returns (".", "", nil).
-// (AddImport accepts the caller's implicit claim that the imported
-// package declares member.)
-//
-// It does not mutate its arguments.
-func AddImport(info *types.Info, file *ast.File, preferredName, pkgpath, member string, pos token.Pos) (name, prefix string, newImport []analysis.TextEdit) {
-	// Find innermost enclosing lexical block.
-	scope := info.Scopes[file].Innermost(pos)
-	if scope == nil {
-		panic("no enclosing lexical block")
-	}
-
-	// Is there an existing import of this package?
-	// If so, are we in its scope? (not shadowed)
-	for _, spec := range file.Imports {
-		pkgname := info.PkgNameOf(spec)
-		if pkgname != nil && pkgname.Imported().Path() == pkgpath {
-			name = pkgname.Name()
-			if name == "." {
-				// The scope of ident must be the file scope.
-				if s, _ := scope.LookupParent(member, pos); s == info.Scopes[file] {
-					return name, "", nil
-				}
-			} else if _, obj := scope.LookupParent(name, pos); obj == pkgname {
-				return name, name + ".", nil
-			}
-		}
-	}
-
-	// We must add a new import.
-	// Ensure we have a fresh name.
-	newName := FreshName(scope, pos, preferredName)
-
-	// Create a new import declaration either before the first existing
-	// declaration (which must exist), including its comments; or
-	// inside the declaration, if it is an import group.
-	//
-	// Use a renaming import whenever the preferred name is not
-	// available, or the chosen name does not match the last
-	// segment of its path.
-	newText := fmt.Sprintf("%q", pkgpath)
-	if newName != preferredName || newName != pathpkg.Base(pkgpath) {
-		newText = fmt.Sprintf("%s %q", newName, pkgpath)
-	}
-	decl0 := file.Decls[0]
-	var before ast.Node = decl0
-	switch decl0 := decl0.(type) {
-	case *ast.GenDecl:
-		if decl0.Doc != nil {
-			before = decl0.Doc
-		}
-	case *ast.FuncDecl:
-		if decl0.Doc != nil {
-			before = decl0.Doc
-		}
-	}
-	// If the first decl is an import group, add this new import at the end.
-	if gd, ok := before.(*ast.GenDecl); ok && gd.Tok == token.IMPORT && gd.Rparen.IsValid() {
-		pos = gd.Rparen
-		// if it's a std lib, we should append it at the beginning of import group.
-		// otherwise we may see the std package is put at the last behind a 3rd module which doesn't follow our convention.
-		// besides, gofmt doesn't help in this case.
-		if IsStdPackage(pkgpath) && len(gd.Specs) != 0 {
-			pos = gd.Specs[0].Pos()
-			newText += "\n\t"
-		} else {
-			newText = "\t" + newText + "\n"
-		}
-	} else {
-		pos = before.Pos()
-		newText = "import " + newText + "\n\n"
-	}
-	return newName, newName + ".", []analysis.TextEdit{{
-		Pos:     pos,
-		End:     pos,
-		NewText: []byte(newText),
-	}}
-}
-
-// FreshName returns the name of an identifier that is undefined
-// at the specified position, based on the preferred name.
-func FreshName(scope *types.Scope, pos token.Pos, preferred string) string {
-	newName := preferred
-	for i := 0; ; i++ {
-		if _, obj := scope.LookupParent(newName, pos); obj == nil {
-			break // fresh
-		}
-		newName = fmt.Sprintf("%s%d", preferred, i)
-	}
-	return newName
-}
-
-// Format returns a string representation of the node n.
-func Format(fset *token.FileSet, n ast.Node) string {
-	var buf strings.Builder
-	printer.Fprint(&buf, fset, n) // ignore errors
-	return buf.String()
-}
-
-// Imports returns true if path is imported by pkg.
-func Imports(pkg *types.Package, path string) bool {
-	for _, imp := range pkg.Imports() {
-		if imp.Path() == path {
-			return true
-		}
-	}
-	return false
-}
-
-// IsTypeNamed reports whether t is (or is an alias for) a
-// package-level defined type with the given package path and one of
-// the given names. It returns false if t is nil.
-//
-// This function avoids allocating the concatenation of "pkg.Name",
-// which is important for the performance of syntax matching.
-func IsTypeNamed(t types.Type, pkgPath string, names ...string) bool {
-	if named, ok := types.Unalias(t).(*types.Named); ok {
-		tname := named.Obj()
-		return tname != nil &&
-			typesinternal.IsPackageLevel(tname) &&
-			tname.Pkg().Path() == pkgPath &&
-			slices.Contains(names, tname.Name())
-	}
-	return false
-}
-
-// IsPointerToNamed reports whether t is (or is an alias for) a pointer to a
-// package-level defined type with the given package path and one of the given
-// names. It returns false if t is not a pointer type.
-func IsPointerToNamed(t types.Type, pkgPath string, names ...string) bool {
-	r := typesinternal.Unpointer(t)
-	if r == t {
-		return false
-	}
-	return IsTypeNamed(r, pkgPath, names...)
-}
-
-// IsFunctionNamed reports whether obj is a package-level function
-// defined in the given package and has one of the given names.
-// It returns false if obj is nil.
-//
-// This function avoids allocating the concatenation of "pkg.Name",
-// which is important for the performance of syntax matching.
-func IsFunctionNamed(obj types.Object, pkgPath string, names ...string) bool {
-	f, ok := obj.(*types.Func)
-	return ok &&
-		typesinternal.IsPackageLevel(obj) &&
-		f.Pkg().Path() == pkgPath &&
-		f.Type().(*types.Signature).Recv() == nil &&
-		slices.Contains(names, f.Name())
-}
-
-// IsMethodNamed reports whether obj is a method defined on a
-// package-level type with the given package and type name, and has
-// one of the given names. It returns false if obj is nil.
-//
-// This function avoids allocating the concatenation of "pkg.TypeName.Name",
-// which is important for the performance of syntax matching.
-func IsMethodNamed(obj types.Object, pkgPath string, typeName string, names ...string) bool {
-	if fn, ok := obj.(*types.Func); ok {
-		if recv := fn.Type().(*types.Signature).Recv(); recv != nil {
-			_, T := typesinternal.ReceiverNamed(recv)
-			return T != nil &&
-				IsTypeNamed(T, pkgPath, typeName) &&
-				slices.Contains(names, fn.Name())
-		}
-	}
-	return false
-}
-
 // ValidateFixes validates the set of fixes for a single diagnostic.
 // Any error indicates a bug in the originating analyzer.
 //
@@ -493,6 +241,20 @@ func validateFix(fset *token.FileSet, fix *analysis.SuggestedFix) error {
 	return nil
 }
 
+// Range returns an [analysis.Range] for the specified start and end positions.
+func Range(pos, end token.Pos) analysis.Range {
+	return tokenRange{pos, end}
+}
+
+// tokenRange is an implementation of the [analysis.Range] interface.
+type tokenRange struct{ StartPos, EndPos token.Pos }
+
+func (r tokenRange) Pos() token.Pos { return r.StartPos }
+func (r tokenRange) End() token.Pos { return r.EndPos }
+
+// TODO(adonovan): the import-related functions below don't depend on
+// analysis (or even on go/types or go/ast). Move somewhere more logical.
+
 // CanImport reports whether one package is allowed to import another.
 //
 // TODO(adonovan): allow customization of the accessibility relation
@@ -520,133 +282,6 @@ func CanImport(from, to string) bool {
 	return true
 }
 
-// DeleteStmt returns the edits to remove the [ast.Stmt] identified by
-// curStmt, if it is contained within a BlockStmt, CaseClause,
-// CommClause, or is the STMT in switch STMT; ... {...}. It returns nil otherwise.
-func DeleteStmt(fset *token.FileSet, curStmt inspector.Cursor) []analysis.TextEdit {
-	stmt := curStmt.Node().(ast.Stmt)
-	// if the stmt is on a line by itself delete the whole line
-	// otherwise just delete the statement.
-
-	// this logic would be a lot simpler with the file contents, and somewhat simpler
-	// if the cursors included the comments.
-
-	tokFile := fset.File(stmt.Pos())
-	lineOf := tokFile.Line
-	stmtStartLine, stmtEndLine := lineOf(stmt.Pos()), lineOf(stmt.End())
-
-	var from, to token.Pos
-	// bounds of adjacent syntax/comments on same line, if any
-	limits := func(left, right token.Pos) {
-		if lineOf(left) == stmtStartLine {
-			from = left
-		}
-		if lineOf(right) == stmtEndLine {
-			to = right
-		}
-	}
-	// TODO(pjw): there are other places a statement might be removed:
-	// IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" ( IfStmt | Block ) ] .
-	// (removing the blocks requires more rewriting than this routine would do)
-	// CommCase   = "case" ( SendStmt | RecvStmt ) | "default" .
-	// (removing the stmt requires more rewriting, and it's unclear what the user means)
-	switch parent := curStmt.Parent().Node().(type) {
-	case *ast.SwitchStmt:
-		limits(parent.Switch, parent.Body.Lbrace)
-	case *ast.TypeSwitchStmt:
-		limits(parent.Switch, parent.Body.Lbrace)
-		if parent.Assign == stmt {
-			return nil // don't let the user break the type switch
-		}
-	case *ast.BlockStmt:
-		limits(parent.Lbrace, parent.Rbrace)
-	case *ast.CommClause:
-		limits(parent.Colon, curStmt.Parent().Parent().Node().(*ast.BlockStmt).Rbrace)
-		if parent.Comm == stmt {
-			return nil // maybe the user meant to remove the entire CommClause?
-		}
-	case *ast.CaseClause:
-		limits(parent.Colon, curStmt.Parent().Parent().Node().(*ast.BlockStmt).Rbrace)
-	case *ast.ForStmt:
-		limits(parent.For, parent.Body.Lbrace)
-
-	default:
-		return nil // not one of ours
-	}
-
-	if prev, found := curStmt.PrevSibling(); found && lineOf(prev.Node().End()) == stmtStartLine {
-		from = prev.Node().End() // preceding statement ends on same line
-	}
-	if next, found := curStmt.NextSibling(); found && lineOf(next.Node().Pos()) == stmtEndLine {
-		to = next.Node().Pos() // following statement begins on same line
-	}
-	// and now for the comments
-Outer:
-	for _, cg := range enclosingFile(curStmt).Comments {
-		for _, co := range cg.List {
-			if lineOf(co.End()) < stmtStartLine {
-				continue
-			} else if lineOf(co.Pos()) > stmtEndLine {
-				break Outer // no more are possible
-			}
-			if lineOf(co.End()) == stmtStartLine && co.End() < stmt.Pos() {
-				if !from.IsValid() || co.End() > from {
-					from = co.End()
-					continue // maybe there are more
-				}
-			}
-			if lineOf(co.Pos()) == stmtEndLine && co.Pos() > stmt.End() {
-				if !to.IsValid() || co.Pos() < to {
-					to = co.Pos()
-					continue // maybe there are more
-				}
-			}
-		}
-	}
-	// if either from or to is valid, just remove the statement
-	// otherwise remove the line
-	edit := analysis.TextEdit{Pos: stmt.Pos(), End: stmt.End()}
-	if from.IsValid() || to.IsValid() {
-		// remove just the statement.
-		// we can't tell if there is a ; or whitespace right after the statement
-		// ideally we'd like to remove the former and leave the latter
-		// (if gofmt has run, there likely won't be a ;)
-		// In type switches we know there's a semicolon somewhere after the statement,
-		// but the extra work for this special case is not worth it, as gofmt will fix it.
-		return []analysis.TextEdit{edit}
-	}
-	// remove the whole line
-	for lineOf(edit.Pos) == stmtStartLine {
-		edit.Pos--
-	}
-	edit.Pos++ // get back tostmtStartLine
-	for lineOf(edit.End) == stmtEndLine {
-		edit.End++
-	}
-	return []analysis.TextEdit{edit}
-}
-
-// Comments returns an iterator over the comments overlapping the specified interval.
-func Comments(file *ast.File, start, end token.Pos) iter.Seq[*ast.Comment] {
-	// TODO(adonovan): optimize use binary O(log n) instead of linear O(n) search.
-	return func(yield func(*ast.Comment) bool) {
-		for _, cg := range file.Comments {
-			for _, co := range cg.List {
-				if co.Pos() > end {
-					return
-				}
-				if co.End() < start {
-					continue
-				}
-
-				if !yield(co) {
-					return
-				}
-			}
-		}
-	}
-}
-
 // IsStdPackage reports whether the specified package path belongs to a
 // package in the standard library (including internal dependencies).
 func IsStdPackage(path string) bool {
@@ -658,20 +293,3 @@ func IsStdPackage(path string) bool {
 	}
 	return !strings.Contains(path[:slash], ".") && path != "testdata"
 }
-
-// Range returns an [analysis.Range] for the specified start and end positions.
-func Range(pos, end token.Pos) analysis.Range {
-	return tokenRange{pos, end}
-}
-
-// tokenRange is an implementation of the [analysis.Range] interface.
-type tokenRange struct{ StartPos, EndPos token.Pos }
-
-func (r tokenRange) Pos() token.Pos { return r.StartPos }
-func (r tokenRange) End() token.Pos { return r.EndPos }
-
-// enclosingFile returns the syntax tree for the file enclosing c.
-func enclosingFile(c inspector.Cursor) *ast.File {
-	c, _ = moreiters.First(c.Enclosing((*ast.File)(nil)))
-	return c.Node().(*ast.File)
-}
diff --git a/tools/vendor/golang.org/x/tools/internal/analysisinternal/extractdoc.go b/tools/vendor/golang.org/x/tools/internal/analysisinternal/extractdoc.go
index 39507723d3..bfb5900f1b 100644
--- a/tools/vendor/golang.org/x/tools/internal/analysisinternal/extractdoc.go
+++ b/tools/vendor/golang.org/x/tools/internal/analysisinternal/extractdoc.go
@@ -97,7 +97,7 @@ func ExtractDoc(content, name string) (string, error) {
 	if f.Doc == nil {
 		return "", fmt.Errorf("Go source file has no package doc comment")
 	}
-	for _, section := range strings.Split(f.Doc.Text(), "\n# ") {
+	for section := range strings.SplitSeq(f.Doc.Text(), "\n# ") {
 		if body := strings.TrimPrefix(section, "Analyzer "+name); body != section &&
 			body != "" &&
 			body[0] == '\r' || body[0] == '\n' {
diff --git a/tools/vendor/golang.org/x/tools/internal/astutil/comment.go b/tools/vendor/golang.org/x/tools/internal/astutil/comment.go
index ee4be23f22..7e52aeaaac 100644
--- a/tools/vendor/golang.org/x/tools/internal/astutil/comment.go
+++ b/tools/vendor/golang.org/x/tools/internal/astutil/comment.go
@@ -7,6 +7,7 @@ package astutil
 import (
 	"go/ast"
 	"go/token"
+	"iter"
 	"strings"
 )
 
@@ -15,7 +16,7 @@ import (
 // https://go.dev/wiki/Deprecated, or "" if the documented symbol is not
 // deprecated.
 func Deprecation(doc *ast.CommentGroup) string {
-	for _, p := range strings.Split(doc.Text(), "\n\n") {
+	for p := range strings.SplitSeq(doc.Text(), "\n\n") {
 		// There is still some ambiguity for deprecation message. This function
 		// only returns the paragraph introduced by "Deprecated: ". More
 		// information related to the deprecation may follow in additional
@@ -111,3 +112,24 @@ func Directives(g *ast.CommentGroup) (res []*Directive) {
 	}
 	return
 }
+
+// Comments returns an iterator over the comments overlapping the specified interval.
+func Comments(file *ast.File, start, end token.Pos) iter.Seq[*ast.Comment] {
+	// TODO(adonovan): optimize use binary O(log n) instead of linear O(n) search.
+	return func(yield func(*ast.Comment) bool) {
+		for _, cg := range file.Comments {
+			for _, co := range cg.List {
+				if co.Pos() > end {
+					return
+				}
+				if co.End() < start {
+					continue
+				}
+
+				if !yield(co) {
+					return
+				}
+			}
+		}
+	}
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/astutil/equal.go b/tools/vendor/golang.org/x/tools/internal/astutil/equal.go
index c945de02d4..210f392387 100644
--- a/tools/vendor/golang.org/x/tools/internal/astutil/equal.go
+++ b/tools/vendor/golang.org/x/tools/internal/astutil/equal.go
@@ -26,6 +26,14 @@ func Equal(x, y ast.Node, identical func(x, y *ast.Ident) bool) bool {
 	return equal(reflect.ValueOf(x), reflect.ValueOf(y), identical)
 }
 
+// EqualSyntax reports whether x and y are equal.
+// Identifiers are considered equal if they are spelled the same.
+// Comments are ignored.
+func EqualSyntax(x, y ast.Expr) bool {
+	sameName := func(x, y *ast.Ident) bool { return x.Name == y.Name }
+	return Equal(x, y, sameName)
+}
+
 func equal(x, y reflect.Value, identical func(x, y *ast.Ident) bool) bool {
 	// Ensure types are the same
 	if x.Type() != y.Type() {
diff --git a/tools/vendor/golang.org/x/tools/internal/astutil/util.go b/tools/vendor/golang.org/x/tools/internal/astutil/util.go
index 14189155e4..a1c0983504 100644
--- a/tools/vendor/golang.org/x/tools/internal/astutil/util.go
+++ b/tools/vendor/golang.org/x/tools/internal/astutil/util.go
@@ -6,7 +6,13 @@ package astutil
 
 import (
 	"go/ast"
+	"go/printer"
 	"go/token"
+	"strings"
+
+	"golang.org/x/tools/go/ast/edge"
+	"golang.org/x/tools/go/ast/inspector"
+	"golang.org/x/tools/internal/moreiters"
 )
 
 // PreorderStack traverses the tree rooted at root,
@@ -67,3 +73,47 @@ func NodeContains(n ast.Node, pos token.Pos) bool {
 	}
 	return start <= pos && pos <= end
 }
+
+// IsChildOf reports whether cur.ParentEdge is ek.
+//
+// TODO(adonovan): promote to a method of Cursor.
+func IsChildOf(cur inspector.Cursor, ek edge.Kind) bool {
+	got, _ := cur.ParentEdge()
+	return got == ek
+}
+
+// EnclosingFile returns the syntax tree for the file enclosing c.
+//
+// TODO(adonovan): promote this to a method of Cursor.
+func EnclosingFile(c inspector.Cursor) *ast.File {
+	c, _ = moreiters.First(c.Enclosing((*ast.File)(nil)))
+	return c.Node().(*ast.File)
+}
+
+// DocComment returns the doc comment for a node, if any.
+func DocComment(n ast.Node) *ast.CommentGroup {
+	switch n := n.(type) {
+	case *ast.FuncDecl:
+		return n.Doc
+	case *ast.GenDecl:
+		return n.Doc
+	case *ast.ValueSpec:
+		return n.Doc
+	case *ast.TypeSpec:
+		return n.Doc
+	case *ast.File:
+		return n.Doc
+	case *ast.ImportSpec:
+		return n.Doc
+	case *ast.Field:
+		return n.Doc
+	}
+	return nil
+}
+
+// Format returns a string representation of the node n.
+func Format(fset *token.FileSet, n ast.Node) string {
+	var buf strings.Builder
+	printer.Fprint(&buf, fset, n) // ignore errors
+	return buf.String()
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/event/core/event.go b/tools/vendor/golang.org/x/tools/internal/event/core/event.go
index a6cf0e64a4..ade5d1e799 100644
--- a/tools/vendor/golang.org/x/tools/internal/event/core/event.go
+++ b/tools/vendor/golang.org/x/tools/internal/event/core/event.go
@@ -28,11 +28,6 @@ type Event struct {
 	dynamic []label.Label  // dynamically sized storage for remaining labels
 }
 
-// eventLabelMap implements label.Map for a the labels of an Event.
-type eventLabelMap struct {
-	event Event
-}
-
 func (ev Event) At() time.Time { return ev.at }
 
 func (ev Event) Format(f fmt.State, r rune) {
diff --git a/tools/vendor/golang.org/x/tools/internal/gcimporter/iexport.go b/tools/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
index 780873e3ae..4a4357d2bd 100644
--- a/tools/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
+++ b/tools/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
@@ -569,7 +569,6 @@ func (p *iexporter) exportName(obj types.Object) (res string) {
 
 type iexporter struct {
 	fset    *token.FileSet
-	out     *bytes.Buffer
 	version int
 
 	shallow    bool                // don't put types from other packages in the index
diff --git a/tools/vendor/golang.org/x/tools/internal/imports/fix.go b/tools/vendor/golang.org/x/tools/internal/imports/fix.go
index 50b6ca51a6..1b4dc0cb5d 100644
--- a/tools/vendor/golang.org/x/tools/internal/imports/fix.go
+++ b/tools/vendor/golang.org/x/tools/internal/imports/fix.go
@@ -16,6 +16,7 @@ import (
 	"go/types"
 	"io/fs"
 	"io/ioutil"
+	"maps"
 	"os"
 	"path"
 	"path/filepath"
@@ -27,8 +28,6 @@ import (
 	"unicode"
 	"unicode/utf8"
 
-	"maps"
-
 	"golang.org/x/tools/go/ast/astutil"
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/gocommand"
@@ -43,7 +42,7 @@ var importToGroup = []func(localPrefix, importPath string) (num int, ok bool){
 		if localPrefix == "" {
 			return
 		}
-		for _, p := range strings.Split(localPrefix, ",") {
+		for p := range strings.SplitSeq(localPrefix, ",") {
 			if strings.HasPrefix(importPath, p) || strings.TrimSuffix(p, "/") == importPath {
 				return 3, true
 			}
@@ -1251,7 +1250,6 @@ func ImportPathToAssumedName(importPath string) string {
 // gopathResolver implements resolver for GOPATH workspaces.
 type gopathResolver struct {
 	env      *ProcessEnv
-	walked   bool
 	cache    *DirInfoCache
 	scanSema chan struct{} // scanSema prevents concurrent scans.
 }
diff --git a/tools/vendor/golang.org/x/tools/internal/modindex/symbols.go b/tools/vendor/golang.org/x/tools/internal/modindex/symbols.go
index fe24db9b13..8e9702d84b 100644
--- a/tools/vendor/golang.org/x/tools/internal/modindex/symbols.go
+++ b/tools/vendor/golang.org/x/tools/internal/modindex/symbols.go
@@ -206,8 +206,7 @@ func isDeprecated(doc *ast.CommentGroup) bool {
 	// go.dev/wiki/Deprecated Paragraph starting 'Deprecated:'
 	// This code fails for /* Deprecated: */, but it's the code from
 	// gopls/internal/analysis/deprecated
-	lines := strings.Split(doc.Text(), "\n\n")
-	for _, line := range lines {
+	for line := range strings.SplitSeq(doc.Text(), "\n\n") {
 		if strings.HasPrefix(line, "Deprecated:") {
 			return true
 		}
diff --git a/tools/vendor/golang.org/x/tools/internal/refactor/delete.go b/tools/vendor/golang.org/x/tools/internal/refactor/delete.go
new file mode 100644
index 0000000000..aa8ba5af4c
--- /dev/null
+++ b/tools/vendor/golang.org/x/tools/internal/refactor/delete.go
@@ -0,0 +1,433 @@
+// Copyright 2025 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 refactor
+
+// This file defines operations for computing deletion edits.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	"slices"
+
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/ast/edge"
+	"golang.org/x/tools/go/ast/inspector"
+	"golang.org/x/tools/internal/astutil"
+	"golang.org/x/tools/internal/typesinternal"
+)
+
+// DeleteVar returns edits to delete the declaration of a variable
+// whose defining identifier is curId.
+//
+// It handles variants including:
+// - GenDecl > ValueSpec versus AssignStmt;
+// - RHS expression has effects, or not;
+// - entire statement/declaration may be eliminated;
+// and removes associated comments.
+//
+// If it cannot make the necessary edits, such as for a function
+// parameter or result, it returns nil.
+func DeleteVar(tokFile *token.File, info *types.Info, curId inspector.Cursor) []analysis.TextEdit {
+	switch ek, _ := curId.ParentEdge(); ek {
+	case edge.ValueSpec_Names:
+		return deleteVarFromValueSpec(tokFile, info, curId)
+
+	case edge.AssignStmt_Lhs:
+		return deleteVarFromAssignStmt(tokFile, info, curId)
+	}
+
+	// e.g. function receiver, parameter, or result,
+	// or "switch v := expr.(T) {}" (which has no object).
+	return nil
+}
+
+// Precondition: curId is Ident beneath ValueSpec.Names beneath GenDecl.
+//
+// See also [deleteVarFromAssignStmt], which has parallel structure.
+func deleteVarFromValueSpec(tokFile *token.File, info *types.Info, curIdent inspector.Cursor) []analysis.TextEdit {
+	var (
+		id      = curIdent.Node().(*ast.Ident)
+		curSpec = curIdent.Parent()
+		spec    = curSpec.Node().(*ast.ValueSpec)
+	)
+
+	declaresOtherNames := slices.ContainsFunc(spec.Names, func(name *ast.Ident) bool {
+		return name != id && name.Name != "_"
+	})
+	noRHSEffects := !slices.ContainsFunc(spec.Values, func(rhs ast.Expr) bool {
+		return !typesinternal.NoEffects(info, rhs)
+	})
+	if !declaresOtherNames && noRHSEffects {
+		// The spec is no longer needed, either to declare
+		// other variables, or for its side effects.
+		return DeleteSpec(tokFile, curSpec)
+	}
+
+	// The spec is still needed, either for
+	// at least one LHS, or for effects on RHS.
+	// Blank out or delete just one LHS.
+
+	_, index := curIdent.ParentEdge() // index of LHS within ValueSpec.Names
+
+	// If there is no RHS, we can delete the LHS.
+	if len(spec.Values) == 0 {
+		var pos, end token.Pos
+		if index == len(spec.Names)-1 {
+			// Delete final name.
+			//
+			// var _, lhs1 T
+			//      ------
+			pos = spec.Names[index-1].End()
+			end = spec.Names[index].End()
+		} else {
+			// Delete non-final name.
+			//
+			// var lhs0, _ T
+			//     ------
+			pos = spec.Names[index].Pos()
+			end = spec.Names[index+1].Pos()
+		}
+		return []analysis.TextEdit{{
+			Pos: pos,
+			End: end,
+		}}
+	}
+
+	// If the assignment is 1:1 and the RHS has no effects,
+	// we can delete the LHS and its corresponding RHS.
+	if len(spec.Names) == len(spec.Values) &&
+		typesinternal.NoEffects(info, spec.Values[index]) {
+
+		if index == len(spec.Names)-1 {
+			// Delete final items.
+			//
+			// var _, lhs1 = rhs0, rhs1
+			//      ------       ------
+			return []analysis.TextEdit{
+				{
+					Pos: spec.Names[index-1].End(),
+					End: spec.Names[index].End(),
+				},
+				{
+					Pos: spec.Values[index-1].End(),
+					End: spec.Values[index].End(),
+				},
+			}
+		} else {
+			// Delete non-final items.
+			//
+			// var lhs0, _ = rhs0, rhs1
+			//     ------    ------
+			return []analysis.TextEdit{
+				{
+					Pos: spec.Names[index].Pos(),
+					End: spec.Names[index+1].Pos(),
+				},
+				{
+					Pos: spec.Values[index].Pos(),
+					End: spec.Values[index+1].Pos(),
+				},
+			}
+		}
+	}
+
+	// We cannot delete the RHS.
+	// Blank out the LHS.
+	return []analysis.TextEdit{{
+		Pos:     id.Pos(),
+		End:     id.End(),
+		NewText: []byte("_"),
+	}}
+}
+
+// Precondition: curId is Ident beneath AssignStmt.Lhs.
+//
+// See also [deleteVarFromValueSpec], which has parallel structure.
+func deleteVarFromAssignStmt(tokFile *token.File, info *types.Info, curIdent inspector.Cursor) []analysis.TextEdit {
+	var (
+		id      = curIdent.Node().(*ast.Ident)
+		curStmt = curIdent.Parent()
+		assign  = curStmt.Node().(*ast.AssignStmt)
+	)
+
+	declaresOtherNames := slices.ContainsFunc(assign.Lhs, func(lhs ast.Expr) bool {
+		lhsId, ok := lhs.(*ast.Ident)
+		return ok && lhsId != id && lhsId.Name != "_"
+	})
+	noRHSEffects := !slices.ContainsFunc(assign.Rhs, func(rhs ast.Expr) bool {
+		return !typesinternal.NoEffects(info, rhs)
+	})
+	if !declaresOtherNames && noRHSEffects {
+		// The assignment is no longer needed, either to
+		// declare other variables, or for its side effects.
+		if edits := DeleteStmt(tokFile, curStmt); edits != nil {
+			return edits
+		}
+		// Statement could not not be deleted in this context.
+		// Fall back to conservative deletion.
+	}
+
+	// The assign is still needed, either for
+	// at least one LHS, or for effects on RHS,
+	// or because it cannot deleted because of its context.
+	// Blank out or delete just one LHS.
+
+	// If the assignment is 1:1 and the RHS has no effects,
+	// we can delete the LHS and its corresponding RHS.
+	_, index := curIdent.ParentEdge()
+	if len(assign.Lhs) > 1 &&
+		len(assign.Lhs) == len(assign.Rhs) &&
+		typesinternal.NoEffects(info, assign.Rhs[index]) {
+
+		if index == len(assign.Lhs)-1 {
+			// Delete final items.
+			//
+			// _, lhs1 := rhs0, rhs1
+			//  ------        ------
+			return []analysis.TextEdit{
+				{
+					Pos: assign.Lhs[index-1].End(),
+					End: assign.Lhs[index].End(),
+				},
+				{
+					Pos: assign.Rhs[index-1].End(),
+					End: assign.Rhs[index].End(),
+				},
+			}
+		} else {
+			// Delete non-final items.
+			//
+			// lhs0, _ := rhs0, rhs1
+			// ------     ------
+			return []analysis.TextEdit{
+				{
+					Pos: assign.Lhs[index].Pos(),
+					End: assign.Lhs[index+1].Pos(),
+				},
+				{
+					Pos: assign.Rhs[index].Pos(),
+					End: assign.Rhs[index+1].Pos(),
+				},
+			}
+		}
+	}
+
+	// We cannot delete the RHS.
+	// Blank out the LHS.
+	edits := []analysis.TextEdit{{
+		Pos:     id.Pos(),
+		End:     id.End(),
+		NewText: []byte("_"),
+	}}
+
+	// If this eliminates the final variable declared by
+	// an := statement, we need to turn it into an =
+	// assignment to avoid a "no new variables on left
+	// side of :=" error.
+	if !declaresOtherNames {
+		edits = append(edits, analysis.TextEdit{
+			Pos:     assign.TokPos,
+			End:     assign.TokPos + token.Pos(len(":=")),
+			NewText: []byte("="),
+		})
+	}
+
+	return edits
+}
+
+// DeleteSpec returns edits to delete the ValueSpec identified by curSpec.
+//
+// TODO(adonovan): add test suite. Test for consts as well.
+func DeleteSpec(tokFile *token.File, curSpec inspector.Cursor) []analysis.TextEdit {
+	var (
+		spec    = curSpec.Node().(*ast.ValueSpec)
+		curDecl = curSpec.Parent()
+		decl    = curDecl.Node().(*ast.GenDecl)
+	)
+
+	// If it is the sole spec in the decl,
+	// delete the entire decl.
+	if len(decl.Specs) == 1 {
+		return DeleteDecl(tokFile, curDecl)
+	}
+
+	// Delete the spec and its comments.
+	_, index := curSpec.ParentEdge() // index of ValueSpec within GenDecl.Specs
+	pos, end := spec.Pos(), spec.End()
+	if spec.Doc != nil {
+		pos = spec.Doc.Pos() // leading comment
+	}
+	if index == len(decl.Specs)-1 {
+		// Delete final spec.
+		if spec.Comment != nil {
+			//  var (v int // comment \n)
+			end = spec.Comment.End()
+		}
+	} else {
+		// Delete non-final spec.
+		//   var ( a T; b T )
+		//         -----
+		end = decl.Specs[index+1].Pos()
+	}
+	return []analysis.TextEdit{{
+		Pos: pos,
+		End: end,
+	}}
+}
+
+// DeleteDecl returns edits to delete the ast.Decl identified by curDecl.
+//
+// TODO(adonovan): add test suite.
+func DeleteDecl(tokFile *token.File, curDecl inspector.Cursor) []analysis.TextEdit {
+	decl := curDecl.Node().(ast.Decl)
+
+	ek, _ := curDecl.ParentEdge()
+	switch ek {
+	case edge.DeclStmt_Decl:
+		return DeleteStmt(tokFile, curDecl.Parent())
+
+	case edge.File_Decls:
+		pos, end := decl.Pos(), decl.End()
+		if doc := astutil.DocComment(decl); doc != nil {
+			pos = doc.Pos()
+		}
+
+		// Delete free-floating comments on same line as rparen.
+		//    var (...) // comment
+		var (
+			file        = curDecl.Parent().Node().(*ast.File)
+			lineOf      = tokFile.Line
+			declEndLine = lineOf(decl.End())
+		)
+		for _, cg := range file.Comments {
+			for _, c := range cg.List {
+				if c.Pos() < end {
+					continue // too early
+				}
+				commentEndLine := lineOf(c.End())
+				if commentEndLine > declEndLine {
+					break // too late
+				} else if lineOf(c.Pos()) == declEndLine && commentEndLine == declEndLine {
+					end = c.End()
+				}
+			}
+		}
+
+		return []analysis.TextEdit{{
+			Pos: pos,
+			End: end,
+		}}
+
+	default:
+		panic(fmt.Sprintf("Decl parent is %v, want DeclStmt or File", ek))
+	}
+}
+
+// DeleteStmt returns the edits to remove the [ast.Stmt] identified by
+// curStmt, if it is contained within a BlockStmt, CaseClause,
+// CommClause, or is the STMT in switch STMT; ... {...}. It returns nil otherwise.
+func DeleteStmt(tokFile *token.File, curStmt inspector.Cursor) []analysis.TextEdit {
+	stmt := curStmt.Node().(ast.Stmt)
+	// if the stmt is on a line by itself delete the whole line
+	// otherwise just delete the statement.
+
+	// this logic would be a lot simpler with the file contents, and somewhat simpler
+	// if the cursors included the comments.
+
+	lineOf := tokFile.Line
+	stmtStartLine, stmtEndLine := lineOf(stmt.Pos()), lineOf(stmt.End())
+
+	var from, to token.Pos
+	// bounds of adjacent syntax/comments on same line, if any
+	limits := func(left, right token.Pos) {
+		if lineOf(left) == stmtStartLine {
+			from = left
+		}
+		if lineOf(right) == stmtEndLine {
+			to = right
+		}
+	}
+	// TODO(pjw): there are other places a statement might be removed:
+	// IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" ( IfStmt | Block ) ] .
+	// (removing the blocks requires more rewriting than this routine would do)
+	// CommCase   = "case" ( SendStmt | RecvStmt ) | "default" .
+	// (removing the stmt requires more rewriting, and it's unclear what the user means)
+	switch parent := curStmt.Parent().Node().(type) {
+	case *ast.SwitchStmt:
+		limits(parent.Switch, parent.Body.Lbrace)
+	case *ast.TypeSwitchStmt:
+		limits(parent.Switch, parent.Body.Lbrace)
+		if parent.Assign == stmt {
+			return nil // don't let the user break the type switch
+		}
+	case *ast.BlockStmt:
+		limits(parent.Lbrace, parent.Rbrace)
+	case *ast.CommClause:
+		limits(parent.Colon, curStmt.Parent().Parent().Node().(*ast.BlockStmt).Rbrace)
+		if parent.Comm == stmt {
+			return nil // maybe the user meant to remove the entire CommClause?
+		}
+	case *ast.CaseClause:
+		limits(parent.Colon, curStmt.Parent().Parent().Node().(*ast.BlockStmt).Rbrace)
+	case *ast.ForStmt:
+		limits(parent.For, parent.Body.Lbrace)
+
+	default:
+		return nil // not one of ours
+	}
+
+	if prev, found := curStmt.PrevSibling(); found && lineOf(prev.Node().End()) == stmtStartLine {
+		from = prev.Node().End() // preceding statement ends on same line
+	}
+	if next, found := curStmt.NextSibling(); found && lineOf(next.Node().Pos()) == stmtEndLine {
+		to = next.Node().Pos() // following statement begins on same line
+	}
+	// and now for the comments
+Outer:
+	for _, cg := range astutil.EnclosingFile(curStmt).Comments {
+		for _, co := range cg.List {
+			if lineOf(co.End()) < stmtStartLine {
+				continue
+			} else if lineOf(co.Pos()) > stmtEndLine {
+				break Outer // no more are possible
+			}
+			if lineOf(co.End()) == stmtStartLine && co.End() < stmt.Pos() {
+				if !from.IsValid() || co.End() > from {
+					from = co.End()
+					continue // maybe there are more
+				}
+			}
+			if lineOf(co.Pos()) == stmtEndLine && co.Pos() > stmt.End() {
+				if !to.IsValid() || co.Pos() < to {
+					to = co.Pos()
+					continue // maybe there are more
+				}
+			}
+		}
+	}
+	// if either from or to is valid, just remove the statement
+	// otherwise remove the line
+	edit := analysis.TextEdit{Pos: stmt.Pos(), End: stmt.End()}
+	if from.IsValid() || to.IsValid() {
+		// remove just the statement.
+		// we can't tell if there is a ; or whitespace right after the statement
+		// ideally we'd like to remove the former and leave the latter
+		// (if gofmt has run, there likely won't be a ;)
+		// In type switches we know there's a semicolon somewhere after the statement,
+		// but the extra work for this special case is not worth it, as gofmt will fix it.
+		return []analysis.TextEdit{edit}
+	}
+	// remove the whole line
+	for lineOf(edit.Pos) == stmtStartLine {
+		edit.Pos--
+	}
+	edit.Pos++ // get back tostmtStartLine
+	for lineOf(edit.End) == stmtEndLine {
+		edit.End++
+	}
+	return []analysis.TextEdit{edit}
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/refactor/imports.go b/tools/vendor/golang.org/x/tools/internal/refactor/imports.go
new file mode 100644
index 0000000000..1ba3a9609f
--- /dev/null
+++ b/tools/vendor/golang.org/x/tools/internal/refactor/imports.go
@@ -0,0 +1,127 @@
+// Copyright 2025 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 refactor
+
+// This file defines operations for computing edits to imports.
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"go/types"
+	pathpkg "path"
+
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/internal/analysisinternal"
+)
+
+// AddImport returns the prefix (either "pkg." or "") that should be
+// used to qualify references to the desired symbol (member) imported
+// from the specified package, plus any necessary edits to the file's
+// import declaration to add a new import.
+//
+// If the import already exists, and is accessible at pos, AddImport
+// returns the existing name and no edits. (If the existing import is
+// a dot import, the prefix is "".)
+//
+// Otherwise, it adds a new import, using a local name derived from
+// the preferred name. To request a blank import, use a preferredName
+// of "_", and discard the prefix result; member is ignored in this
+// case.
+//
+// AddImport accepts the caller's implicit claim that the imported
+// package declares member.
+//
+// AddImport does not mutate its arguments.
+func AddImport(info *types.Info, file *ast.File, preferredName, pkgpath, member string, pos token.Pos) (prefix string, edits []analysis.TextEdit) {
+	// Find innermost enclosing lexical block.
+	scope := info.Scopes[file].Innermost(pos)
+	if scope == nil {
+		panic("no enclosing lexical block")
+	}
+
+	// Is there an existing import of this package?
+	// If so, are we in its scope? (not shadowed)
+	for _, spec := range file.Imports {
+		pkgname := info.PkgNameOf(spec)
+		if pkgname != nil && pkgname.Imported().Path() == pkgpath {
+			name := pkgname.Name()
+			if preferredName == "_" {
+				// Request for blank import; any existing import will do.
+				return "", nil
+			}
+			if name == "." {
+				// The scope of ident must be the file scope.
+				if s, _ := scope.LookupParent(member, pos); s == info.Scopes[file] {
+					return "", nil
+				}
+			} else if _, obj := scope.LookupParent(name, pos); obj == pkgname {
+				return name + ".", nil
+			}
+		}
+	}
+
+	// We must add a new import.
+
+	// Ensure we have a fresh name.
+	newName := preferredName
+	if preferredName != "_" {
+		newName = FreshName(scope, pos, preferredName)
+	}
+
+	// Create a new import declaration either before the first existing
+	// declaration (which must exist), including its comments; or
+	// inside the declaration, if it is an import group.
+	//
+	// Use a renaming import whenever the preferred name is not
+	// available, or the chosen name does not match the last
+	// segment of its path.
+	newText := fmt.Sprintf("%q", pkgpath)
+	if newName != preferredName || newName != pathpkg.Base(pkgpath) {
+		newText = fmt.Sprintf("%s %q", newName, pkgpath)
+	}
+
+	decl0 := file.Decls[0]
+	var before ast.Node = decl0
+	switch decl0 := decl0.(type) {
+	case *ast.GenDecl:
+		if decl0.Doc != nil {
+			before = decl0.Doc
+		}
+	case *ast.FuncDecl:
+		if decl0.Doc != nil {
+			before = decl0.Doc
+		}
+	}
+	if gd, ok := before.(*ast.GenDecl); ok && gd.Tok == token.IMPORT && gd.Rparen.IsValid() {
+		// Have existing grouped import ( ... ) decl.
+		if analysisinternal.IsStdPackage(pkgpath) && len(gd.Specs) > 0 {
+			// Add spec for a std package before
+			// first existing spec, followed by
+			// a blank line if the next one is non-std.
+			first := gd.Specs[0].(*ast.ImportSpec)
+			pos = first.Pos()
+			if !analysisinternal.IsStdPackage(first.Path.Value) {
+				newText += "\n"
+			}
+			newText += "\n\t"
+		} else {
+			// Add spec at end of group.
+			pos = gd.Rparen
+			newText = "\t" + newText + "\n"
+		}
+	} else {
+		// No import decl, or non-grouped import.
+		// Add a new import decl before first decl.
+		// (gofmt will merge multiple import decls.)
+		pos = before.Pos()
+		newText = "import " + newText + "\n\n"
+	}
+	return newName + ".", []analysis.TextEdit{{
+		Pos:     pos,
+		End:     pos,
+		NewText: []byte(newText),
+	}}
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/refactor/refactor.go b/tools/vendor/golang.org/x/tools/internal/refactor/refactor.go
new file mode 100644
index 0000000000..27b9750896
--- /dev/null
+++ b/tools/vendor/golang.org/x/tools/internal/refactor/refactor.go
@@ -0,0 +1,29 @@
+// Copyright 2025 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 refactor provides operators to compute common textual edits
+// for refactoring tools.
+//
+// This package should not use features of the analysis API
+// other than [analysis.TextEdit].
+package refactor
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+)
+
+// FreshName returns the name of an identifier that is undefined
+// at the specified position, based on the preferred name.
+func FreshName(scope *types.Scope, pos token.Pos, preferred string) string {
+	newName := preferred
+	for i := 0; ; i++ {
+		if _, obj := scope.LookupParent(newName, pos); obj == nil {
+			break // fresh
+		}
+		newName = fmt.Sprintf("%s%d", preferred, i)
+	}
+	return newName
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/typesinternal/fx.go b/tools/vendor/golang.org/x/tools/internal/typesinternal/fx.go
new file mode 100644
index 0000000000..93acff2170
--- /dev/null
+++ b/tools/vendor/golang.org/x/tools/internal/typesinternal/fx.go
@@ -0,0 +1,49 @@
+// Copyright 2025 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 typesinternal
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+)
+
+// NoEffects reports whether the expression has no side effects, i.e., it
+// does not modify the memory state. This function is conservative: it may
+// return false even when the expression has no effect.
+func NoEffects(info *types.Info, expr ast.Expr) bool {
+	noEffects := true
+	ast.Inspect(expr, func(n ast.Node) bool {
+		switch v := n.(type) {
+		case nil, *ast.Ident, *ast.BasicLit, *ast.BinaryExpr, *ast.ParenExpr,
+			*ast.SelectorExpr, *ast.IndexExpr, *ast.SliceExpr, *ast.TypeAssertExpr,
+			*ast.StarExpr, *ast.CompositeLit, *ast.ArrayType, *ast.StructType,
+			*ast.MapType, *ast.InterfaceType, *ast.KeyValueExpr:
+			// No effect
+		case *ast.UnaryExpr:
+			// Channel send <-ch has effects
+			if v.Op == token.ARROW {
+				noEffects = false
+			}
+		case *ast.CallExpr:
+			// Type conversion has no effects
+			if !info.Types[v.Fun].IsType() {
+				// TODO(adonovan): Add a case for built-in functions without side
+				// effects (by using callsPureBuiltin from tools/internal/refactor/inline)
+
+				noEffects = false
+			}
+		case *ast.FuncLit:
+			// A FuncLit has no effects, but do not descend into it.
+			return false
+		default:
+			// All other expressions have effects
+			noEffects = false
+		}
+
+		return noEffects
+	})
+	return noEffects
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go b/tools/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
new file mode 100644
index 0000000000..f2affec4fb
--- /dev/null
+++ b/tools/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
@@ -0,0 +1,71 @@
+// Copyright 2025 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 typesinternal
+
+import (
+	"go/types"
+	"slices"
+)
+
+// IsTypeNamed reports whether t is (or is an alias for) a
+// package-level defined type with the given package path and one of
+// the given names. It returns false if t is nil.
+//
+// This function avoids allocating the concatenation of "pkg.Name",
+// which is important for the performance of syntax matching.
+func IsTypeNamed(t types.Type, pkgPath string, names ...string) bool {
+	if named, ok := types.Unalias(t).(*types.Named); ok {
+		tname := named.Obj()
+		return tname != nil &&
+			IsPackageLevel(tname) &&
+			tname.Pkg().Path() == pkgPath &&
+			slices.Contains(names, tname.Name())
+	}
+	return false
+}
+
+// IsPointerToNamed reports whether t is (or is an alias for) a pointer to a
+// package-level defined type with the given package path and one of the given
+// names. It returns false if t is not a pointer type.
+func IsPointerToNamed(t types.Type, pkgPath string, names ...string) bool {
+	r := Unpointer(t)
+	if r == t {
+		return false
+	}
+	return IsTypeNamed(r, pkgPath, names...)
+}
+
+// IsFunctionNamed reports whether obj is a package-level function
+// defined in the given package and has one of the given names.
+// It returns false if obj is nil.
+//
+// This function avoids allocating the concatenation of "pkg.Name",
+// which is important for the performance of syntax matching.
+func IsFunctionNamed(obj types.Object, pkgPath string, names ...string) bool {
+	f, ok := obj.(*types.Func)
+	return ok &&
+		IsPackageLevel(obj) &&
+		f.Pkg().Path() == pkgPath &&
+		f.Type().(*types.Signature).Recv() == nil &&
+		slices.Contains(names, f.Name())
+}
+
+// IsMethodNamed reports whether obj is a method defined on a
+// package-level type with the given package and type name, and has
+// one of the given names. It returns false if obj is nil.
+//
+// This function avoids allocating the concatenation of "pkg.TypeName.Name",
+// which is important for the performance of syntax matching.
+func IsMethodNamed(obj types.Object, pkgPath string, typeName string, names ...string) bool {
+	if fn, ok := obj.(*types.Func); ok {
+		if recv := fn.Type().(*types.Signature).Recv(); recv != nil {
+			_, T := ReceiverNamed(recv)
+			return T != nil &&
+				IsTypeNamed(T, pkgPath, typeName) &&
+				slices.Contains(names, fn.Name())
+		}
+	}
+	return false
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go b/tools/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go
index b64f714eb3..64f47919f0 100644
--- a/tools/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go
+++ b/tools/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go
@@ -15,6 +15,14 @@ import (
 // file.
 // If the same package is imported multiple times, the last appearance is
 // recorded.
+//
+// TODO(adonovan): this function ignores the effect of shadowing. It
+// should accept a [token.Pos] and a [types.Info] and compute only the
+// set of imports that are not shadowed at that point, analogous to
+// [analysisinternal.AddImport]. It could also compute (as a side
+// effect) the set of additional imports required to ensure that there
+// is an accessible import for each necessary package, making it
+// converge even more closely with AddImport.
 func FileQualifier(f *ast.File, pkg *types.Package) types.Qualifier {
 	// Construct mapping of import paths to their defined names.
 	// It is only necessary to look at renaming imports.
diff --git a/tools/vendor/golang.org/x/tools/internal/typesinternal/types.go b/tools/vendor/golang.org/x/tools/internal/typesinternal/types.go
index a5cd7e8dbf..fef74a7856 100644
--- a/tools/vendor/golang.org/x/tools/internal/typesinternal/types.go
+++ b/tools/vendor/golang.org/x/tools/internal/typesinternal/types.go
@@ -2,8 +2,20 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package typesinternal provides access to internal go/types APIs that are not
-// yet exported.
+// Package typesinternal provides helpful operators for dealing with
+// go/types:
+//
+//   - operators for querying typed syntax trees (e.g. [Imports], [IsFunctionNamed]);
+//   - functions for converting types to strings or syntax (e.g. [TypeExpr], FileQualifier]);
+//   - helpers for working with the [go/types] API (e.g. [NewTypesInfo]);
+//   - access to internal go/types APIs that are not yet
+//     exported (e.g. [SetUsesCgo], [ErrorCodeStartEnd], [VarKind]); and
+//   - common algorithms related to types (e.g. [TooNewStdSymbols]).
+//
+// See also:
+//   - [golang.org/x/tools/internal/astutil], for operations on untyped syntax;
+//   - [golang.org/x/tools/internal/analysisinernal], for helpers for analyzers;
+//   - [golang.org/x/tools/internal/refactor], for operators to compute text edits.
 package typesinternal
 
 import (
@@ -13,6 +25,7 @@ import (
 	"reflect"
 	"unsafe"
 
+	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/internal/aliases"
 )
 
@@ -60,6 +73,9 @@ func ErrorCodeStartEnd(err types.Error) (code ErrorCode, start, end token.Pos, o
 // which is often excessive.)
 //
 // If pkg is nil, it is equivalent to [*types.Package.Name].
+//
+// TODO(adonovan): all uses of this with TypeString should be
+// eliminated when https://go.dev/issues/75604 is resolved.
 func NameRelativeTo(pkg *types.Package) types.Qualifier {
 	return func(other *types.Package) string {
 		if pkg != nil && pkg == other {
@@ -153,3 +169,31 @@ func NewTypesInfo() *types.Info {
 		FileVersions: map[*ast.File]string{},
 	}
 }
+
+// EnclosingScope returns the innermost block logically enclosing the cursor.
+func EnclosingScope(info *types.Info, cur inspector.Cursor) *types.Scope {
+	for cur := range cur.Enclosing() {
+		n := cur.Node()
+		// A function's Scope is associated with its FuncType.
+		switch f := n.(type) {
+		case *ast.FuncDecl:
+			n = f.Type
+		case *ast.FuncLit:
+			n = f.Type
+		}
+		if b := info.Scopes[n]; b != nil {
+			return b
+		}
+	}
+	panic("no Scope for *ast.File")
+}
+
+// Imports reports whether path is imported by pkg.
+func Imports(pkg *types.Package, path string) bool {
+	for _, imp := range pkg.Imports() {
+		if imp.Path() == path {
+			return true
+		}
+	}
+	return false
+}
diff --git a/tools/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go b/tools/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go
index d272949c17..453bba2ad5 100644
--- a/tools/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go
+++ b/tools/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go
@@ -204,23 +204,12 @@ func ZeroExpr(t types.Type, qual types.Qualifier) (_ ast.Expr, isValid bool) {
 	}
 }
 
-// IsZeroExpr uses simple syntactic heuristics to report whether expr
-// is a obvious zero value, such as 0, "", nil, or false.
-// It cannot do better without type information.
-func IsZeroExpr(expr ast.Expr) bool {
-	switch e := expr.(type) {
-	case *ast.BasicLit:
-		return e.Value == "0" || e.Value == `""`
-	case *ast.Ident:
-		return e.Name == "nil" || e.Name == "false"
-	default:
-		return false
-	}
-}
-
 // TypeExpr returns syntax for the specified type. References to named types
 // are qualified by an appropriate (optional) qualifier function.
 // It may panic for types such as Tuple or Union.
+//
+// See also https://go.dev/issues/75604, which will provide a robust
+// Type-to-valid-Go-syntax formatter.
 func TypeExpr(t types.Type, qual types.Qualifier) ast.Expr {
 	switch t := t.(type) {
 	case *types.Basic:
diff --git a/tools/vendor/modules.txt b/tools/vendor/modules.txt
index 2f0cc5b950..f45596853a 100644
--- a/tools/vendor/modules.txt
+++ b/tools/vendor/modules.txt
@@ -959,7 +959,7 @@ go.uber.org/zap/zapcore
 # golang.org/x/exp/typeparams v0.0.0-20250911091902-df9299821621
 ## explicit; go 1.24.0
 golang.org/x/exp/typeparams
-# golang.org/x/mod v0.28.0
+# golang.org/x/mod v0.29.0
 ## explicit; go 1.24.0
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile
@@ -970,11 +970,11 @@ golang.org/x/mod/sumdb/dirhash
 ## explicit; go 1.24.0
 golang.org/x/sync/errgroup
 golang.org/x/sync/semaphore
-# golang.org/x/sys v0.36.0
+# golang.org/x/sys v0.37.0
 ## explicit; go 1.24.0
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-# golang.org/x/telemetry v0.0.0-20250908211612-aef8a434d053
+# golang.org/x/telemetry v0.0.0-20251008203120-078029d740a8
 ## explicit; go 1.24.0
 golang.org/x/telemetry/counter
 golang.org/x/telemetry/internal/counter
@@ -998,7 +998,7 @@ golang.org/x/text/runes
 golang.org/x/text/transform
 golang.org/x/text/unicode/norm
 golang.org/x/text/width
-# golang.org/x/tools v0.37.0
+# golang.org/x/tools v0.38.0
 ## explicit; go 1.24.0
 golang.org/x/tools/cmd/goimports
 golang.org/x/tools/go/analysis
@@ -1083,6 +1083,7 @@ golang.org/x/tools/internal/modindex
 golang.org/x/tools/internal/moreiters
 golang.org/x/tools/internal/packagesinternal
 golang.org/x/tools/internal/pkgbits
+golang.org/x/tools/internal/refactor
 golang.org/x/tools/internal/stdlib
 golang.org/x/tools/internal/typeparams
 golang.org/x/tools/internal/typesinternal