<0 padding>
-//
-// The last byte of the UTF-8-encoded rune is xor-ed with the last byte of the
-// UTF-8 encoding of the original rune. Mappings often have the following
-// pattern:
-//
-// Ａ -> A (U+FF21 -> U+0041)
-// Ｂ -> B (U+FF22 -> U+0042)
-// ...
-//
-// By xor-ing the last byte the same entry can be shared by many mappings. This
-// reduces the total number of distinct entries by about two thirds.
-// The resulting entry for the aforementioned mappings is
-//
-// { 0x01, 0xE0, 0x00, 0x00 }
-//
-// Using this entry to map U+FF21 (UTF-8 [EF BC A1]), we get
-//
-// E0 ^ A1 = 41.
-//
-// Similarly, for U+FF22 (UTF-8 [EF BC A2]), we get
-//
-// E0 ^ A2 = 42.
-//
-// Note that because of the xor-ing, the byte sequence stored in the entry is
-// not valid UTF-8.
-var inverseData = [150][4]byte{
- {0x00, 0x00, 0x00, 0x00},
- {0x03, 0xe3, 0x80, 0xa0},
- {0x03, 0xef, 0xbc, 0xa0},
- {0x03, 0xef, 0xbc, 0xe0},
- {0x03, 0xef, 0xbd, 0xe0},
- {0x03, 0xef, 0xbf, 0x02},
- {0x03, 0xef, 0xbf, 0x00},
- {0x03, 0xef, 0xbf, 0x0e},
- {0x03, 0xef, 0xbf, 0x0c},
- {0x03, 0xef, 0xbf, 0x0f},
- {0x03, 0xef, 0xbf, 0x39},
- {0x03, 0xef, 0xbf, 0x3b},
- {0x03, 0xef, 0xbf, 0x3f},
- {0x03, 0xef, 0xbf, 0x2a},
- {0x03, 0xef, 0xbf, 0x0d},
- {0x03, 0xef, 0xbf, 0x25},
- {0x03, 0xef, 0xbd, 0x1a},
- {0x03, 0xef, 0xbd, 0x26},
- {0x01, 0xa0, 0x00, 0x00},
- {0x03, 0xef, 0xbd, 0x25},
- {0x03, 0xef, 0xbd, 0x23},
- {0x03, 0xef, 0xbd, 0x2e},
- {0x03, 0xef, 0xbe, 0x07},
- {0x03, 0xef, 0xbe, 0x05},
- {0x03, 0xef, 0xbd, 0x06},
- {0x03, 0xef, 0xbd, 0x13},
- {0x03, 0xef, 0xbd, 0x0b},
- {0x03, 0xef, 0xbd, 0x16},
- {0x03, 0xef, 0xbd, 0x0c},
- {0x03, 0xef, 0xbd, 0x15},
- {0x03, 0xef, 0xbd, 0x0d},
- {0x03, 0xef, 0xbd, 0x1c},
- {0x03, 0xef, 0xbd, 0x02},
- {0x03, 0xef, 0xbd, 0x1f},
- {0x03, 0xef, 0xbd, 0x1d},
- {0x03, 0xef, 0xbd, 0x17},
- {0x03, 0xef, 0xbd, 0x08},
- {0x03, 0xef, 0xbd, 0x09},
- {0x03, 0xef, 0xbd, 0x0e},
- {0x03, 0xef, 0xbd, 0x04},
- {0x03, 0xef, 0xbd, 0x05},
- {0x03, 0xef, 0xbe, 0x3f},
- {0x03, 0xef, 0xbe, 0x00},
- {0x03, 0xef, 0xbd, 0x2c},
- {0x03, 0xef, 0xbe, 0x06},
- {0x03, 0xef, 0xbe, 0x0c},
- {0x03, 0xef, 0xbe, 0x0f},
- {0x03, 0xef, 0xbe, 0x0d},
- {0x03, 0xef, 0xbe, 0x0b},
- {0x03, 0xef, 0xbe, 0x19},
- {0x03, 0xef, 0xbe, 0x15},
- {0x03, 0xef, 0xbe, 0x11},
- {0x03, 0xef, 0xbe, 0x31},
- {0x03, 0xef, 0xbe, 0x33},
- {0x03, 0xef, 0xbd, 0x0f},
- {0x03, 0xef, 0xbe, 0x30},
- {0x03, 0xef, 0xbe, 0x3e},
- {0x03, 0xef, 0xbe, 0x32},
- {0x03, 0xef, 0xbe, 0x36},
- {0x03, 0xef, 0xbd, 0x14},
- {0x03, 0xef, 0xbe, 0x2e},
- {0x03, 0xef, 0xbd, 0x1e},
- {0x03, 0xef, 0xbe, 0x10},
- {0x03, 0xef, 0xbf, 0x13},
- {0x03, 0xef, 0xbf, 0x15},
- {0x03, 0xef, 0xbf, 0x17},
- {0x03, 0xef, 0xbf, 0x1f},
- {0x03, 0xef, 0xbf, 0x1d},
- {0x03, 0xef, 0xbf, 0x1b},
- {0x03, 0xef, 0xbf, 0x09},
- {0x03, 0xef, 0xbf, 0x0b},
- {0x03, 0xef, 0xbf, 0x37},
- {0x03, 0xef, 0xbe, 0x04},
- {0x01, 0xe0, 0x00, 0x00},
- {0x03, 0xe2, 0xa6, 0x1a},
- {0x03, 0xe2, 0xa6, 0x26},
- {0x03, 0xe3, 0x80, 0x23},
- {0x03, 0xe3, 0x80, 0x2e},
- {0x03, 0xe3, 0x80, 0x25},
- {0x03, 0xe3, 0x83, 0x1e},
- {0x03, 0xe3, 0x83, 0x14},
- {0x03, 0xe3, 0x82, 0x06},
- {0x03, 0xe3, 0x82, 0x0b},
- {0x03, 0xe3, 0x82, 0x0c},
- {0x03, 0xe3, 0x82, 0x0d},
- {0x03, 0xe3, 0x82, 0x02},
- {0x03, 0xe3, 0x83, 0x0f},
- {0x03, 0xe3, 0x83, 0x08},
- {0x03, 0xe3, 0x83, 0x09},
- {0x03, 0xe3, 0x83, 0x2c},
- {0x03, 0xe3, 0x83, 0x0c},
- {0x03, 0xe3, 0x82, 0x13},
- {0x03, 0xe3, 0x82, 0x16},
- {0x03, 0xe3, 0x82, 0x15},
- {0x03, 0xe3, 0x82, 0x1c},
- {0x03, 0xe3, 0x82, 0x1f},
- {0x03, 0xe3, 0x82, 0x1d},
- {0x03, 0xe3, 0x82, 0x1a},
- {0x03, 0xe3, 0x82, 0x17},
- {0x03, 0xe3, 0x82, 0x08},
- {0x03, 0xe3, 0x82, 0x09},
- {0x03, 0xe3, 0x82, 0x0e},
- {0x03, 0xe3, 0x82, 0x04},
- {0x03, 0xe3, 0x82, 0x05},
- {0x03, 0xe3, 0x82, 0x3f},
- {0x03, 0xe3, 0x83, 0x00},
- {0x03, 0xe3, 0x83, 0x06},
- {0x03, 0xe3, 0x83, 0x05},
- {0x03, 0xe3, 0x83, 0x0d},
- {0x03, 0xe3, 0x83, 0x0b},
- {0x03, 0xe3, 0x83, 0x07},
- {0x03, 0xe3, 0x83, 0x19},
- {0x03, 0xe3, 0x83, 0x15},
- {0x03, 0xe3, 0x83, 0x11},
- {0x03, 0xe3, 0x83, 0x31},
- {0x03, 0xe3, 0x83, 0x33},
- {0x03, 0xe3, 0x83, 0x30},
- {0x03, 0xe3, 0x83, 0x3e},
- {0x03, 0xe3, 0x83, 0x32},
- {0x03, 0xe3, 0x83, 0x36},
- {0x03, 0xe3, 0x83, 0x2e},
- {0x03, 0xe3, 0x82, 0x07},
- {0x03, 0xe3, 0x85, 0x04},
- {0x03, 0xe3, 0x84, 0x10},
- {0x03, 0xe3, 0x85, 0x30},
- {0x03, 0xe3, 0x85, 0x0d},
- {0x03, 0xe3, 0x85, 0x13},
- {0x03, 0xe3, 0x85, 0x15},
- {0x03, 0xe3, 0x85, 0x17},
- {0x03, 0xe3, 0x85, 0x1f},
- {0x03, 0xe3, 0x85, 0x1d},
- {0x03, 0xe3, 0x85, 0x1b},
- {0x03, 0xe3, 0x85, 0x09},
- {0x03, 0xe3, 0x85, 0x0f},
- {0x03, 0xe3, 0x85, 0x0b},
- {0x03, 0xe3, 0x85, 0x37},
- {0x03, 0xe3, 0x85, 0x3b},
- {0x03, 0xe3, 0x85, 0x39},
- {0x03, 0xe3, 0x85, 0x3f},
- {0x02, 0xc2, 0x02, 0x00},
- {0x02, 0xc2, 0x0e, 0x00},
- {0x02, 0xc2, 0x0c, 0x00},
- {0x02, 0xc2, 0x00, 0x00},
- {0x03, 0xe2, 0x82, 0x0f},
- {0x03, 0xe2, 0x94, 0x2a},
- {0x03, 0xe2, 0x86, 0x39},
- {0x03, 0xe2, 0x86, 0x3b},
- {0x03, 0xe2, 0x86, 0x3f},
- {0x03, 0xe2, 0x96, 0x0d},
- {0x03, 0xe2, 0x97, 0x25},
-}
-
-// Total table size 14680 bytes (14KiB)
diff --git a/vendor/golang.org/x/tools/go/analysis/analysis.go b/vendor/golang.org/x/tools/go/analysis/analysis.go
index a7df4d1f..786c29d5 100644
--- a/vendor/golang.org/x/tools/go/analysis/analysis.go
+++ b/vendor/golang.org/x/tools/go/analysis/analysis.go
@@ -11,6 +11,7 @@ import (
"go/token"
"go/types"
"reflect"
+ "time"
)
// An Analyzer describes an analysis function and its options.
@@ -250,7 +251,19 @@ type Fact interface {
// A Module describes the module to which a package belongs.
type Module struct {
- Path string // module path
- Version string // module version ("" if unknown, such as for workspace modules)
- GoVersion string // go version used in module (e.g. "go1.22.0")
+ Path string // module path
+ Version string // module version ("" if unknown, such as for workspace modules)
+ Replace *Module // replaced by this module
+ Time *time.Time // time version was created
+ Main bool // is this the main module?
+ Indirect bool // is this module only an indirect dependency of main module?
+ Dir string // directory holding files for this module, if any
+ GoMod string // path to go.mod file used when loading this module, if any
+ GoVersion string // go version used in module (e.g. "go1.22.0")
+ Error *ModuleError // error loading module
+}
+
+// ModuleError holds errors loading a module.
+type ModuleError struct {
+ Err string // the error itself
}
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/buildssa/buildssa.go b/vendor/golang.org/x/tools/go/analysis/passes/buildssa/buildssa.go
index 37c878ef..017415f9 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/buildssa/buildssa.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/buildssa/buildssa.go
@@ -16,9 +16,7 @@ import (
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/analysis/passes/ctrlflow"
- "golang.org/x/tools/go/analysis/passes/internal/ctrlflowinternal"
"golang.org/x/tools/go/ssa"
- "golang.org/x/tools/internal/ssainternal"
)
var Analyzer = &analysis.Analyzer{
@@ -62,9 +60,7 @@ func run(pass *analysis.Pass) (any, error) {
prog := ssa.NewProgram(pass.Fset, mode)
// Use the result of the ctrlflow analysis to improve the SSA CFG.
- ssainternal.SetNoReturn(prog, func(fn *types.Func) bool {
- return ctrlflowinternal.NoReturn(cfgs, fn)
- })
+ prog.SetNoReturn(cfgs.NoReturn)
// Create SSA packages for direct imports.
for _, p := range pass.Pkg.Imports() {
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go b/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go
index b84c8d6f..4e6ea9d6 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go
@@ -16,11 +16,9 @@ import (
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/analysis/passes/inspect"
- "golang.org/x/tools/go/analysis/passes/internal/ctrlflowinternal"
"golang.org/x/tools/go/ast/inspector"
"golang.org/x/tools/go/cfg"
"golang.org/x/tools/go/types/typeutil"
- "golang.org/x/tools/internal/cfginternal"
"golang.org/x/tools/internal/typesinternal"
)
@@ -51,18 +49,19 @@ type CFGs struct {
pass *analysis.Pass // transient; nil after construction
}
-// TODO(adonovan): add (*CFGs).NoReturn to public API.
-func (c *CFGs) isNoReturn(fn *types.Func) bool {
+// NoReturn reports whether the specified control-flow graph cannot return normally.
+//
+// It is defined for at least all function symbols that appear as the static callee of a
+// CallExpr in the current package, even if the callee was imported from a dependency.
+//
+// The result may incorporate interprocedural information based on induction of
+// the "no return" property over the static call graph within the package.
+// For example, if f simply calls g and g always calls os.Exit, then both f and g may
+// be deemed never to return.
+func (c *CFGs) NoReturn(fn *types.Func) bool {
return c.noReturn[fn]
}
-func init() {
- // Expose the hidden method to callers in x/tools.
- ctrlflowinternal.NoReturn = func(c any, fn *types.Func) bool {
- return c.(*CFGs).isNoReturn(fn)
- }
-}
-
// CFGs has two maps: funcDecls for named functions and funcLits for
// unnamed ones. Unlike funcLits, the funcDecls map is not keyed by its
// syntax node, *ast.FuncDecl, because callMayReturn needs to do a
@@ -154,7 +153,7 @@ func run(pass *analysis.Pass) (any, error) {
li := funcLits[lit]
if li.cfg == nil {
li.cfg = cfg.New(lit.Body, c.callMayReturn)
- if cfginternal.IsNoReturn(li.cfg) {
+ if li.cfg.NoReturn() {
li.noReturn = true
}
}
@@ -183,7 +182,7 @@ func (c *CFGs) buildDecl(fn *types.Func, di *declInfo) {
if !known {
if di.decl.Body != nil {
di.cfg = cfg.New(di.decl.Body, c.callMayReturn)
- if cfginternal.IsNoReturn(di.cfg) {
+ if di.cfg.NoReturn() {
noreturn = true
}
}
@@ -245,7 +244,17 @@ func knownIntrinsic(fn *types.Func) (noreturn, known bool) {
// Functions known intrinsically never to return.
if typesinternal.IsFunctionNamed(fn, "syscall", "Exit", "ExitProcess", "ExitThread") ||
- typesinternal.IsFunctionNamed(fn, "runtime", "Goexit") {
+ typesinternal.IsFunctionNamed(fn, "runtime", "Goexit", "fatalthrow", "fatalpanic", "exit") ||
+ // Following staticcheck (see go/ir/exits.go) we include functions
+ // in several popular logging packages whose no-return status is
+ // beyond the analysis to infer.
+ // TODO(adonovan): make this list extensible.
+ typesinternal.IsMethodNamed(fn, "go.uber.org/zap", "Logger", "Fatal", "Panic") ||
+ typesinternal.IsMethodNamed(fn, "go.uber.org/zap", "SugaredLogger", "Fatal", "Fatalw", "Fatalf", "Panic", "Panicw", "Panicf") ||
+ typesinternal.IsMethodNamed(fn, "github.com/sirupsen/logrus", "Logger", "Exit", "Panic", "Panicf", "Panicln") ||
+ typesinternal.IsMethodNamed(fn, "github.com/sirupsen/logrus", "Entry", "Panicf", "Panicln") ||
+ typesinternal.IsFunctionNamed(fn, "k8s.io/klog", "Exit", "ExitDepth", "Exitf", "Exitln", "Fatal", "FatalDepth", "Fatalf", "Fatalln") ||
+ typesinternal.IsFunctionNamed(fn, "k8s.io/klog/v2", "Exit", "ExitDepth", "Exitf", "Exitln", "Fatal", "FatalDepth", "Fatalf", "Fatalln") {
return true, true
}
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/fieldalignment/fieldalignment.go b/vendor/golang.org/x/tools/go/analysis/passes/fieldalignment/fieldalignment.go
index 235fa4f0..53c74634 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/fieldalignment/fieldalignment.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/fieldalignment/fieldalignment.go
@@ -23,7 +23,7 @@ import (
const Doc = `find structs that would use less memory if their fields were sorted
-This analyzer find structs that can be rearranged to use less memory, and provides
+This analyzer finds structs that can be rearranged to use less memory, and provides
a suggested edit with the most compact order.
Note that there are two different diagnostics reported. One checks struct size,
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/internal/ctrlflowinternal/ctrlflowinternal.go b/vendor/golang.org/x/tools/go/analysis/passes/internal/ctrlflowinternal/ctrlflowinternal.go
deleted file mode 100644
index ee7a3722..00000000
--- a/vendor/golang.org/x/tools/go/analysis/passes/internal/ctrlflowinternal/ctrlflowinternal.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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 ctrlflowinternal exposes internals of ctrlflow.
-// It cannot actually depend on symbols from ctrlflow.
-package ctrlflowinternal
-
-import "go/types"
-
-// NoReturn exposes the (*ctrlflow.CFGs).NoReturn method to the buildssa analyzer.
-//
-// You must link [golang.org/x/tools/go/analysis/passes/ctrlflow] into your
-// application for it to be non-nil.
-var NoReturn = func(cfgs any, fn *types.Func) bool {
- panic("x/tools/go/analysis/passes/ctrlflow is not linked into this application")
-}
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go b/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go
index 28a5f6cd..dfc43136 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go
@@ -16,7 +16,6 @@ import (
"golang.org/x/tools/go/ast/inspector"
"golang.org/x/tools/go/cfg"
"golang.org/x/tools/internal/analysis/analyzerutil"
- "golang.org/x/tools/internal/astutil"
"golang.org/x/tools/internal/typesinternal"
)
@@ -84,7 +83,7 @@ func runFunc(pass *analysis.Pass, node ast.Node) {
// {FuncDecl,FuncLit,CallExpr,SelectorExpr}.
// Find the set of cancel vars to analyze.
- astutil.PreorderStack(node, nil, func(n ast.Node, stack []ast.Node) bool {
+ ast.PreorderStack(node, nil, func(n ast.Node, stack []ast.Node) bool {
if _, ok := n.(*ast.FuncLit); ok && len(stack) > 0 {
return false // don't stray into nested functions
}
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go b/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go
index a09bfd1c..1d536648 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/printf/doc.go
@@ -57,6 +57,16 @@
//
// fmt.Printf("%s", message)
//
+// The %w verb, as used in fmt.Errorf, should have an operand whose type
+// implements error, not a pointer to a type that implements error. Using a
+// pointer can result in surprising behavior when passing the resulting error to
+// errors.Is and errors.As. In the example below, MyError implements error:
+//
+// // %w wants operand of error type MyError, not pointer type *MyError (defeats errors.Is)
+// err := fmt.Errorf("%w", &MyError{Msg: "my error"})
+//
+// This feature applies only to files using at least Go 1.27.
+//
// # Inferred printf wrappers
//
// Functions that delegate their arguments to fmt.Printf are
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go b/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
index 1afb07c4..13065312 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
@@ -318,7 +318,7 @@ func findPrintLike(pass *analysis.Pass, res *Result) {
// An interface method has no body, but acts
// like an implicit call to each implementing method.
- if w.curBody.Inspector() == nil {
+ if !w.curBody.Valid() {
for impl := range impls[w.obj.(*types.Func)] {
doCall(w, impl, nil)
}
@@ -770,10 +770,6 @@ func checkPrintf(pass *analysis.Pass, fileVersion string, kind Kind, call *ast.C
anyIndex = true
}
rng := opRange(formatArg, op)
- if !okPrintfArg(pass, fileVersion, call, rng, &maxArgIndex, firstArg, name, op) {
- // One error per format is enough.
- return
- }
if op.Verb.Verb == 'w' {
switch kind {
case KindNone, KindPrint, KindPrintf:
@@ -781,6 +777,10 @@ func checkPrintf(pass *analysis.Pass, fileVersion string, kind Kind, call *ast.C
return
}
}
+ if !okPrintfArg(pass, fileVersion, call, rng, &maxArgIndex, firstArg, name, op) {
+ // One error per format is enough.
+ return
+ }
}
// Dotdotdot is hard.
if call.Ellipsis.IsValid() && maxArgIndex >= len(call.Args)-2 {
@@ -966,6 +966,26 @@ func okPrintfArg(pass *analysis.Pass, fileVersion string, call *ast.CallExpr, rn
return false
}
arg := call.Args[verbArgIndex]
+ if verb == 'w' {
+ // Check if arg is of type *E where E implements error.
+ // This diagnostic will help prevent potential misuses of errors.As,
+ // errors.Is, etc. If the %w argument in fmt.Errorf is a pointer to an error
+ // type, where the pointer type also happens to implement error, then calls
+ // to errors.Is using the result of fmt.Errorf may behave unexpectedly.
+ // See golang/go#61342.
+ typ := pass.TypesInfo.Types[arg].Type
+ if t, ok := typ.Underlying().(*types.Pointer); ok && types.Implements(t.Elem(), errorType) && versions.AtLeast(fileVersion, versions.Go1_27) {
+ // qual is a qualifier that returns the package name if different from the current package.
+ qual := func(p *types.Package) string {
+ if p == pass.Pkg {
+ return ""
+ }
+ return p.Name()
+ }
+ pass.ReportRangef(rng, "%%w wants operand of error type %s, not pointer type %s (defeats errors.Is)", types.TypeString(t.Elem(), qual), types.TypeString(typ, qual))
+ return false
+ }
+ }
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, astutil.Format(pass.Fset, arg))
return false
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go b/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go
index 31472195..d1fda880 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/stdversion/stdversion.go
@@ -99,6 +99,13 @@ func run(pass *analysis.Pass) (any, error) {
if obj, ok := pass.TypesInfo.Uses[n]; ok && obj.Pkg() != nil {
disallowed := disallowedSymbols(obj.Pkg(), fileVersion)
if minVersion, ok := disallowed[origin(obj)]; ok {
+ // Some symbols are accessible before their release but
+ // only with specific build tags unknown to us here.
+ // Avoid false positives in such cases.
+ // TODO(mkalil): move this check into typesinternal.TooNewStdSymbols.
+ if obj.Pkg().Path() == "testing/synctest" && versions.AtLeast(fileVersion, "go1.24") {
+ break // requires go1.24 && goexperiment.synctest || go1.25
+ }
noun := "module"
if fileVersion != pkgVersion {
noun = "file"
diff --git a/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go b/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
index 826add2c..7e97a4a1 100644
--- a/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
+++ b/vendor/golang.org/x/tools/go/analysis/passes/structtag/structtag.go
@@ -222,7 +222,7 @@ var (
// in the canonical format, which is a space-separated list of key:"value"
// settings. The value may contain spaces.
func validateStructTag(tag string) error {
- // This code is based on the StructTag.Get code in package reflect.
+ // This code is based on the StructTag.Lookup code in package reflect.
n := 0
for ; tag != ""; n++ {
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/cursor.go b/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
index fc9bbc71..239b10c4 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
@@ -18,8 +18,11 @@ import (
//
// Two Cursors compare equal if they represent the same node.
//
-// Call [Inspector.Root] to obtain a valid cursor for the virtual root
-// node of the traversal.
+// The zero value of Cursor is not valid.
+//
+// Call [Inspector.Root] to obtain a cursor for the virtual root node
+// of the traversal. This is the sole valid cursor for which [Cursor.Node]
+// returns nil.
//
// Use the following methods to navigate efficiently around the tree:
// - for ancestors, use [Cursor.Parent] and [Cursor.Enclosing];
@@ -37,7 +40,7 @@ type Cursor struct {
index int32 // index of push node; -1 for virtual root node
}
-// Root returns a cursor for the virtual root node,
+// Root returns a valid cursor for the virtual root node,
// whose children are the files provided to [New].
//
// Its [Cursor.Node] method return nil.
@@ -61,14 +64,23 @@ func (in *Inspector) At(index int32) Cursor {
return Cursor{in, index}
}
+// Valid reports whether the cursor is valid.
+// The zero value of cursor is invalid.
+// Unless otherwise documented, it is not safe to call
+// any other method on an invalid cursor.
+func (c Cursor) Valid() bool {
+ return c.in != nil
+}
+
// Inspector returns the cursor's Inspector.
+// It returns nil if the Cursor is not valid.
func (c Cursor) Inspector() *Inspector { return c.in }
// Index returns the index of this cursor position within the package.
//
// Clients should not assume anything about the numeric Index value
// except that it increases monotonically throughout the traversal.
-// It is provided for use with [At].
+// It is provided for use with [Inspector.At].
//
// Index must not be called on the Root node.
func (c Cursor) Index() int32 {
@@ -89,7 +101,7 @@ func (c Cursor) Node() ast.Node {
// String returns information about the cursor's node, if any.
func (c Cursor) String() string {
- if c.in == nil {
+ if !c.Valid() {
return "(invalid)"
}
if c.index < 0 {
@@ -233,6 +245,18 @@ func (c Cursor) ParentEdge() (edge.Kind, int) {
return unpackEdgeKindAndIndex(events[pop].parent)
}
+// ParentEdgeKind returns the kind component of the result of [Cursor.ParentEdge].
+func (c Cursor) ParentEdgeKind() edge.Kind {
+ ek, _ := c.ParentEdge()
+ return ek
+}
+
+// ParentEdgeIndex returns the index component of the result of [Cursor.ParentEdge].
+func (c Cursor) ParentEdgeIndex() int {
+ _, index := c.ParentEdge()
+ return index
+}
+
// ChildAt returns the cursor for the child of the
// current node identified by its edge and index.
// The index must be -1 if the edge.Kind is not a slice.
@@ -453,6 +477,9 @@ func (c Cursor) FindNode(n ast.Node) (Cursor, bool) {
// rooted at c such that n.Pos() <= start && end <= n.End().
// (For an *ast.File, it uses the bounds n.FileStart-n.FileEnd.)
//
+// An empty range (start == end) between two adjacent nodes is
+// considered to belong to the first node.
+//
// It returns zero if none is found.
// Precondition: start <= end.
//
@@ -501,10 +528,17 @@ func (c Cursor) FindByPos(start, end token.Pos) (Cursor, bool) {
break // disjoint, after; stop
}
}
+
// Inv: node.{Pos,FileStart} <= start
if end <= nodeEnd {
// node fully contains target range
best = i
+
+ // Don't search beyond end of the first match.
+ // This is important only for an empty range (start=end)
+ // between two adjoining nodes, which would otherwise
+ // match both nodes; we want to match only the first.
+ limit = ev.index
} else if nodeEnd < start {
i = ev.index // disjoint, before; skip forward
}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go b/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
index a703cdfc..b414d17e 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
@@ -87,7 +87,7 @@ type event struct {
// Type can be recovered from the sole bit in typ.
// [Tried this, wasn't faster. --adonovan]
-// Preorder visits all the nodes of the files supplied to New in
+// Preorder visits all the nodes of the files supplied to [New] in
// depth-first order. It calls f(n) for each node n before it visits
// n's children.
//
@@ -133,7 +133,7 @@ func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
}
}
-// Nodes visits the nodes of the files supplied to New in depth-first
+// Nodes visits the nodes of the files supplied to [New] in depth-first
// order. It calls f(n, true) for each node n before it visits n's
// children. If f returns true, Nodes invokes f recursively for each
// of the non-nil children of the node, followed by a call of
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/iter.go b/vendor/golang.org/x/tools/go/ast/inspector/iter.go
index c576dc70..b68c553d 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/iter.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/iter.go
@@ -12,13 +12,31 @@ import (
)
// PreorderSeq returns an iterator that visits all the
-// nodes of the files supplied to New in depth-first order.
+// nodes of the files supplied to [New] in depth-first order.
// It visits each node n before n's children.
// The complete traversal sequence is determined by ast.Inspect.
//
-// The types argument, if non-empty, enables type-based
-// filtering of events: only nodes whose type matches an
-// element of the types slice are included in the sequence.
+// The types argument, if non-empty, enables type-based filtering:
+// only nodes whose type matches an element of the types slice are
+// included in the sequence.
+//
+// Example:
+//
+// for call := range in.PreorderSeq((*ast.CallExpr)(nil)) { ... }
+//
+// The [All] function is more convenient if there is exactly one node type:
+//
+// for call := range All[*ast.CallExpr](in) { ... }
+//
+// See also the newer and more flexible [Cursor] API, which lets you
+// start the traversal at an arbitrary node, and reports each matching
+// node by its Cursor, enabling easier navigation.
+// The above example would be written thus:
+//
+// for curCall := range in.Root().Preorder((*ast.CallExpr)(nil)) {
+// call := curCall.Node().(*ast.CallExpr)
+// ...
+// }
func (in *Inspector) PreorderSeq(types ...ast.Node) iter.Seq[ast.Node] {
// This implementation is identical to Preorder,
@@ -53,6 +71,16 @@ func (in *Inspector) PreorderSeq(types ...ast.Node) iter.Seq[ast.Node] {
// Example:
//
// for call := range All[*ast.CallExpr](in) { ... }
+//
+// See also the newer and more flexible [Cursor] API, which lets you
+// start the traversal at an arbitrary node, and reports each matching
+// node by its Cursor, enabling easier navigation.
+// The above example would be written thus:
+//
+// for curCall := range in.Root().Preorder((*ast.CallExpr)(nil)) {
+// call := curCall.Node().(*ast.CallExpr)
+// ...
+// }
func All[N interface {
*S
ast.Node
diff --git a/vendor/golang.org/x/tools/go/cfg/cfg.go b/vendor/golang.org/x/tools/go/cfg/cfg.go
index 38aba77c..f69912c8 100644
--- a/vendor/golang.org/x/tools/go/cfg/cfg.go
+++ b/vendor/golang.org/x/tools/go/cfg/cfg.go
@@ -47,8 +47,6 @@ import (
"go/ast"
"go/format"
"go/token"
-
- "golang.org/x/tools/internal/cfginternal"
)
// A CFG represents the control-flow graph of a single function.
@@ -59,6 +57,9 @@ type CFG struct {
noreturn bool // function body lacks a reachable return statement
}
+// NoReturn reports whether the function has no reachable return.
+func (cfg *CFG) NoReturn() bool { return cfg.noreturn }
+
// A Block represents a basic block: a list of statements and
// expressions that are always evaluated sequentially.
//
@@ -184,14 +185,6 @@ func New(body *ast.BlockStmt, mayReturn func(*ast.CallExpr) bool) *CFG {
return &CFG{Blocks: b.blocks, noreturn: noreturn}
}
-// isNoReturn reports whether the function has no reachable return.
-// TODO(adonovan): add (*CFG).NoReturn to public API.
-func isNoReturn(_cfg any) bool { return _cfg.(*CFG).noreturn }
-
-func init() {
- cfginternal.IsNoReturn = isNoReturn // expose to ctrlflow analyzer
-}
-
func (b *Block) String() string {
return fmt.Sprintf("block %d (%s)", b.Index, b.comment(nil))
}
diff --git a/vendor/golang.org/x/tools/go/packages/golist.go b/vendor/golang.org/x/tools/go/packages/golist.go
index 680a70ca..a6c17cf6 100644
--- a/vendor/golang.org/x/tools/go/packages/golist.go
+++ b/vendor/golang.org/x/tools/go/packages/golist.go
@@ -61,13 +61,42 @@ func (r *responseDeduper) addAll(dr *DriverResponse) {
}
func (r *responseDeduper) addPackage(p *Package) {
- if r.seenPackages[p.ID] != nil {
+ if prev := r.seenPackages[p.ID]; prev != nil {
+ // Package already seen in a previous response. Merge the file lists,
+ // removing duplicates. This can happen when the same package appears
+ // in multiple driver responses that are being merged together.
+ prev.GoFiles = appendUniqueStrings(prev.GoFiles, p.GoFiles)
+ prev.CompiledGoFiles = appendUniqueStrings(prev.CompiledGoFiles, p.CompiledGoFiles)
+ prev.OtherFiles = appendUniqueStrings(prev.OtherFiles, p.OtherFiles)
+ prev.IgnoredFiles = appendUniqueStrings(prev.IgnoredFiles, p.IgnoredFiles)
+ prev.EmbedFiles = appendUniqueStrings(prev.EmbedFiles, p.EmbedFiles)
+ prev.EmbedPatterns = appendUniqueStrings(prev.EmbedPatterns, p.EmbedPatterns)
return
}
r.seenPackages[p.ID] = p
r.dr.Packages = append(r.dr.Packages, p)
}
+// appendUniqueStrings appends elements from src to dst, skipping duplicates.
+func appendUniqueStrings(dst, src []string) []string {
+ if len(src) == 0 {
+ return dst
+ }
+
+ seen := make(map[string]bool, len(dst))
+ for _, s := range dst {
+ seen[s] = true
+ }
+
+ for _, s := range src {
+ if !seen[s] {
+ dst = append(dst, s)
+ }
+ }
+
+ return dst
+}
+
func (r *responseDeduper) addRoot(id string) {
if r.seenRoots[id] {
return
@@ -832,6 +861,8 @@ func golistargs(cfg *Config, words []string, goVersion int) []string {
// go list doesn't let you pass -test and -find together,
// probably because you'd just get the TestMain.
fmt.Sprintf("-find=%t", !cfg.Tests && cfg.Mode&findFlags == 0 && !usesExportData(cfg)),
+ // VCS information is not needed when not printing Stale or StaleReason fields
+ "-buildvcs=false",
}
// golang/go#60456: with go1.21 and later, go list serves pgo variants, which
diff --git a/vendor/golang.org/x/tools/go/packages/packages.go b/vendor/golang.org/x/tools/go/packages/packages.go
index ff607389..412ba06b 100644
--- a/vendor/golang.org/x/tools/go/packages/packages.go
+++ b/vendor/golang.org/x/tools/go/packages/packages.go
@@ -284,6 +284,8 @@ func Load(cfg *Config, patterns ...string) ([]*Package, error) {
}
}
+ ld.externalDriver = external
+
return ld.refine(response)
}
@@ -401,6 +403,10 @@ func mergeResponses(responses ...*DriverResponse) *DriverResponse {
if len(responses) == 0 {
return nil
}
+ // No dedup needed
+ if len(responses) == 1 {
+ return responses[0]
+ }
response := newDeduper()
response.dr.NotHandled = false
response.dr.Compiler = responses[0].Compiler
@@ -692,10 +698,11 @@ type loaderPackage struct {
type loader struct {
pkgs map[string]*loaderPackage // keyed by Package.ID
Config
- sizes types.Sizes // non-nil if needed by mode
- parseCache map[string]*parseValue
- parseCacheMu sync.Mutex
- exportMu sync.Mutex // enforces mutual exclusion of exportdata operations
+ sizes types.Sizes // non-nil if needed by mode
+ parseCache map[string]*parseValue
+ parseCacheMu sync.Mutex
+ exportMu sync.Mutex // enforces mutual exclusion of exportdata operations
+ externalDriver bool // true if an external GOPACKAGESDRIVER handled the request
// Config.Mode contains the implied mode (see impliedLoadMode).
// Implied mode contains all the fields we need the data for.
@@ -1226,6 +1233,10 @@ func (ld *loader) loadPackage(lpkg *loaderPackage) {
}
if lpkg.Module != nil && lpkg.Module.GoVersion != "" {
tc.GoVersion = "go" + lpkg.Module.GoVersion
+ } else if ld.externalDriver && lpkg.goVersion != 0 {
+ // Module information is missing when GOPACKAGESDRIVER is used,
+ // so use the go version from the driver response.
+ tc.GoVersion = fmt.Sprintf("go1.%d", lpkg.goVersion)
}
if (ld.Mode & typecheckCgo) != 0 {
if !typesinternal.SetUsesCgo(tc) {
diff --git a/vendor/golang.org/x/tools/go/ssa/builder.go b/vendor/golang.org/x/tools/go/ssa/builder.go
index a75257c8..24207492 100644
--- a/vendor/golang.org/x/tools/go/ssa/builder.go
+++ b/vendor/golang.org/x/tools/go/ssa/builder.go
@@ -100,6 +100,7 @@ var (
// Type constants.
tBool = types.Typ[types.Bool]
tByte = types.Typ[types.Byte]
+ tRune = types.Universe.Lookup("rune").Type() // prints as "rune" (Typ[Rune] is same as Int32)
tInt = types.Typ[types.Int]
tInvalid = types.Typ[types.Invalid]
tString = types.Typ[types.String]
@@ -892,6 +893,10 @@ func (b *builder) expr0(fn *Function, e ast.Expr, tv types.TypeAndValue) Value {
bound := createBound(fn.Prog, obj)
b.enqueue(bound)
+ // The assignment may widen a type parameter to its
+ // interface bound (case #3 of go.dev/issue.78110).
+ v = emitConv(fn, v, bound.FreeVars[0].Type())
+
c := &MakeClosure{
Fn: bound,
Bindings: []Value{v},
@@ -1270,7 +1275,7 @@ func (b *builder) arrayLen(fn *Function, elts []ast.Expr) int64 {
// x := T{a: 1}
// x = T{a: x.a}
//
-// all the reads must occur before all the writes. Thus all stores to
+// all the reads must occur before all the writes. Thus all stores to
// loc are emitted to the storebuf sb for later execution.
//
// A CompositeLit may have pointer type only in the recursive (nested)
@@ -1287,28 +1292,35 @@ func (b *builder) compLit(fn *Function, addr Value, e *ast.CompositeLit, isZero
sb.store(&address{addr, e.Lbrace, nil}, zeroConst(zt))
isZero = true
}
+ var fIndices []int
for i, e := range e.Elts {
- fieldIndex := i
- pos := e.Pos()
- if kv, ok := e.(*ast.KeyValueExpr); ok {
+ var (
+ pos token.Pos
+ fType types.Type
+ )
+
+ if kv, ok := e.(*ast.KeyValueExpr); ok { // tagged field
fname := kv.Key.(*ast.Ident).Name
- for i, n := 0, t.NumFields(); i < n; i++ {
- sf := t.Field(i)
- if sf.Name() == fname {
- fieldIndex = i
- pos = kv.Colon
- e = kv.Value
- break
- }
- }
+ obj, index, _ := types.LookupFieldOrMethod(t, true, fn.declaredPackage().Pkg, fname)
+ fIndices = append(fIndices[:0], index...)
+ pos = kv.Colon
+ e = kv.Value
+ fType = obj.Type()
+ } else { // untagged field
+ fIndices = append(fIndices[:0], i)
+ pos = e.Pos()
+ fType = t.Field(i).Type()
}
- sf := t.Field(fieldIndex)
+
+ last := len(fIndices) - 1
+ v := emitImplicitSelections(fn, addr, fIndices[:last], pos)
+
faddr := &FieldAddr{
- X: addr,
- Field: fieldIndex,
+ X: v,
+ Field: fIndices[last],
}
faddr.setPos(pos)
- faddr.setType(types.NewPointer(sf.Type()))
+ faddr.setType(types.NewPointer(fType))
fn.emit(faddr)
b.assign(fn, &address{addr: faddr, pos: pos, expr: e}, e, isZero, sb)
}
@@ -1467,13 +1479,14 @@ func (b *builder) switchStmt(fn *Function, s *ast.SwitchStmt, label *lblock) {
var nextCond *BasicBlock
for _, cond := range cc.List {
nextCond = fn.newBasicBlock("switch.next")
- // TODO(adonovan): opt: when tag==vTrue, we'd
- // get better code if we use b.cond(cond)
- // instead of BinOp(EQL, tag, b.expr(cond))
- // followed by If. Don't forget conversions
- // though.
- cond := emitCompare(fn, token.EQL, tag, b.expr(fn, cond), cond.Pos())
- emitIf(fn, cond, body, nextCond)
+ // For boolean switches, emit short-circuit control flow,
+ // just like an if/else-chain.
+ if tag == vTrue && !isNonTypeParamInterface(fn.info.Types[cond].Type) {
+ b.cond(fn, cond, body, nextCond)
+ } else {
+ c := emitCompare(fn, token.EQL, tag, b.expr(fn, cond), cond.Pos())
+ emitIf(fn, c, body, nextCond)
+ }
fn.currentBlock = nextCond
}
fn.currentBlock = body
@@ -2149,13 +2162,6 @@ func (b *builder) rangeIter(fn *Function, x Value, tk, tv types.Type, pos token.
// done: (target of break)
//
- if tk == nil {
- tk = tInvalid
- }
- if tv == nil {
- tv = tInvalid
- }
-
rng := &Range{X: x}
rng.setPos(pos)
rng.setType(tRangeIter)
@@ -2165,14 +2171,29 @@ func (b *builder) rangeIter(fn *Function, x Value, tk, tv types.Type, pos token.
emitJump(fn, loop)
fn.currentBlock = loop
+ var ak, av types.Type
+ isString := false
+ if m, ok := typeparams.CoreType(x.Type()).(*types.Map); ok {
+ ak, av = m.Key(), m.Elem()
+ } else {
+ isString = true
+ ak, av = tInt, tRune
+ }
+ if tk == nil {
+ ak = tInvalid
+ }
+ if tv == nil {
+ av = tInvalid
+ }
+
okv := &Next{
Iter: it,
- IsString: isBasic(typeparams.CoreType(x.Type())),
+ IsString: isString,
}
okv.setType(types.NewTuple(
varOk,
- newVar("k", tk),
- newVar("v", tv),
+ newVar("k", ak),
+ newVar("v", av),
))
fn.emit(okv)
@@ -2181,11 +2202,14 @@ func (b *builder) rangeIter(fn *Function, x Value, tk, tv types.Type, pos token.
emitIf(fn, emitExtract(fn, okv, 0), body, done)
fn.currentBlock = body
- if tk != tInvalid {
- k = emitExtract(fn, okv, 1)
+ // The assignment may widen a map or string
+ // key/value to a variable's interface type
+ // (cases #1 and #2 of go.dev/issue/78110).
+ if tk != nil {
+ k = emitConv(fn, emitExtract(fn, okv, 1), tk)
}
- if tv != tInvalid {
- v = emitExtract(fn, okv, 2)
+ if tv != nil {
+ v = emitConv(fn, emitExtract(fn, okv, 2), tv)
}
return
}
diff --git a/vendor/golang.org/x/tools/go/ssa/create.go b/vendor/golang.org/x/tools/go/ssa/create.go
index bbf88567..d94cb6fb 100644
--- a/vendor/golang.org/x/tools/go/ssa/create.go
+++ b/vendor/golang.org/x/tools/go/ssa/create.go
@@ -15,7 +15,6 @@ import (
"os"
"sync"
- "golang.org/x/tools/internal/ssainternal"
"golang.org/x/tools/internal/versions"
)
@@ -314,19 +313,13 @@ func (prog *Program) ImportedPackage(path string) *Package {
return prog.imported[path]
}
-// setNoReturn sets the predicate used by the SSA builder to decide
-// whether a call to the specified named function cannot return,
-// allowing the builder to prune control-flow edges following the
-// call, thus improving the precision of downstream analysis.
+// SetNoReturn sets the predicate used when building the ssa.Program
+// prog that reports whether a given function cannot return.
+// This may be used to prune spurious control flow edges
+// after (e.g.) log.Fatal, improving the precision of analyses.
//
-// TODO(adonovan): add (*Program).SetNoReturn to the public API.
-func (prog *Program) setNoReturn(noReturn func(*types.Func) bool) {
+// A typical implementation is the [ctrlflow.CFGs.NoReturn] method from
+// [golang.org/x/tools/go/analysis/passes/ctrlflow].
+func (prog *Program) SetNoReturn(noReturn func(*types.Func) bool) {
prog.noReturn = noReturn
}
-
-func init() {
- // SetNoReturn exposes Program.setNoReturn to the buildssa analyzer.
- ssainternal.SetNoReturn = func(prog any, noReturn func(*types.Func) bool) {
- prog.(*Program).setNoReturn(noReturn)
- }
-}
diff --git a/vendor/golang.org/x/tools/go/ssa/sanity.go b/vendor/golang.org/x/tools/go/ssa/sanity.go
index c47a137c..5bd5d97d 100644
--- a/vendor/golang.org/x/tools/go/ssa/sanity.go
+++ b/vendor/golang.org/x/tools/go/ssa/sanity.go
@@ -16,6 +16,8 @@ import (
"os"
"slices"
"strings"
+
+ "golang.org/x/tools/internal/typeparams"
)
type sanity struct {
@@ -154,12 +156,17 @@ func (s *sanity) checkInstr(idx int, instr Instruction) {
case *Lookup:
case *MakeChan:
case *MakeClosure:
- numFree := len(instr.Fn.(*Function).FreeVars)
- numBind := len(instr.Bindings)
- if numFree != numBind {
+ fn := instr.Fn.(*Function)
+ if numFree, numBind := len(fn.FreeVars), len(instr.Bindings); numFree != numBind {
s.errorf("MakeClosure has %d Bindings for function %s with %d free vars",
numBind, instr.Fn, numFree)
-
+ } else {
+ for i, fv := range fn.FreeVars {
+ if !types.Identical(instr.Bindings[i].Type(), fv.Type()) {
+ s.errorf("MakeClosure binding %d for %s has type %s, expected %s",
+ i, fv.Name(), instr.Bindings[i].Type(), fv.Type())
+ }
+ }
}
if recv := instr.Type().(*types.Signature).Recv(); recv != nil {
s.errorf("MakeClosure's type includes receiver %s", recv.Type())
@@ -170,12 +177,42 @@ func (s *sanity) checkInstr(idx int, instr Instruction) {
case *MakeSlice:
case *MapUpdate:
case *Next:
+ rng, ok := instr.Iter.(*Range)
+ if !ok {
+ s.errorf("Next: Iter is %T, not *Range", instr.Iter)
+ }
+ if rng.Type() != tRangeIter {
+ s.errorf("Next: Iter has type %s, expected %s", rng.Type(), tRangeIter)
+ }
+ var ek, ev types.Type
+ switch xt := typeparams.CoreType(rng.X.Type()).(type) {
+ case *types.Basic:
+ if types.Default(xt) != tString {
+ s.errorf("Next: basic operand of Next.Iter (Range) is %s, want string or untyped string", xt)
+ }
+ ek, ev = tInt, tRune
+ case *types.Map:
+ ek, ev = xt.Key(), xt.Elem()
+ }
+
+ res := instr.Type().(*types.Tuple) // (ok bool, k K, v V), but K or V may be invalid if unused
+ if !types.Identical(res.At(1).Type(), ek) && res.At(1).Type() != tInvalid {
+ s.errorf("Next: key type %s does not match map key type %s", res.At(1).Type(), ek)
+ }
+ if !types.Identical(res.At(2).Type(), ev) && res.At(2).Type() != tInvalid {
+ s.errorf("Next: value type %s does not match map value type %s", res.At(2).Type(), ev)
+ }
+
case *Range:
case *RunDefers:
case *Select:
case *Send:
case *Slice:
case *Store:
+ if !types.Identical(instr.Val.Type(), typeparams.CoreType(instr.Addr.Type()).(*types.Pointer).Elem()) {
+ s.errorf("Store: value type %s does not match address type %s",
+ instr.Val.Type(), instr.Addr.Type())
+ }
case *TypeAssert:
case *UnOp:
case *DebugRef:
diff --git a/vendor/golang.org/x/tools/go/ssa/subst.go b/vendor/golang.org/x/tools/go/ssa/subst.go
index 5799a078..a5441690 100644
--- a/vendor/golang.org/x/tools/go/ssa/subst.go
+++ b/vendor/golang.org/x/tools/go/ssa/subst.go
@@ -319,10 +319,10 @@ func (subst *subster) interface_(iface *types.Interface) *types.Interface {
func (subst *subster) alias(t *types.Alias) types.Type {
// See subster.named. This follows the same strategy.
- tparams := aliases.TypeParams(t)
- targs := aliases.TypeArgs(t)
+ tparams := t.TypeParams()
+ targs := t.TypeArgs()
tname := t.Obj()
- torigin := aliases.Origin(t)
+ torigin := t.Origin()
if !declaredWithin(tname, subst.origin) {
// t is declared outside of the function origin. So t is a package level type alias.
@@ -361,15 +361,10 @@ func (subst *subster) alias(t *types.Alias) types.Type {
}
// Substitute rhs.
- rhs := subst.typ(aliases.Rhs(t))
+ rhs := subst.typ(t.Rhs())
// Create the fresh alias.
- //
- // Until 1.27, the result of aliases.NewAlias(...).Type() cannot guarantee it is a *types.Alias.
- // However, as t is an *alias.Alias and t is well-typed, then aliases must have been enabled.
- // Follow this decision, and always enable aliases here.
- const enabled = true
- obj := aliases.NewAlias(enabled, tname.Pos(), tname.Pkg(), tname.Name(), rhs, newTParams)
+ obj := aliases.New(tname.Pos(), tname.Pkg(), tname.Name(), rhs, newTParams)
// Substitute into all of the constraints after they are created.
for i, ntp := range newTParams {
diff --git a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
index 6646bf55..77aad553 100644
--- a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
+++ b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
@@ -29,7 +29,6 @@ import (
"strconv"
"strings"
- "golang.org/x/tools/internal/aliases"
"golang.org/x/tools/internal/typesinternal"
)
@@ -281,10 +280,10 @@ func (enc *Encoder) For(obj types.Object) (Path, error) {
T := o.Type()
if alias, ok := T.(*types.Alias); ok {
- if r := findTypeParam(obj, aliases.TypeParams(alias), path, opTypeParam); r != nil {
+ if r := findTypeParam(obj, alias.TypeParams(), path, opTypeParam); r != nil {
return Path(r), nil
}
- if r := find(obj, aliases.Rhs(alias), append(path, opRhs)); r != nil {
+ if r := find(obj, alias.Rhs(), append(path, opRhs)); r != nil {
return Path(r), nil
}
@@ -525,7 +524,7 @@ func (f *finder) find(T types.Type, path []byte) []byte {
for i := 0; i < T.NumMethods(); i++ {
m := T.Method(i)
if f.seenMethods[m] {
- return nil
+ continue // break cycles (see TestIssue70418)
}
path2 := appendOpArg(path, opMethod, i)
if m == f.obj {
@@ -694,14 +693,11 @@ func Object(pkg *types.Package, p Path) (types.Object, error) {
case opRhs:
if alias, ok := t.(*types.Alias); ok {
- t = aliases.Rhs(alias)
- } else if false && aliases.Enabled() {
- // The Enabled check is too expensive, so for now we
- // simply assume that aliases are not enabled.
- //
+ t = alias.Rhs()
+ } else if false {
// Now that go1.24 is assured, we should be able to
- // replace this with "if true {", but it causes tests
- // to fail. TODO(adonovan): investigate.
+ // replace this with "if true {", but it causes objectpath
+ // tests to fail. TODO(adonovan): investigate.
return nil, fmt.Errorf("cannot apply %q to %s (got %T, want alias)", code, t, t)
}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases.go b/vendor/golang.org/x/tools/internal/aliases/aliases.go
index b9425f5a..a4ae04bc 100644
--- a/vendor/golang.org/x/tools/internal/aliases/aliases.go
+++ b/vendor/golang.org/x/tools/internal/aliases/aliases.go
@@ -9,30 +9,10 @@ import (
"go/types"
)
-// Package aliases defines backward compatible shims
-// for the types.Alias type representation added in 1.22.
-// This defines placeholders for x/tools until 1.26.
-
-// NewAlias creates a new TypeName in Package pkg that
+// New creates a new TypeName in Package pkg that
// is an alias for the type rhs.
-//
-// The enabled parameter determines whether the resulting [TypeName]'s
-// type is an [types.Alias]. Its value must be the result of a call to
-// [Enabled], which computes the effective value of
-// GODEBUG=gotypesalias=... by invoking the type checker. The Enabled
-// function is expensive and should be called once per task (e.g.
-// package import), not once per call to NewAlias.
-//
-// Precondition: enabled || len(tparams)==0.
-// If materialized aliases are disabled, there must not be any type parameters.
-func NewAlias(enabled bool, pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
- if enabled {
- tname := types.NewTypeName(pos, pkg, name, nil)
- SetTypeParams(types.NewAlias(tname, rhs), tparams)
- return tname
- }
- if len(tparams) > 0 {
- panic("cannot create an alias with type parameters when gotypesalias is not enabled")
- }
- return types.NewTypeName(pos, pkg, name, rhs)
+func New(pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
+ tname := types.NewTypeName(pos, pkg, name, nil)
+ types.NewAlias(tname, rhs).SetTypeParams(tparams)
+ return tname
}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go b/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
deleted file mode 100644
index 7716a333..00000000
--- a/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2024 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 aliases
-
-import (
- "go/ast"
- "go/parser"
- "go/token"
- "go/types"
-)
-
-// Rhs returns the type on the right-hand side of the alias declaration.
-func Rhs(alias *types.Alias) types.Type {
- if alias, ok := any(alias).(interface{ Rhs() types.Type }); ok {
- return alias.Rhs() // go1.23+
- }
-
- // go1.22's Alias didn't have the Rhs method,
- // so Unalias is the best we can do.
- return types.Unalias(alias)
-}
-
-// TypeParams returns the type parameter list of the alias.
-func TypeParams(alias *types.Alias) *types.TypeParamList {
- if alias, ok := any(alias).(interface{ TypeParams() *types.TypeParamList }); ok {
- return alias.TypeParams() // go1.23+
- }
- return nil
-}
-
-// SetTypeParams sets the type parameters of the alias type.
-func SetTypeParams(alias *types.Alias, tparams []*types.TypeParam) {
- if alias, ok := any(alias).(interface {
- SetTypeParams(tparams []*types.TypeParam)
- }); ok {
- alias.SetTypeParams(tparams) // go1.23+
- } else if len(tparams) > 0 {
- panic("cannot set type parameters of an Alias type in go1.22")
- }
-}
-
-// TypeArgs returns the type arguments used to instantiate the Alias type.
-func TypeArgs(alias *types.Alias) *types.TypeList {
- if alias, ok := any(alias).(interface{ TypeArgs() *types.TypeList }); ok {
- return alias.TypeArgs() // go1.23+
- }
- return nil // empty (go1.22)
-}
-
-// Origin returns the generic Alias type of which alias is an instance.
-// If alias is not an instance of a generic alias, Origin returns alias.
-func Origin(alias *types.Alias) *types.Alias {
- if alias, ok := any(alias).(interface{ Origin() *types.Alias }); ok {
- return alias.Origin() // go1.23+
- }
- return alias // not an instance of a generic alias (go1.22)
-}
-
-// Enabled reports whether [NewAlias] should create [types.Alias] types.
-//
-// This function is expensive! Call it sparingly.
-func Enabled() bool {
- // The only reliable way to compute the answer is to invoke go/types.
- // We don't parse the GODEBUG environment variable, because
- // (a) it's tricky to do so in a manner that is consistent
- // with the godebug package; in particular, a simple
- // substring check is not good enough. The value is a
- // rightmost-wins list of options. But more importantly:
- // (b) it is impossible to detect changes to the effective
- // setting caused by os.Setenv("GODEBUG"), as happens in
- // many tests. Therefore any attempt to cache the result
- // is just incorrect.
- fset := token.NewFileSet()
- f, _ := parser.ParseFile(fset, "a.go", "package p; type A = int", parser.SkipObjectResolution)
- pkg, _ := new(types.Config).Check("p", fset, []*ast.File{f}, nil)
- _, enabled := pkg.Scope().Lookup("A").Type().(*types.Alias)
- return enabled
-}
diff --git a/vendor/golang.org/x/tools/internal/analysis/analyzerutil/version.go b/vendor/golang.org/x/tools/internal/analysis/analyzerutil/version.go
index 0b9bcc37..700d53ef 100644
--- a/vendor/golang.org/x/tools/internal/analysis/analyzerutil/version.go
+++ b/vendor/golang.org/x/tools/internal/analysis/analyzerutil/version.go
@@ -17,6 +17,9 @@ import (
// FileUsesGoVersion reports whether the specified file may use features of the
// specified version of Go (e.g. "go1.24").
//
+// It returns false when version information is not available,
+// such as for parsed files that are ignored by the type checker.
+//
// Tip: we recommend using this check "late", just before calling
// pass.Report, rather than "early" (when entering each ast.File, or
// each candidate node of interest, during the traversal), because the
@@ -24,7 +27,10 @@ import (
// fraction of files that pass most version checks is high and
// increases over time.
func FileUsesGoVersion(pass *analysis.Pass, file *ast.File, version string) (_res bool) {
- fileVersion := pass.TypesInfo.FileVersions[file]
+ fileVersion, ok := pass.TypesInfo.FileVersions[file]
+ if !ok {
+ return false // be conservative in the absence of information (e.g. IgnoredFiles)
+ }
// Standard packages that are part of toolchain bootstrapping
// are not considered to use a version of Go later than the
diff --git a/vendor/golang.org/x/tools/internal/astutil/comment.go b/vendor/golang.org/x/tools/internal/astutil/comment.go
index 7e52aeaa..5ed4765c 100644
--- a/vendor/golang.org/x/tools/internal/astutil/comment.go
+++ b/vendor/golang.org/x/tools/internal/astutil/comment.go
@@ -31,7 +31,7 @@ func Deprecation(doc *ast.CommentGroup) string {
// -- plundered from the future (CL 605517, issue #68021) --
-// TODO(adonovan): replace with ast.Directive after go1.25 (#68021).
+// TODO(adonovan): replace with ast.Directive in go1.26 (#68021).
// Beware of our local mods to handle analysistest
// "want" comments on the same line.
diff --git a/vendor/golang.org/x/tools/internal/astutil/stringlit.go b/vendor/golang.org/x/tools/internal/astutil/stringlit.go
index ce1e7de8..eb49d451 100644
--- a/vendor/golang.org/x/tools/internal/astutil/stringlit.go
+++ b/vendor/golang.org/x/tools/internal/astutil/stringlit.go
@@ -40,20 +40,64 @@ func PosInStringLiteral(lit *ast.BasicLit, offset int) (token.Pos, error) {
return 0, fmt.Errorf("invalid offset")
}
+ pos, _ := walkStringLiteral(lit, lit.End(), offset)
+ return pos, nil
+}
+
+// OffsetInStringLiteral returns the byte offset within the logical (unquoted)
+// string corresponding to the specified source position.
+func OffsetInStringLiteral(lit *ast.BasicLit, pos token.Pos) (int, error) {
+ if !NodeContainsPos(lit, pos) {
+ return 0, fmt.Errorf("invalid position")
+ }
+
+ raw := lit.Value
+
+ value, err := strconv.Unquote(raw)
+ if err != nil {
+ return 0, err
+ }
+
+ _, offset := walkStringLiteral(lit, pos, len(value))
+ return offset, nil
+}
+
+// walkStringLiteral iterates through the raw string literal to map between
+// a file position and a logical byte offset. It stops when it reaches
+// either the targetPos or the targetOffset.
+//
+// TODO(hxjiang): consider making an iterator.
+func walkStringLiteral(lit *ast.BasicLit, targetPos token.Pos, targetOffset int) (token.Pos, int) {
+ raw := lit.Value
+ norm := int(lit.End()-lit.Pos()) > len(lit.Value)
+
// remove quotes
quote := raw[0] // '"' or '`'
raw = raw[1 : len(raw)-1]
var (
- i = 0 // byte index within logical value
- pos = lit.ValuePos + 1 // position within literal
+ i = 0 // byte index within logical value
+ pos = lit.Pos() + 1 // position within literal
)
- for raw != "" && i < offset {
+
+ for raw != "" {
r, _, rest, _ := strconv.UnquoteChar(raw, quote) // can't fail
sz := len(raw) - len(rest) // length of literal char in raw bytes
- pos += token.Pos(sz)
+
+ nextPos := pos + token.Pos(sz)
+ if norm && r == '\n' {
+ nextPos++
+ }
+ nextI := i + utf8.RuneLen(r) // length of logical char in "cooked" bytes
+
+ if nextPos > targetPos || nextI > targetOffset {
+ break
+ }
+
raw = raw[sz:]
- i += utf8.RuneLen(r)
+ i = nextI
+ pos = nextPos
}
- return pos, nil
+
+ return pos, i
}
diff --git a/vendor/golang.org/x/tools/internal/astutil/util.go b/vendor/golang.org/x/tools/internal/astutil/util.go
index 6986a518..b855a560 100644
--- a/vendor/golang.org/x/tools/internal/astutil/util.go
+++ b/vendor/golang.org/x/tools/internal/astutil/util.go
@@ -11,45 +11,10 @@ import (
"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,
-// calling f before visiting each node.
-//
-// Each call to f provides the current node and traversal stack,
-// consisting of the original value of stack appended with all nodes
-// from root to n, excluding n itself. (This design allows calls
-// to PreorderStack to be nested without double counting.)
-//
-// If f returns false, the traversal skips over that subtree. Unlike
-// [ast.Inspect], no second call to f is made after visiting node n.
-// In practice, the second call is nearly always used only to pop the
-// stack, and it is surprisingly tricky to do this correctly; see
-// https://go.dev/issue/73319.
-//
-// TODO(adonovan): replace with [ast.PreorderStack] when go1.25 is assured.
-func PreorderStack(root ast.Node, stack []ast.Node, f func(n ast.Node, stack []ast.Node) bool) {
- before := len(stack)
- ast.Inspect(root, func(n ast.Node) bool {
- if n != nil {
- if !f(n, stack) {
- // Do not push, as there will be no corresponding pop.
- return false
- }
- stack = append(stack, n) // push
- } else {
- stack = stack[:len(stack)-1] // pop
- }
- return true
- })
- if len(stack) != before {
- panic("push/pop mismatch")
- }
-}
-
// NodeContains reports whether the Pos/End range of node n encloses
// the given range.
//
@@ -73,14 +38,6 @@ func NodeContainsPos(n ast.Node, pos token.Pos) bool {
return NodeRange(n).ContainsPos(pos)
}
-// 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.
@@ -178,6 +135,9 @@ func (r Range) IsValid() bool { return r.Start.IsValid() && r.Start <= r.EndPos
//
// Select returns the enclosing BlockStmt, the f() CallExpr, and the g() CallExpr.
//
+// If the selection does not wholly enclose any nodes, Select returns an error
+// and invalid start/end nodes, but it may return a valid enclosing node.
+//
// Callers that require exactly one syntax tree (e.g. just f() or just
// g()) should check that the returned start and end nodes are
// identical.
@@ -187,6 +147,10 @@ func (r Range) IsValid() bool { return r.Start.IsValid() && r.Start <= r.EndPos
// extraneous whitespace and comments. Use it in new code instead of
// PathEnclosingInterval. When the exact extent of a node is known,
// use [Cursor.FindByPos] instead.
+//
+// TODO(hxjiang): Consider refactoring the function signature. It is currently
+// confusing that an error is returned even when a valid enclosing node is
+// successfully found. Consider grouping all cursors into one struct.
func Select(curFile inspector.Cursor, start, end token.Pos) (_enclosing, _start, _end inspector.Cursor, _ error) {
curEnclosing, ok := curFile.FindByPos(start, end)
if !ok {
@@ -201,33 +165,92 @@ func Select(curFile inspector.Cursor, start, end token.Pos) (_enclosing, _start,
for cur := range curEnclosing.Preorder() {
if rng.Contains(NodeRange(cur.Node())) {
// The start node has the least Pos.
- if !CursorValid(curStart) {
+ if !curStart.Valid() {
curStart = cur
}
// The end node has the greatest End.
// End positions do not change monotonically,
// so we must compute the max.
- if !CursorValid(curEnd) ||
+ if !curEnd.Valid() ||
cur.Node().End() > curEnd.Node().End() {
curEnd = cur
}
}
}
- if !CursorValid(curStart) {
- return noCursor, noCursor, noCursor, fmt.Errorf("no syntax selected")
+ if !curStart.Valid() {
+ // The selection is valid (inside curEnclosing) but contains no
+ // complete nodes. This happens for point selections (start == end),
+ // or selections covering only only spaces, comments, and punctuation
+ // tokens.
+ // Return the enclosing node so the caller can still use the context.
+ return curEnclosing, noCursor, noCursor, fmt.Errorf("invalid selection")
}
return curEnclosing, curStart, curEnd, nil
}
-// CursorValid reports whether the cursor is valid.
-//
-// A valid cursor may yet be the virtual root node,
-// cur.Inspector.Root(), which has no [Cursor.Node].
+var noCursor inspector.Cursor
+
+// MaybeParenthesize returns new, possibly wrapped in parens if needed
+// to preserve operator precedence when it replaces old, whose parent
+// is parentNode.
//
-// TODO(adonovan): move to cursorutil package, and move that package into x/tools.
-// Ultimately, make this a method of Cursor. Needs a proposal.
-func CursorValid(cur inspector.Cursor) bool {
- return cur.Inspector() != nil
+// (This would be more naturally written in terms of Cursor, but one of
+// the callers--the inliner--does not have cursors handy.)
+func MaybeParenthesize(parentNode ast.Node, old, new ast.Expr) ast.Expr {
+ if needsParens(parentNode, old, new) {
+ new = &ast.ParenExpr{X: new}
+ }
+ return new
}
-var noCursor inspector.Cursor
+func needsParens(parentNode ast.Node, old, new ast.Expr) bool {
+ // An expression beneath a non-expression
+ // has no precedence ambiguity.
+ parent, ok := parentNode.(ast.Expr)
+ if !ok {
+ return false
+ }
+
+ precedence := func(n ast.Node) int {
+ switch n := n.(type) {
+ case *ast.UnaryExpr, *ast.StarExpr:
+ return token.UnaryPrec
+ case *ast.BinaryExpr:
+ return n.Op.Precedence()
+ }
+ return -1
+ }
+
+ // Parens are not required if the new node
+ // is not unary or binary.
+ newprec := precedence(new)
+ if newprec < 0 {
+ return false
+ }
+
+ // Parens are required if parent and child are both
+ // unary or binary and the parent has higher precedence.
+ if precedence(parent) > newprec {
+ return true
+ }
+
+ // Was the old node the operand of a postfix operator?
+ // f().sel
+ // f()[i:j]
+ // f()[i]
+ // f().(T)
+ // f()(x)
+ switch parent := parent.(type) {
+ case *ast.SelectorExpr:
+ return parent.X == old
+ case *ast.IndexExpr:
+ return parent.X == old
+ case *ast.SliceExpr:
+ return parent.X == old
+ case *ast.TypeAssertExpr:
+ return parent.X == old
+ case *ast.CallExpr:
+ return parent.Fun == old
+ }
+ return false
+}
diff --git a/vendor/golang.org/x/tools/internal/cfginternal/cfginternal.go b/vendor/golang.org/x/tools/internal/cfginternal/cfginternal.go
deleted file mode 100644
index a9b6236f..00000000
--- a/vendor/golang.org/x/tools/internal/cfginternal/cfginternal.go
+++ /dev/null
@@ -1,16 +0,0 @@
-// 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 cfginternal exposes internals of go/cfg.
-// It cannot actually depend on symbols from go/cfg.
-package cfginternal
-
-// IsNoReturn exposes (*cfg.CFG).noReturn to the ctrlflow analyzer.
-// TODO(adonovan): add CFG.NoReturn to the public API.
-//
-// You must link [golang.org/x/tools/go/cfg] into your application for
-// this function to be non-nil.
-var IsNoReturn = func(cfg any) bool {
- panic("golang.org/x/tools/go/cfg not linked into application")
-}
diff --git a/vendor/golang.org/x/tools/internal/event/core/event.go b/vendor/golang.org/x/tools/internal/event/core/event.go
index ade5d1e7..42c21881 100644
--- a/vendor/golang.org/x/tools/internal/event/core/event.go
+++ b/vendor/golang.org/x/tools/internal/event/core/event.go
@@ -7,6 +7,7 @@ package core
import (
"fmt"
+ "iter"
"time"
"golang.org/x/tools/internal/event/label"
@@ -34,10 +35,8 @@ func (ev Event) Format(f fmt.State, r rune) {
if !ev.at.IsZero() {
fmt.Fprint(f, ev.at.Format("2006/01/02 15:04:05 "))
}
- for index := 0; ev.Valid(index); index++ {
- if l := ev.Label(index); l.Valid() {
- fmt.Fprintf(f, "\n\t%v", l)
- }
+ for l := range ev.Labels() {
+ fmt.Fprintf(f, "\n\t%v", l)
}
}
@@ -52,6 +51,22 @@ func (ev Event) Label(index int) label.Label {
return ev.dynamic[index-len(ev.static)]
}
+// Labels returns an iterator over the event's valid labels.
+func (ev Event) Labels() iter.Seq[label.Label] {
+ return func(yield func(label.Label) bool) {
+ for _, l := range ev.static {
+ if l.Valid() && !yield(l) {
+ return
+ }
+ }
+ for _, l := range ev.dynamic {
+ if l.Valid() && !yield(l) {
+ return
+ }
+ }
+ }
+}
+
func (ev Event) Find(key label.Key) label.Label {
for _, l := range ev.static {
if l.Key() == key {
diff --git a/vendor/golang.org/x/tools/internal/event/keys/keys.go b/vendor/golang.org/x/tools/internal/event/keys/keys.go
index 4cfa51b6..ac78bc3b 100644
--- a/vendor/golang.org/x/tools/internal/event/keys/keys.go
+++ b/vendor/golang.org/x/tools/internal/event/keys/keys.go
@@ -6,14 +6,13 @@ package keys
import (
"fmt"
- "io"
"math"
"strconv"
"golang.org/x/tools/internal/event/label"
)
-// Value represents a key for untyped values.
+// Value is a [label.Key] for untyped values.
type Value struct {
name string
description string
@@ -27,11 +26,11 @@ func New(name, description string) *Value {
func (k *Value) Name() string { return k.name }
func (k *Value) Description() string { return k.description }
-func (k *Value) Format(w io.Writer, buf []byte, l label.Label) {
- fmt.Fprint(w, k.From(l))
+func (k *Value) Append(buf []byte, l label.Label) []byte {
+ return fmt.Append(buf, k.From(l))
}
-// Get can be used to get a label for the key from a label.Map.
+// Get returns the label for the key of a label.Map.
func (k *Value) Get(lm label.Map) any {
if t := lm.Find(k); t.Valid() {
return k.From(t)
@@ -39,7 +38,7 @@ func (k *Value) Get(lm label.Map) any {
return nil
}
-// From can be used to get a value from a Label.
+// From returns the value of a Label.
func (k *Value) From(t label.Label) any { return t.UnpackValue() }
// Of creates a new Label with this key and the supplied value.
@@ -54,7 +53,7 @@ type Tag struct {
description string
}
-// NewTag creates a new Key for tagging labels.
+// NewTag creates a new [label.Key] for tagging labels.
func NewTag(name, description string) *Tag {
return &Tag{name: name, description: description}
}
@@ -62,18 +61,18 @@ func NewTag(name, description string) *Tag {
func (k *Tag) Name() string { return k.name }
func (k *Tag) Description() string { return k.description }
-func (k *Tag) Format(w io.Writer, buf []byte, l label.Label) {}
+func (k *Tag) Append(buf []byte, l label.Label) []byte { return buf }
// New creates a new Label with this key.
func (k *Tag) New() label.Label { return label.OfValue(k, nil) }
-// Int represents a key
+// Int is a [label.Key] for signed integers.
type Int struct {
name string
description string
}
-// NewInt creates a new Key for int values.
+// NewInt returns a new [label.Key] for int64 values.
func NewInt(name, description string) *Int {
return &Int{name: name, description: description}
}
@@ -81,381 +80,92 @@ func NewInt(name, description string) *Int {
func (k *Int) Name() string { return k.name }
func (k *Int) Description() string { return k.description }
-func (k *Int) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
+func (k *Int) Append(buf []byte, l label.Label) []byte {
+ return strconv.AppendInt(buf, k.From(l), 10)
}
// Of creates a new Label with this key and the supplied value.
-func (k *Int) Of(v int) label.Label { return label.Of64(k, uint64(v)) }
+func (k *Int) Of(v int) label.Label { return k.Of64(int64(v)) }
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int) Get(lm label.Map) int {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int) From(t label.Label) int { return int(t.Unpack64()) }
-
-// Int8 represents a key
-type Int8 struct {
- name string
- description string
-}
-
-// NewInt8 creates a new Key for int8 values.
-func NewInt8(name, description string) *Int8 {
- return &Int8{name: name, description: description}
-}
-
-func (k *Int8) Name() string { return k.name }
-func (k *Int8) Description() string { return k.description }
-
-func (k *Int8) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int8) Of(v int8) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int8) Get(lm label.Map) int8 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int8) From(t label.Label) int8 { return int8(t.Unpack64()) }
-
-// Int16 represents a key
-type Int16 struct {
- name string
- description string
-}
-
-// NewInt16 creates a new Key for int16 values.
-func NewInt16(name, description string) *Int16 {
- return &Int16{name: name, description: description}
-}
-
-func (k *Int16) Name() string { return k.name }
-func (k *Int16) Description() string { return k.description }
-
-func (k *Int16) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int16) Of(v int16) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int16) Get(lm label.Map) int16 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int16) From(t label.Label) int16 { return int16(t.Unpack64()) }
-
-// Int32 represents a key
-type Int32 struct {
- name string
- description string
-}
+// Of64 creates a new Label with this key and the supplied value.
+func (k *Int) Of64(v int64) label.Label { return label.Of64(k, uint64(v)) }
-// NewInt32 creates a new Key for int32 values.
-func NewInt32(name, description string) *Int32 {
- return &Int32{name: name, description: description}
-}
-
-func (k *Int32) Name() string { return k.name }
-func (k *Int32) Description() string { return k.description }
-
-func (k *Int32) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int32) Of(v int32) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int32) Get(lm label.Map) int32 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Int32) From(t label.Label) int32 { return int32(t.Unpack64()) }
-
-// Int64 represents a key
-type Int64 struct {
- name string
- description string
-}
-
-// NewInt64 creates a new Key for int64 values.
-func NewInt64(name, description string) *Int64 {
- return &Int64{name: name, description: description}
-}
-
-func (k *Int64) Name() string { return k.name }
-func (k *Int64) Description() string { return k.description }
-
-func (k *Int64) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendInt(buf, k.From(l), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Int64) Of(v int64) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Int64) Get(lm label.Map) int64 {
+// Get returns the label for the key of a label.Map.
+func (k *Int) Get(lm label.Map) int64 {
if t := lm.Find(k); t.Valid() {
return k.From(t)
}
return 0
}
-// From can be used to get a value from a Label.
-func (k *Int64) From(t label.Label) int64 { return int64(t.Unpack64()) }
+// From returns the value of a Label.
+func (k *Int) From(t label.Label) int64 { return int64(t.Unpack64()) }
-// UInt represents a key
-type UInt struct {
+// Uint is a [label.Key] for unsigned integers.
+type Uint struct {
name string
description string
}
-// NewUInt creates a new Key for uint values.
-func NewUInt(name, description string) *UInt {
- return &UInt{name: name, description: description}
+// NewUint creates a new [label.Key] for unsigned values.
+func NewUint(name, description string) *Uint {
+ return &Uint{name: name, description: description}
}
-func (k *UInt) Name() string { return k.name }
-func (k *UInt) Description() string { return k.description }
+func (k *Uint) Name() string { return k.name }
+func (k *Uint) Description() string { return k.description }
-func (k *UInt) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
+func (k *Uint) Append(buf []byte, l label.Label) []byte {
+ return strconv.AppendUint(buf, k.From(l), 10)
}
// Of creates a new Label with this key and the supplied value.
-func (k *UInt) Of(v uint) label.Label { return label.Of64(k, uint64(v)) }
+func (k *Uint) Of(v uint64) label.Label { return label.Of64(k, v) }
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt) Get(lm label.Map) uint {
+// Get returns the label for the key of a label.Map.
+func (k *Uint) Get(lm label.Map) uint64 {
if t := lm.Find(k); t.Valid() {
return k.From(t)
}
return 0
}
-// From can be used to get a value from a Label.
-func (k *UInt) From(t label.Label) uint { return uint(t.Unpack64()) }
+// From returns the value of a Label.
+func (k *Uint) From(t label.Label) uint64 { return t.Unpack64() }
-// UInt8 represents a key
-type UInt8 struct {
+// Float is a label.Key for floating-point values.
+type Float struct {
name string
description string
}
-// NewUInt8 creates a new Key for uint8 values.
-func NewUInt8(name, description string) *UInt8 {
- return &UInt8{name: name, description: description}
+// NewFloat creates a new [label.Key] for floating-point values.
+func NewFloat(name, description string) *Float {
+ return &Float{name: name, description: description}
}
-func (k *UInt8) Name() string { return k.name }
-func (k *UInt8) Description() string { return k.description }
+func (k *Float) Name() string { return k.name }
+func (k *Float) Description() string { return k.description }
-func (k *UInt8) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
+func (k *Float) Append(buf []byte, l label.Label) []byte {
+ return strconv.AppendFloat(buf, k.From(l), 'E', -1, 64)
}
// Of creates a new Label with this key and the supplied value.
-func (k *UInt8) Of(v uint8) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt8) Get(lm label.Map) uint8 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt8) From(t label.Label) uint8 { return uint8(t.Unpack64()) }
-
-// UInt16 represents a key
-type UInt16 struct {
- name string
- description string
-}
-
-// NewUInt16 creates a new Key for uint16 values.
-func NewUInt16(name, description string) *UInt16 {
- return &UInt16{name: name, description: description}
-}
-
-func (k *UInt16) Name() string { return k.name }
-func (k *UInt16) Description() string { return k.description }
-
-func (k *UInt16) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt16) Of(v uint16) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt16) Get(lm label.Map) uint16 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt16) From(t label.Label) uint16 { return uint16(t.Unpack64()) }
-
-// UInt32 represents a key
-type UInt32 struct {
- name string
- description string
-}
-
-// NewUInt32 creates a new Key for uint32 values.
-func NewUInt32(name, description string) *UInt32 {
- return &UInt32{name: name, description: description}
-}
-
-func (k *UInt32) Name() string { return k.name }
-func (k *UInt32) Description() string { return k.description }
-
-func (k *UInt32) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt32) Of(v uint32) label.Label { return label.Of64(k, uint64(v)) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt32) Get(lm label.Map) uint32 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt32) From(t label.Label) uint32 { return uint32(t.Unpack64()) }
-
-// UInt64 represents a key
-type UInt64 struct {
- name string
- description string
-}
-
-// NewUInt64 creates a new Key for uint64 values.
-func NewUInt64(name, description string) *UInt64 {
- return &UInt64{name: name, description: description}
-}
-
-func (k *UInt64) Name() string { return k.name }
-func (k *UInt64) Description() string { return k.description }
-
-func (k *UInt64) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendUint(buf, k.From(l), 10))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *UInt64) Of(v uint64) label.Label { return label.Of64(k, v) }
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *UInt64) Get(lm label.Map) uint64 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *UInt64) From(t label.Label) uint64 { return t.Unpack64() }
-
-// Float32 represents a key
-type Float32 struct {
- name string
- description string
-}
-
-// NewFloat32 creates a new Key for float32 values.
-func NewFloat32(name, description string) *Float32 {
- return &Float32{name: name, description: description}
-}
-
-func (k *Float32) Name() string { return k.name }
-func (k *Float32) Description() string { return k.description }
-
-func (k *Float32) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendFloat(buf, float64(k.From(l)), 'E', -1, 32))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Float32) Of(v float32) label.Label {
- return label.Of64(k, uint64(math.Float32bits(v)))
-}
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Float32) Get(lm label.Map) float32 {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return 0
-}
-
-// From can be used to get a value from a Label.
-func (k *Float32) From(t label.Label) float32 {
- return math.Float32frombits(uint32(t.Unpack64()))
-}
-
-// Float64 represents a key
-type Float64 struct {
- name string
- description string
-}
-
-// NewFloat64 creates a new Key for int64 values.
-func NewFloat64(name, description string) *Float64 {
- return &Float64{name: name, description: description}
-}
-
-func (k *Float64) Name() string { return k.name }
-func (k *Float64) Description() string { return k.description }
-
-func (k *Float64) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendFloat(buf, k.From(l), 'E', -1, 64))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Float64) Of(v float64) label.Label {
+func (k *Float) Of(v float64) label.Label {
return label.Of64(k, math.Float64bits(v))
}
-// Get can be used to get a label for the key from a label.Map.
-func (k *Float64) Get(lm label.Map) float64 {
+// Get returns the label for the key of a label.Map.
+func (k *Float) Get(lm label.Map) float64 {
if t := lm.Find(k); t.Valid() {
return k.From(t)
}
return 0
}
-// From can be used to get a value from a Label.
-func (k *Float64) From(t label.Label) float64 {
+// From returns the value of a Label.
+func (k *Float) From(t label.Label) float64 {
return math.Float64frombits(t.Unpack64())
}
@@ -473,14 +183,14 @@ func NewString(name, description string) *String {
func (k *String) Name() string { return k.name }
func (k *String) Description() string { return k.description }
-func (k *String) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendQuote(buf, k.From(l)))
+func (k *String) Append(buf []byte, l label.Label) []byte {
+ return strconv.AppendQuote(buf, k.From(l))
}
// Of creates a new Label with this key and the supplied value.
func (k *String) Of(v string) label.Label { return label.OfString(k, v) }
-// Get can be used to get a label for the key from a label.Map.
+// Get returns the label for the key of a label.Map.
func (k *String) Get(lm label.Map) string {
if t := lm.Find(k); t.Valid() {
return k.From(t)
@@ -488,53 +198,16 @@ func (k *String) Get(lm label.Map) string {
return ""
}
-// From can be used to get a value from a Label.
+// From returns the value of a Label.
func (k *String) From(t label.Label) string { return t.UnpackString() }
-// Boolean represents a key
-type Boolean struct {
- name string
- description string
-}
-
-// NewBoolean creates a new Key for bool values.
-func NewBoolean(name, description string) *Boolean {
- return &Boolean{name: name, description: description}
-}
-
-func (k *Boolean) Name() string { return k.name }
-func (k *Boolean) Description() string { return k.description }
-
-func (k *Boolean) Format(w io.Writer, buf []byte, l label.Label) {
- w.Write(strconv.AppendBool(buf, k.From(l)))
-}
-
-// Of creates a new Label with this key and the supplied value.
-func (k *Boolean) Of(v bool) label.Label {
- if v {
- return label.Of64(k, 1)
- }
- return label.Of64(k, 0)
-}
-
-// Get can be used to get a label for the key from a label.Map.
-func (k *Boolean) Get(lm label.Map) bool {
- if t := lm.Find(k); t.Valid() {
- return k.From(t)
- }
- return false
-}
-
-// From can be used to get a value from a Label.
-func (k *Boolean) From(t label.Label) bool { return t.Unpack64() > 0 }
-
// Error represents a key
type Error struct {
name string
description string
}
-// NewError creates a new Key for int64 values.
+// NewError returns a new [label.Key] for error values.
func NewError(name, description string) *Error {
return &Error{name: name, description: description}
}
@@ -542,14 +215,14 @@ func NewError(name, description string) *Error {
func (k *Error) Name() string { return k.name }
func (k *Error) Description() string { return k.description }
-func (k *Error) Format(w io.Writer, buf []byte, l label.Label) {
- io.WriteString(w, k.From(l).Error())
+func (k *Error) Append(buf []byte, l label.Label) []byte {
+ return append(buf, k.From(l).Error()...)
}
-// Of creates a new Label with this key and the supplied value.
+// Of returns a new Label with this key and the supplied value.
func (k *Error) Of(v error) label.Label { return label.OfValue(k, v) }
-// Get can be used to get a label for the key from a label.Map.
+// Get returns the label for the key of a label.Map.
func (k *Error) Get(lm label.Map) error {
if t := lm.Find(k); t.Valid() {
return k.From(t)
@@ -557,7 +230,7 @@ func (k *Error) Get(lm label.Map) error {
return nil
}
-// From can be used to get a value from a Label.
+// From returns the value of a Label.
func (k *Error) From(t label.Label) error {
err, _ := t.UnpackValue().(error)
return err
diff --git a/vendor/golang.org/x/tools/internal/event/label/label.go b/vendor/golang.org/x/tools/internal/event/label/label.go
index c37584af..e84226f8 100644
--- a/vendor/golang.org/x/tools/internal/event/label/label.go
+++ b/vendor/golang.org/x/tools/internal/event/label/label.go
@@ -19,12 +19,8 @@ type Key interface {
Name() string
// Description returns a string that can be used to describe the value.
Description() string
-
- // Format is used in formatting to append the value of the label to the
- // supplied buffer.
- // The formatter may use the supplied buf as a scratch area to avoid
- // allocations.
- Format(w io.Writer, buf []byte, l Label)
+ // Append appends the formatted value of the label to the supplied buffer.
+ Append(buf []byte, l Label) []byte
}
// Label holds a key and value pair.
@@ -131,8 +127,7 @@ func (t Label) Format(f fmt.State, r rune) {
}
io.WriteString(f, t.Key().Name())
io.WriteString(f, "=")
- var buf [128]byte
- t.Key().Format(f, buf[:0], t)
+ f.Write(t.Key().Append(nil, t)) // ignore error
}
func (l *list) Valid(index int) bool {
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
index 2bef2b05..4c9450f4 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
@@ -242,7 +242,6 @@ import (
"strings"
"golang.org/x/tools/go/types/objectpath"
- "golang.org/x/tools/internal/aliases"
)
// IExportShallow encodes "shallow" export data for the specified package.
@@ -767,11 +766,11 @@ func (p *iexporter) doDecl(obj types.Object) {
}
if obj.IsAlias() {
- alias, materialized := t.(*types.Alias) // may fail when aliases are not enabled
+ alias, materialized := t.(*types.Alias) // perhaps false for certain built-ins?
var tparams *types.TypeParamList
if materialized {
- tparams = aliases.TypeParams(alias)
+ tparams = alias.TypeParams()
}
if tparams.Len() == 0 {
w.tag(aliasTag)
@@ -785,7 +784,7 @@ func (p *iexporter) doDecl(obj types.Object) {
if materialized {
// Preserve materialized aliases,
// even of non-exported types.
- t = aliases.Rhs(alias)
+ t = alias.Rhs()
}
w.typ(t, obj.Pkg())
break
@@ -1011,11 +1010,11 @@ func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
}
switch t := t.(type) {
case *types.Alias:
- if targs := aliases.TypeArgs(t); targs.Len() > 0 {
+ if targs := t.TypeArgs(); targs.Len() > 0 {
w.startType(instanceType)
w.pos(t.Obj().Pos())
w.typeList(targs, pkg)
- w.typ(aliases.Origin(t), pkg)
+ w.typ(t.Origin(), pkg)
return
}
w.startType(aliasType)
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
index 4d6d5009..1ee4e935 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
@@ -210,7 +210,6 @@ func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte
p := iimporter{
version: int(version),
ipath: path,
- aliases: aliases.Enabled(),
shallow: shallow,
reportf: reportf,
@@ -370,7 +369,6 @@ type iimporter struct {
version int
ipath string
- aliases bool
shallow bool
reportf ReportFunc // if non-nil, used to report bugs
@@ -576,7 +574,7 @@ func (r *importReader) obj(pkg *types.Package, name string) {
tparams = r.tparamList()
}
typ := r.typ()
- obj := aliases.NewAlias(r.p.aliases, pos, pkg, name, typ, tparams)
+ obj := aliases.New(pos, pkg, name, typ, tparams)
markBlack(obj) // workaround for golang/go#69912
r.declare(obj)
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
similarity index 88%
rename from vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
rename to vendor/golang.org/x/tools/internal/gcimporter/ureader.go
index 37b4a39e..3db62b89 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
@@ -26,7 +26,6 @@ type pkgReader struct {
ctxt *types.Context
imports map[string]*types.Package // previously imported packages, indexed by path
- aliases bool // create types.Alias nodes
// lazily initialized arrays corresponding to the unified IR
// PosBase, Pkg, and Type sections, respectively.
@@ -36,6 +35,10 @@ type pkgReader struct {
// laterFns holds functions that need to be invoked at the end of
// import reading.
+ //
+ // TODO(mdempsky): Is it safe to have a single "later" slice or do
+ // we need to have multiple passes? See comments on CL 386002 and
+ // go.dev/issue/52104.
laterFns []func()
// laterFors is used in case of 'type A B' to ensure that B is processed before A.
laterFors map[types.Type]int
@@ -98,7 +101,6 @@ func readUnifiedPackage(fset *token.FileSet, ctxt *types.Context, imports map[st
ctxt: ctxt,
imports: imports,
- aliases: aliases.Enabled(),
posBases: make([]string, input.NumElems(pkgbits.RelocPosBase)),
pkgs: make([]*types.Package, input.NumElems(pkgbits.RelocPkg)),
@@ -160,12 +162,11 @@ type reader struct {
// A readerDict holds the state for type parameters that parameterize
// the current unified IR element.
type readerDict struct {
- // bounds is a slice of typeInfos corresponding to the underlying
- // bounds of the element's type parameters.
- bounds []typeInfo
+ rtbounds []typeInfo // contains constraint types for each parameter in rtparams
+ rtparams []*types.TypeParam // contains receiver type parameters for an element
- // tparams is a slice of the constructed TypeParams for the element.
- tparams []*types.TypeParam
+ tbounds []typeInfo // contains constraint types for each parameter in tparams
+ tparams []*types.TypeParam // contains type parameters for an element
// derived is a slice of types derived from tparams, which may be
// instantiated while reading the current element.
@@ -355,7 +356,11 @@ func (r *reader) doTyp() (res types.Type) {
return name.Type()
case pkgbits.TypeTypeParam:
- return r.dict.tparams[r.Len()]
+ n := r.Len()
+ if n < len(r.dict.rtbounds) {
+ return r.dict.rtparams[n]
+ }
+ return r.dict.tparams[n-len(r.dict.rtbounds)]
case pkgbits.TypeArray:
len := int64(r.Uint64())
@@ -536,10 +541,10 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
pos := r.pos()
var tparams []*types.TypeParam
if r.Version().Has(pkgbits.AliasTypeParamNames) {
- tparams = r.typeParamNames()
+ tparams = r.typeParamNames(false)
}
typ := r.typ()
- declare(aliases.NewAlias(r.p.aliases, pos, objPkg, objName, typ, tparams))
+ declare(aliases.New(pos, objPkg, objName, typ, tparams))
case pkgbits.ObjConst:
pos := r.pos()
@@ -549,8 +554,15 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
case pkgbits.ObjFunc:
pos := r.pos()
- tparams := r.typeParamNames()
- sig := r.signature(nil, nil, tparams)
+ var rtparams []*types.TypeParam
+ var recv *types.Var
+ if r.Version().Has(pkgbits.GenericMethods) && r.Bool() {
+ r.selector()
+ rtparams = r.typeParamNames(true)
+ recv = r.param()
+ }
+ tparams := r.typeParamNames(false)
+ sig := r.signature(recv, rtparams, tparams)
declare(types.NewFunc(pos, objPkg, objName, sig))
case pkgbits.ObjType:
@@ -560,7 +572,7 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
named := types.NewNamed(obj, nil, nil)
declare(obj)
- named.SetTypeParams(r.typeParamNames())
+ named.SetTypeParams(r.typeParamNames(false))
setUnderlying := func(underlying types.Type) {
// If the underlying type is an interface, we need to
@@ -640,9 +652,20 @@ func (pr *pkgReader) objDictIdx(idx pkgbits.Index) *readerDict {
errorf("unexpected object with %v implicit type parameter(s)", implicits)
}
- dict.bounds = make([]typeInfo, r.Len())
- for i := range dict.bounds {
- dict.bounds[i] = r.typInfo()
+ nreceivers := 0
+ if r.Version().Has(pkgbits.GenericMethods) && r.Bool() {
+ nreceivers = r.Len()
+ }
+ nexplicits := r.Len()
+
+ dict.rtbounds = make([]typeInfo, nreceivers)
+ for i := range dict.rtbounds {
+ dict.rtbounds[i] = r.typInfo()
+ }
+
+ dict.tbounds = make([]typeInfo, nexplicits)
+ for i := range dict.tbounds {
+ dict.tbounds[i] = r.typInfo()
}
dict.derived = make([]derivedInfo, r.Len())
@@ -661,15 +684,24 @@ func (pr *pkgReader) objDictIdx(idx pkgbits.Index) *readerDict {
return &dict
}
-func (r *reader) typeParamNames() []*types.TypeParam {
+func (r *reader) typeParamNames(isGenMeth bool) []*types.TypeParam {
r.Sync(pkgbits.SyncTypeParamNames)
- // Note: This code assumes it only processes objects without
- // implement type parameters. This is currently fine, because
- // reader is only used to read in exported declarations, which are
- // always package scoped.
+ // Note: This code assumes there are no implicit type parameters.
+ // This is fine since it only reads exported declarations, which
+ // never have implicits.
- if len(r.dict.bounds) == 0 {
+ var in []typeInfo
+ var out *[]*types.TypeParam
+ if isGenMeth {
+ in = r.dict.rtbounds
+ out = &r.dict.rtparams
+ } else {
+ in = r.dict.tbounds
+ out = &r.dict.tparams
+ }
+
+ if len(in) == 0 {
return nil
}
@@ -678,40 +710,34 @@ func (r *reader) typeParamNames() []*types.TypeParam {
// create all the TypeNames and TypeParams, then we construct and
// set the bound type.
- r.dict.tparams = make([]*types.TypeParam, len(r.dict.bounds))
- for i := range r.dict.bounds {
+ // We have to save tparams outside of the closure, because typeParamNames
+ // can be called multiple times with the same dictionary instance.
+ tparams := make([]*types.TypeParam, len(in))
+ *out = tparams
+
+ for i := range in {
pos := r.pos()
pkg, name := r.localIdent()
tname := types.NewTypeName(pos, pkg, name, nil)
- r.dict.tparams[i] = types.NewTypeParam(tname, nil)
+ tparams[i] = types.NewTypeParam(tname, nil)
}
- typs := make([]types.Type, len(r.dict.bounds))
- for i, bound := range r.dict.bounds {
- typs[i] = r.p.typIdx(bound, r.dict)
+ // The reader dictionary will continue mutating before we have time
+ // to call delayed functions; make a local copy of the constraints.
+ types := make([]types.Type, len(in))
+ for i, info := range in {
+ types[i] = r.p.typIdx(info, r.dict)
}
- // TODO(mdempsky): This is subtle, elaborate further.
- //
- // We have to save tparams outside of the closure, because
- // typeParamNames() can be called multiple times with the same
- // dictionary instance.
- //
- // Also, this needs to happen later to make sure SetUnderlying has
- // been called.
- //
- // TODO(mdempsky): Is it safe to have a single "later" slice or do
- // we need to have multiple passes? See comments on CL 386002 and
- // go.dev/issue/52104.
- tparams := r.dict.tparams
+ // This needs to happen later to make sure SetUnderlying has been called.
r.p.later(func() {
- for i, typ := range typs {
+ for i, typ := range types {
tparams[i].SetConstraint(typ)
}
})
- return r.dict.tparams
+ return tparams
}
func (r *reader) method() *types.Func {
@@ -719,7 +745,7 @@ func (r *reader) method() *types.Func {
pos := r.pos()
pkg, name := r.selector()
- rparams := r.typeParamNames()
+ rparams := r.typeParamNames(false)
sig := r.signature(r.param(), rparams, nil)
_ = r.pos() // TODO(mdempsky): Remove; this is a hacker for linker.go.
diff --git a/vendor/golang.org/x/tools/internal/gocommand/version.go b/vendor/golang.org/x/tools/internal/gocommand/version.go
index 446c5846..cce290c4 100644
--- a/vendor/golang.org/x/tools/internal/gocommand/version.go
+++ b/vendor/golang.org/x/tools/internal/gocommand/version.go
@@ -26,6 +26,9 @@ func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error) {
inv.BuildFlags = nil // This is not a build command.
inv.ModFlag = ""
inv.ModFile = ""
+ // Set GO111MODULE=off so that we are immune to errors in go.{work,mod}.
+ // Unfortunately, this breaks the Go 1.21+ toolchain directive and
+ // may affect the set of ReleaseTags; see #68495.
inv.Env = append(inv.Env[:len(inv.Env):len(inv.Env)], "GO111MODULE=off")
stdoutBytes, err := r.Run(ctx, inv)
diff --git a/vendor/golang.org/x/tools/internal/imports/source_modindex.go b/vendor/golang.org/x/tools/internal/imports/source_modindex.go
deleted file mode 100644
index ca745d4a..00000000
--- a/vendor/golang.org/x/tools/internal/imports/source_modindex.go
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright 2024 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 imports
-
-import (
- "context"
- "sync"
- "time"
-
- "golang.org/x/tools/internal/modindex"
-)
-
-// This code is here rather than in the modindex package
-// to avoid import loops
-
-// TODO(adonovan): this code is only used by a test in this package.
-// Can we delete it? Or is there a plan to call NewIndexSource from
-// cmd/goimports?
-
-// implements Source using modindex, so only for module cache.
-//
-// this is perhaps over-engineered. A new Index is read at first use.
-// And then Update is called after every 15 minutes, and a new Index
-// is read if the index changed. It is not clear the Mutex is needed.
-type IndexSource struct {
- modcachedir string
- mu sync.Mutex
- index *modindex.Index // (access via getIndex)
- expires time.Time
-}
-
-// create a new Source. Called from NewView in cache/session.go.
-func NewIndexSource(cachedir string) *IndexSource {
- return &IndexSource{modcachedir: cachedir}
-}
-
-func (s *IndexSource) LoadPackageNames(ctx context.Context, srcDir string, paths []ImportPath) (map[ImportPath]PackageName, error) {
- /// This is used by goimports to resolve the package names of imports of the
- // current package, which is irrelevant for the module cache.
- return nil, nil
-}
-
-func (s *IndexSource) ResolveReferences(ctx context.Context, filename string, missing References) ([]*Result, error) {
- index, err := s.getIndex()
- if err != nil {
- return nil, err
- }
- var cs []modindex.Candidate
- for pkg, nms := range missing {
- for nm := range nms {
- x := index.Lookup(pkg, nm, false)
- cs = append(cs, x...)
- }
- }
- found := make(map[string]*Result)
- for _, c := range cs {
- var x *Result
- if x = found[c.ImportPath]; x == nil {
- x = &Result{
- Import: &ImportInfo{
- ImportPath: c.ImportPath,
- Name: "",
- },
- Package: &PackageInfo{
- Name: c.PkgName,
- Exports: make(map[string]bool),
- },
- }
- found[c.ImportPath] = x
- }
- x.Package.Exports[c.Name] = true
- }
- var ans []*Result
- for _, x := range found {
- ans = append(ans, x)
- }
- return ans, nil
-}
-
-func (s *IndexSource) getIndex() (*modindex.Index, error) {
- s.mu.Lock()
- defer s.mu.Unlock()
-
- // (s.index = nil => s.expires is zero,
- // so the first condition is strictly redundant.
- // But it makes the postcondition very clear.)
- if s.index == nil || time.Now().After(s.expires) {
- index, err := modindex.Update(s.modcachedir)
- if err != nil {
- return nil, err
- }
- s.index = index
- s.expires = index.ValidAt.Add(15 * time.Minute) // (refresh period)
- }
- // Inv: s.index != nil
-
- return s.index, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/directories.go b/vendor/golang.org/x/tools/internal/modindex/directories.go
deleted file mode 100644
index 9a963744..00000000
--- a/vendor/golang.org/x/tools/internal/modindex/directories.go
+++ /dev/null
@@ -1,131 +0,0 @@
-// Copyright 2024 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 modindex
-
-import (
- "fmt"
- "log"
- "os"
- "path/filepath"
- "regexp"
- "strings"
- "sync"
- "time"
-
- "golang.org/x/mod/semver"
- "golang.org/x/tools/internal/gopathwalk"
-)
-
-type directory struct {
- path string // relative to GOMODCACHE
- importPath string
- version string // semantic version
-}
-
-// bestDirByImportPath returns the best directory for each import
-// path, where "best" means most recent semantic version. These import
-// paths are inferred from the GOMODCACHE-relative dir names in dirs.
-func bestDirByImportPath(dirs []string) (map[string]directory, error) {
- dirsByPath := make(map[string]directory)
- for _, dir := range dirs {
- importPath, version, err := dirToImportPathVersion(dir)
- if err != nil {
- return nil, err
- }
- new := directory{
- path: dir,
- importPath: importPath,
- version: version,
- }
- if old, ok := dirsByPath[importPath]; !ok || compareDirectory(new, old) < 0 {
- dirsByPath[importPath] = new
- }
- }
- return dirsByPath, nil
-}
-
-// compareDirectory defines an ordering of path@version directories,
-// by descending version, then by ascending path.
-func compareDirectory(x, y directory) int {
- if sign := -semver.Compare(x.version, y.version); sign != 0 {
- return sign // latest first
- }
- return strings.Compare(string(x.path), string(y.path))
-}
-
-// modCacheRegexp splits a relpathpath into module, module version, and package.
-var modCacheRegexp = regexp.MustCompile(`(.*)@([^/\\]*)(.*)`)
-
-// dirToImportPathVersion computes import path and semantic version
-// from a GOMODCACHE-relative directory name.
-func dirToImportPathVersion(dir string) (string, string, error) {
- m := modCacheRegexp.FindStringSubmatch(string(dir))
- // m[1] is the module path
- // m[2] is the version major.minor.patch(- 1 && flds[1][1] == 'D',
- }
- if px.Type == Func {
- n, err := strconv.Atoi(flds[2])
- if err != nil {
- continue // should never happen
- }
- px.Results = int16(n)
- if len(flds) >= 4 {
- sig := strings.Split(flds[3], " ")
- for i := range sig {
- // $ cannot otherwise occur. removing the spaces
- // almost works, but for chan struct{}, e.g.
- sig[i] = strings.Replace(sig[i], "$", " ", -1)
- }
- px.Sig = toFields(sig)
- }
- }
- ans = append(ans, px)
- }
- }
- return ans
-}
-
-func toFields(sig []string) []Field {
- ans := make([]Field, len(sig)/2)
- for i := range ans {
- ans[i] = Field{Arg: sig[2*i], Type: sig[2*i+1]}
- }
- return ans
-}
-
-// benchmarks show this is measurably better than strings.Split
-// split into first 4 fields separated by single space
-func fastSplit(x string) []string {
- ans := make([]string, 0, 4)
- nxt := 0
- start := 0
- for i := 0; i < len(x); i++ {
- if x[i] != ' ' {
- continue
- }
- ans = append(ans, x[start:i])
- nxt++
- start = i + 1
- if nxt >= 3 {
- break
- }
- }
- ans = append(ans, x[start:])
- return ans
-}
-
-func asLexType(c byte) LexType {
- switch c {
- case 'C':
- return Const
- case 'V':
- return Var
- case 'T':
- return Type
- case 'F':
- return Func
- }
- return -1
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/modindex.go b/vendor/golang.org/x/tools/internal/modindex/modindex.go
deleted file mode 100644
index 5fa285d9..00000000
--- a/vendor/golang.org/x/tools/internal/modindex/modindex.go
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright 2024 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 modindex contains code for building and searching an
-// [Index] of the Go module cache.
-package modindex
-
-// The directory containing the index, returned by
-// [IndexDir], contains a file index-name- that contains the name
-// of the current index. We believe writing that short file is atomic.
-// [Read] reads that file to get the file name of the index.
-// WriteIndex writes an index with a unique name and then
-// writes that name into a new version of index-name-.
-// ( stands for the CurrentVersion of the index format.)
-
-import (
- "maps"
- "os"
- "path/filepath"
- "slices"
- "strings"
- "time"
-
- "golang.org/x/mod/semver"
-)
-
-// Update updates the index for the specified Go
-// module cache directory, creating it as needed.
-// On success it returns the current index.
-func Update(gomodcache string) (*Index, error) {
- prev, err := Read(gomodcache)
- if err != nil {
- if !os.IsNotExist(err) {
- return nil, err
- }
- prev = nil
- }
- return update(gomodcache, prev)
-}
-
-// update builds, writes, and returns the current index.
-//
-// If old is nil, the new index is built from all of GOMODCACHE;
-// otherwise it is built from the old index plus cache updates
-// since the previous index's time.
-func update(gomodcache string, old *Index) (*Index, error) {
- gomodcache, err := filepath.Abs(gomodcache)
- if err != nil {
- return nil, err
- }
- new, changed, err := build(gomodcache, old)
- if err != nil {
- return nil, err
- }
- if old == nil || changed {
- if err := write(gomodcache, new); err != nil {
- return nil, err
- }
- }
- return new, nil
-}
-
-// build returns a new index for the specified Go module cache (an
-// absolute path).
-//
-// If an old index is provided, only directories more recent than it
-// that it are scanned; older directories are provided by the old
-// Index.
-//
-// The boolean result indicates whether new entries were found.
-func build(gomodcache string, old *Index) (*Index, bool, error) {
- // Set the time window.
- var start time.Time // = dawn of time
- if old != nil {
- start = old.ValidAt
- }
- now := time.Now()
- end := now.Add(24 * time.Hour) // safely in the future
-
- // Enumerate GOMODCACHE package directories.
- // Choose the best (latest) package for each import path.
- pkgDirs := findDirs(gomodcache, start, end)
- dirByPath, err := bestDirByImportPath(pkgDirs)
- if err != nil {
- return nil, false, err
- }
-
- // For each import path it might occur only in
- // dirByPath, only in old, or in both.
- // If both, use the semantically later one.
- var entries []Entry
- if old != nil {
- for _, entry := range old.Entries {
- dir, ok := dirByPath[entry.ImportPath]
- if !ok || semver.Compare(dir.version, entry.Version) <= 0 {
- // New dir is missing or not more recent; use old entry.
- entries = append(entries, entry)
- delete(dirByPath, entry.ImportPath)
- }
- }
- }
-
- // Extract symbol information for all the new directories.
- newEntries := extractSymbols(gomodcache, maps.Values(dirByPath))
- entries = append(entries, newEntries...)
- slices.SortFunc(entries, func(x, y Entry) int {
- if n := strings.Compare(x.PkgName, y.PkgName); n != 0 {
- return n
- }
- return strings.Compare(x.ImportPath, y.ImportPath)
- })
-
- return &Index{
- GOMODCACHE: gomodcache,
- ValidAt: now, // time before the directories were scanned
- Entries: entries,
- }, len(newEntries) > 0, nil
-}
diff --git a/vendor/golang.org/x/tools/internal/modindex/symbols.go b/vendor/golang.org/x/tools/internal/modindex/symbols.go
deleted file mode 100644
index 8e9702d8..00000000
--- a/vendor/golang.org/x/tools/internal/modindex/symbols.go
+++ /dev/null
@@ -1,244 +0,0 @@
-// Copyright 2024 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 modindex
-
-import (
- "fmt"
- "go/ast"
- "go/parser"
- "go/token"
- "go/types"
- "iter"
- "os"
- "path/filepath"
- "runtime"
- "slices"
- "strings"
- "sync"
-
- "golang.org/x/sync/errgroup"
-)
-
-// The name of a symbol contains information about the symbol:
-// T for types, TD if the type is deprecated
-// C for consts, CD if the const is deprecated
-// V for vars, VD if the var is deprecated
-// and for funcs: F ( )*
-// any spaces in are replaced by $s so that the fields
-// of the name are space separated. F is replaced by FD if the func
-// is deprecated.
-type symbol struct {
- pkg string // name of the symbols's package
- name string // declared name
- kind string // T, C, V, or F, followed by D if deprecated
- sig string // signature information, for F
-}
-
-// extractSymbols returns a (new, unordered) array of Entries, one for
-// each provided package directory, describing its exported symbols.
-func extractSymbols(cwd string, dirs iter.Seq[directory]) []Entry {
- var (
- mu sync.Mutex
- entries []Entry
- )
-
- var g errgroup.Group
- g.SetLimit(max(2, runtime.GOMAXPROCS(0)/2))
- for dir := range dirs {
- g.Go(func() error {
- thedir := filepath.Join(cwd, string(dir.path))
- mode := parser.SkipObjectResolution | parser.ParseComments
-
- // Parse all Go files in dir and extract symbols.
- dirents, err := os.ReadDir(thedir)
- if err != nil {
- return nil // log this someday?
- }
- var syms []symbol
- for _, dirent := range dirents {
- if !strings.HasSuffix(dirent.Name(), ".go") ||
- strings.HasSuffix(dirent.Name(), "_test.go") {
- continue
- }
- fname := filepath.Join(thedir, dirent.Name())
- tr, err := parser.ParseFile(token.NewFileSet(), fname, nil, mode)
- if err != nil {
- continue // ignore errors, someday log them?
- }
- syms = append(syms, getFileExports(tr)...)
- }
-
- // Create an entry for the package.
- pkg, names := processSyms(syms)
- if pkg != "" {
- mu.Lock()
- defer mu.Unlock()
- entries = append(entries, Entry{
- PkgName: pkg,
- Dir: dir.path,
- ImportPath: dir.importPath,
- Version: dir.version,
- Names: names,
- })
- }
-
- return nil
- })
- }
- g.Wait() // ignore error
-
- return entries
-}
-
-func getFileExports(f *ast.File) []symbol {
- pkg := f.Name.Name
- if pkg == "main" || pkg == "" {
- return nil
- }
- var ans []symbol
- // should we look for //go:build ignore?
- for _, decl := range f.Decls {
- switch decl := decl.(type) {
- case *ast.FuncDecl:
- if decl.Recv != nil {
- // ignore methods, as we are completing package selections
- continue
- }
- name := decl.Name.Name
- dtype := decl.Type
- // not looking at dtype.TypeParams. That is, treating
- // generic functions just like non-generic ones.
- sig := dtype.Params
- kind := "F"
- if isDeprecated(decl.Doc) {
- kind += "D"
- }
- result := []string{fmt.Sprintf("%d", dtype.Results.NumFields())}
- for _, x := range sig.List {
- // This code creates a string representing the type.
- // TODO(pjw): it may be fragile:
- // 1. x.Type could be nil, perhaps in ill-formed code
- // 2. ExprString might someday change incompatibly to
- // include struct tags, which can be arbitrary strings
- if x.Type == nil {
- // Can this happen without a parse error? (Files with parse
- // errors are ignored in getSymbols)
- continue // maybe report this someday
- }
- tp := types.ExprString(x.Type)
- if len(tp) == 0 {
- // Can this happen?
- continue // maybe report this someday
- }
- // This is only safe if ExprString never returns anything with a $
- // The only place a $ can occur seems to be in a struct tag, which
- // can be an arbitrary string literal, and ExprString does not presently
- // print struct tags. So for this to happen the type of a formal parameter
- // has to be a explicit struct, e.g. foo(x struct{a int "$"}) and ExprString
- // would have to show the struct tag. Even testing for this case seems
- // a waste of effort, but let's remember the possibility
- if strings.Contains(tp, "$") {
- continue
- }
- tp = strings.Replace(tp, " ", "$", -1)
- if len(x.Names) == 0 {
- result = append(result, "_")
- result = append(result, tp)
- } else {
- for _, y := range x.Names {
- result = append(result, y.Name)
- result = append(result, tp)
- }
- }
- }
- sigs := strings.Join(result, " ")
- if s := newsym(pkg, name, kind, sigs); s != nil {
- ans = append(ans, *s)
- }
- case *ast.GenDecl:
- depr := isDeprecated(decl.Doc)
- switch decl.Tok {
- case token.CONST, token.VAR:
- tp := "V"
- if decl.Tok == token.CONST {
- tp = "C"
- }
- if depr {
- tp += "D"
- }
- for _, sp := range decl.Specs {
- for _, x := range sp.(*ast.ValueSpec).Names {
- if s := newsym(pkg, x.Name, tp, ""); s != nil {
- ans = append(ans, *s)
- }
- }
- }
- case token.TYPE:
- tp := "T"
- if depr {
- tp += "D"
- }
- for _, sp := range decl.Specs {
- if s := newsym(pkg, sp.(*ast.TypeSpec).Name.Name, tp, ""); s != nil {
- ans = append(ans, *s)
- }
- }
- }
- }
- }
- return ans
-}
-
-func newsym(pkg, name, kind, sig string) *symbol {
- if len(name) == 0 || !ast.IsExported(name) {
- return nil
- }
- sym := symbol{pkg: pkg, name: name, kind: kind, sig: sig}
- return &sym
-}
-
-func isDeprecated(doc *ast.CommentGroup) bool {
- if doc == nil {
- return false
- }
- // go.dev/wiki/Deprecated Paragraph starting 'Deprecated:'
- // This code fails for /* Deprecated: */, but it's the code from
- // gopls/internal/analysis/deprecated
- for line := range strings.SplitSeq(doc.Text(), "\n\n") {
- if strings.HasPrefix(line, "Deprecated:") {
- return true
- }
- }
- return false
-}
-
-// return the package name and the value for the symbols.
-// if there are multiple packages, choose one arbitrarily
-// the returned slice is sorted lexicographically
-func processSyms(syms []symbol) (string, []string) {
- if len(syms) == 0 {
- return "", nil
- }
- slices.SortFunc(syms, func(l, r symbol) int {
- return strings.Compare(l.name, r.name)
- })
- pkg := syms[0].pkg
- var names []string
- for _, s := range syms {
- if s.pkg != pkg {
- // Symbols came from two files in same dir
- // with different package declarations.
- continue
- }
- var nx string
- if s.sig != "" {
- nx = fmt.Sprintf("%s %s %s", s.name, s.kind, s.sig)
- } else {
- nx = fmt.Sprintf("%s %s", s.name, s.kind)
- }
- names = append(names, nx)
- }
- return pkg, names
-}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/version.go b/vendor/golang.org/x/tools/internal/pkgbits/version.go
index 53af9df2..0db96527 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/version.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/version.go
@@ -28,6 +28,15 @@ const (
// - remove derived info "needed" bool
V2
+ // V3: introduces a more compact format for composite literal element lists
+ // - negative lengths indicate that (some) elements may have keys
+ // - positive lengths indicate that no element has a key
+ // - a negative struct field index indicates an embedded field
+ V3
+
+ // V4: encodes generic methods as standalone function objects
+ V4
+
numVersions = iota
)
@@ -61,6 +70,12 @@ const (
// whether a type was a derived type.
DerivedInfoNeeded
+ // Composite literals use a more compact format for element lists.
+ CompactCompLiterals
+
+ // Generic methods may appear as standalone function objects.
+ GenericMethods
+
numFields = iota
)
@@ -68,6 +83,8 @@ const (
var introduced = [numFields]Version{
Flags: V1,
AliasTypeParamNames: V2,
+ CompactCompLiterals: V3,
+ GenericMethods: V4,
}
// removed is the version a field was removed in or 0 for fields
diff --git a/vendor/golang.org/x/tools/internal/refactor/delete.go b/vendor/golang.org/x/tools/internal/refactor/delete.go
index 54d0b5f0..25547f04 100644
--- a/vendor/golang.org/x/tools/internal/refactor/delete.go
+++ b/vendor/golang.org/x/tools/internal/refactor/delete.go
@@ -32,7 +32,7 @@ import (
// 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) []Edit {
- switch ek, _ := curId.ParentEdge(); ek {
+ switch curId.ParentEdgeKind() {
case edge.ValueSpec_Names:
return deleteVarFromValueSpec(tokFile, info, curId)
@@ -74,7 +74,7 @@ func deleteVarFromValueSpec(tokFile *token.File, info *types.Info, curIdent insp
// 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
+ index := curIdent.ParentEdgeIndex() // index of LHS within ValueSpec.Names
// If there is no RHS, we can delete the LHS.
if len(spec.Values) == 0 {
@@ -181,7 +181,7 @@ func deleteVarFromAssignStmt(tokFile *token.File, info *types.Info, curIdent ins
// If the assignment is 1:1 and the RHS has no effects,
// we can delete the LHS and its corresponding RHS.
- _, index := curIdent.ParentEdge()
+ index := curIdent.ParentEdgeIndex()
if len(assign.Lhs) > 1 &&
len(assign.Lhs) == len(assign.Rhs) &&
typesinternal.NoEffects(info, assign.Rhs[index]) {
@@ -259,7 +259,7 @@ func DeleteSpec(tokFile *token.File, curSpec inspector.Cursor) []Edit {
}
// Delete the spec and its comments.
- _, index := curSpec.ParentEdge() // index of ValueSpec within GenDecl.Specs
+ index := curSpec.ParentEdgeIndex() // index of ValueSpec within GenDecl.Specs
pos, end := spec.Pos(), spec.End()
if doc := astutil.DocComment(spec); doc != nil {
pos = doc.Pos() // leading comment
@@ -288,7 +288,7 @@ func DeleteSpec(tokFile *token.File, curSpec inspector.Cursor) []Edit {
func DeleteDecl(tokFile *token.File, curDecl inspector.Cursor) []Edit {
decl := curDecl.Node().(ast.Decl)
- ek, _ := curDecl.ParentEdge()
+ ek := curDecl.ParentEdgeKind()
switch ek {
case edge.DeclStmt_Decl:
return DeleteStmt(tokFile, curDecl.Parent())
diff --git a/vendor/golang.org/x/tools/internal/refactor/refactor.go b/vendor/golang.org/x/tools/internal/refactor/refactor.go
index 8664377f..1d6c0543 100644
--- a/vendor/golang.org/x/tools/internal/refactor/refactor.go
+++ b/vendor/golang.org/x/tools/internal/refactor/refactor.go
@@ -17,10 +17,9 @@ import (
// FreshName returns the name of an identifier that is undefined
// at the specified position, based on the preferred name.
//
-// TODO(adonovan): refine this to choose a fresh name only when there
-// would be a conflict with the existing declaration: it's fine to
-// redeclare a name in a narrower scope so long as there are no free
-// references to the outer name from within the narrower scope.
+// export/use freshName in go/analysis/passes/modernize/modernize.go if you want
+// to generate a fresh name only when necessary (i.e., there is both an existing
+// declaration and some free reference to the name within a narrower scope)
func FreshName(scope *types.Scope, pos token.Pos, preferred string) string {
newName := preferred
for i := 0; ; i++ {
diff --git a/vendor/golang.org/x/tools/internal/ssainternal/ssainternal.go b/vendor/golang.org/x/tools/internal/ssainternal/ssainternal.go
deleted file mode 100644
index 686c5d97..00000000
--- a/vendor/golang.org/x/tools/internal/ssainternal/ssainternal.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// 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 ssainternal exposes setters for internals of go/ssa.
-// It cannot actually depend on symbols from go/ssa.
-package ssainternal
-
-import "go/types"
-
-// SetNoReturn sets the predicate used when building the ssa.Program
-// prog that reports whether a given function cannot return.
-// This may be used to prune spurious control flow edges
-// after (e.g.) log.Fatal, improving the precision of analyses.
-//
-// You must link [golang.org/x/tools/go/ssa] into your application for
-// this function to be non-nil.
-//
-// TODO(adonovan): add (*ssa.Program).SetNoReturn to the public API.
-var SetNoReturn = func(prog any, noreturn func(*types.Func) bool) {
- panic("golang.org/x/tools/go/ssa not linked into application")
-}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/deps.go b/vendor/golang.org/x/tools/internal/stdlib/deps.go
index f7b9c128..dacfc1df 100644
--- a/vendor/golang.org/x/tools/internal/stdlib/deps.go
+++ b/vendor/golang.org/x/tools/internal/stdlib/deps.go
@@ -12,364 +12,366 @@ type pkginfo struct {
}
var deps = [...]pkginfo{
- {"archive/tar", "\x03p\x03F=\x01\n\x01$\x01\x01\x02\x05\b\x02\x01\x02\x02\f"},
- {"archive/zip", "\x02\x04f\a\x03\x13\x021=\x01+\x05\x01\x0f\x03\x02\x0e\x04"},
- {"bufio", "\x03p\x86\x01D\x14"},
- {"bytes", "s+[\x03\fG\x02\x02"},
+ {"archive/tar", "\x03q\x03F=\x01\n\x01$\x01\x01\x02\x05\b\x02\x01\x02\x02\r"},
+ {"archive/zip", "\x02\x04g\a\x03\x13\x021=\x01+\x05\x01\x0f\x03\x02\x0f\x04"},
+ {"bufio", "\x03q\x86\x01D\x15"},
+ {"bytes", "t+[\x03\fH\x02\x02"},
{"cmp", ""},
- {"compress/bzip2", "\x02\x02\xf5\x01A"},
- {"compress/flate", "\x02q\x03\x83\x01\f\x033\x01\x03"},
- {"compress/gzip", "\x02\x04f\a\x03\x15nT"},
- {"compress/lzw", "\x02q\x03\x83\x01"},
- {"compress/zlib", "\x02\x04f\a\x03\x13\x01o"},
- {"container/heap", "\xbb\x02"},
+ {"compress/bzip2", "\x02\x02\xf6\x01A"},
+ {"compress/flate", "\x02r\x03\x83\x01\f\x033\x01\x03"},
+ {"compress/gzip", "\x02\x04g\a\x03\x15nU"},
+ {"compress/lzw", "\x02r\x03\x83\x01"},
+ {"compress/zlib", "\x02\x04g\a\x03\x13\x01o"},
+ {"container/heap", "\xbc\x02"},
{"container/list", ""},
{"container/ring", ""},
- {"context", "s\\p\x01\r"},
- {"crypto", "\x89\x01pC"},
- {"crypto/aes", "\x10\n\t\x99\x02"},
- {"crypto/cipher", "\x03 \x01\x01 \x12\x1c,Z"},
- {"crypto/des", "\x10\x15 .,\x9d\x01\x03"},
- {"crypto/dsa", "E\x04*\x86\x01\r"},
- {"crypto/ecdh", "\x03\v\f\x10\x04\x17\x04\x0e\x1c\x86\x01"},
- {"crypto/ecdsa", "\x0e\x05\x03\x04\x01\x10\b\v\x06\x01\x04\r\x01\x1c\x86\x01\r\x05K\x01"},
- {"crypto/ed25519", "\x0e\x1e\x12\a\v\a\x1c\x86\x01C"},
- {"crypto/elliptic", "3@\x86\x01\r9"},
- {"crypto/fips140", "\"\x05"},
- {"crypto/hkdf", "/\x15\x01.\x16"},
- {"crypto/hmac", "\x1a\x16\x14\x01\x122"},
- {"crypto/internal/boring", "\x0e\x02\rl"},
- {"crypto/internal/boring/bbig", "\x1a\xec\x01M"},
- {"crypto/internal/boring/bcache", "\xc0\x02\x13"},
+ {"context", "t\\p\x01\x0e"},
+ {"crypto", "\x8a\x01pC"},
+ {"crypto/aes", "\x10\v\t\x99\x02"},
+ {"crypto/cipher", "\x03!\x01\x01 \x12\x1c,Z"},
+ {"crypto/des", "\x10\x16 .,\x9d\x01\x03"},
+ {"crypto/dsa", "F\x03+\x86\x01\r"},
+ {"crypto/ecdh", "\x03\v\r\x10\x04\x17\x03\x0f\x1c\x86\x01"},
+ {"crypto/ecdsa", "\x0e\x05\x03\x05\x01\x10\b\v\x06\x01\x03\x0e\x01\x1c\x86\x01\r\x05L\x01"},
+ {"crypto/ed25519", "\x0e\x1f\x12\a\x03\b\a\x1cI=C"},
+ {"crypto/elliptic", "4@\x86\x01\r9"},
+ {"crypto/fips140", "#\x05\x95\x01\x98\x01"},
+ {"crypto/hkdf", "0\x15\x01.\x16"},
+ {"crypto/hmac", "\x1b\x16\x14\x01\x122"},
+ {"crypto/hpke", "\x03\v\x02\x03\x04\x01\f\x01\x05\x1f\x05\a\x01\x01\x1d\x03\x13\x16\x9b\x01\x1c"},
+ {"crypto/internal/boring", "\x0e\x02\x0el"},
+ {"crypto/internal/boring/bbig", "\x1b\xec\x01N"},
+ {"crypto/internal/boring/bcache", "\xc1\x02\x14"},
{"crypto/internal/boring/sig", ""},
{"crypto/internal/constanttime", ""},
- {"crypto/internal/cryptotest", "\x03\r\n\b&\x0f\x19\x06\x13\x12 \x04\x06\t\x19\x01\x11\x11\x1b\x01\a\x05\b\x03\x05\v"},
- {"crypto/internal/entropy", "J"},
- {"crypto/internal/entropy/v1.0.0", "C0\x95\x018\x13"},
- {"crypto/internal/fips140", "B1\xbf\x01\v\x16"},
- {"crypto/internal/fips140/aes", "\x03\x1f\x03\x02\x14\x05\x01\x01\x06+\x95\x014"},
- {"crypto/internal/fips140/aes/gcm", "\"\x01\x02\x02\x02\x12\x05\x01\a+\x92\x01"},
- {"crypto/internal/fips140/alias", "\xd3\x02"},
- {"crypto/internal/fips140/bigmod", "'\x19\x01\a+\x95\x01"},
- {"crypto/internal/fips140/check", "\"\x0e\a\t\x02\xb7\x01Z"},
- {"crypto/internal/fips140/check/checktest", "'\x8b\x02!"},
- {"crypto/internal/fips140/drbg", "\x03\x1e\x01\x01\x04\x14\x05\t\x01)\x86\x01\x0f7\x01"},
- {"crypto/internal/fips140/ecdh", "\x03\x1f\x05\x02\n\r3\x86\x01\x0f7"},
- {"crypto/internal/fips140/ecdsa", "\x03\x1f\x04\x01\x02\a\x03\x06:\x16pF"},
- {"crypto/internal/fips140/ed25519", "\x03\x1f\x05\x02\x04\f:\xc9\x01\x03"},
- {"crypto/internal/fips140/edwards25519", "\x1e\t\a\x123\x95\x017"},
- {"crypto/internal/fips140/edwards25519/field", "'\x14\x053\x95\x01"},
- {"crypto/internal/fips140/hkdf", "\x03\x1f\x05\t\a<\x16"},
- {"crypto/internal/fips140/hmac", "\x03\x1f\x15\x01\x01:\x16"},
- {"crypto/internal/fips140/mldsa", "\x03\x1b\x04\x05\x02\x0e\x01\x03\x053\x95\x017"},
- {"crypto/internal/fips140/mlkem", "\x03\x1f\x05\x02\x0f\x03\x053\xcc\x01"},
- {"crypto/internal/fips140/nistec", "\x1e\t\r\f3\x95\x01*\r\x14"},
- {"crypto/internal/fips140/nistec/fiat", "'\x148\x95\x01"},
- {"crypto/internal/fips140/pbkdf2", "\x03\x1f\x05\t\a<\x16"},
- {"crypto/internal/fips140/rsa", "\x03\x1b\x04\x04\x01\x02\x0e\x01\x01\x028\x16pF"},
- {"crypto/internal/fips140/sha256", "\x03\x1f\x1e\x01\a+\x16\x7f"},
- {"crypto/internal/fips140/sha3", "\x03\x1f\x19\x05\x012\x95\x01K"},
- {"crypto/internal/fips140/sha512", "\x03\x1f\x1e\x01\a+\x16\x7f"},
- {"crypto/internal/fips140/ssh", "'b"},
- {"crypto/internal/fips140/subtle", "\x1e\a\x1b\xc8\x01"},
- {"crypto/internal/fips140/tls12", "\x03\x1f\x05\t\a\x02:\x16"},
- {"crypto/internal/fips140/tls13", "\x03\x1f\x05\b\b\t3\x16"},
- {"crypto/internal/fips140cache", "\xb2\x02\r&"},
+ {"crypto/internal/cryptotest", "\x03\r\v\b%\x10\x19\x06\x13\x12 \x04\x06\t\x19\x01\x11\x11\x1b\x01\a\x05\b\x03\x05\f"},
+ {"crypto/internal/entropy", "K"},
+ {"crypto/internal/entropy/v1.0.0", "D0\x95\x018\x14"},
+ {"crypto/internal/fips140", "C1\xbf\x01\v\x17"},
+ {"crypto/internal/fips140/aes", "\x03 \x03\x02\x14\x05\x01\x01\x05,\x95\x014"},
+ {"crypto/internal/fips140/aes/gcm", "#\x01\x02\x02\x02\x12\x05\x01\x06,\x92\x01"},
+ {"crypto/internal/fips140/alias", "\xd5\x02"},
+ {"crypto/internal/fips140/bigmod", "(\x19\x01\x06,\x95\x01"},
+ {"crypto/internal/fips140/check", "#\x0e\a\t\x02\xb7\x01["},
+ {"crypto/internal/fips140/check/checktest", "(\x8b\x02\""},
+ {"crypto/internal/fips140/drbg", "\x03\x1f\x01\x01\x04\x14\x05\n)\x86\x01\x0f7\x01"},
+ {"crypto/internal/fips140/ecdh", "\x03 \x05\x02\n\r3\x86\x01\x0f7"},
+ {"crypto/internal/fips140/ecdsa", "\x03 \x04\x01\x02\a\x03\x06:\x16pF"},
+ {"crypto/internal/fips140/ed25519", "\x03 \x05\x02\x04\f:\xc9\x01\x03"},
+ {"crypto/internal/fips140/edwards25519", "\x1f\t\a\x123\x95\x017"},
+ {"crypto/internal/fips140/edwards25519/field", "(\x14\x053\x95\x01"},
+ {"crypto/internal/fips140/hkdf", "\x03 \x05\t\a<\x16"},
+ {"crypto/internal/fips140/hmac", "\x03 \x15\x01\x01:\x16"},
+ {"crypto/internal/fips140/mldsa", "\x03\x1c\x04\x05\x02\x0e\x01\x03\x053\x95\x017"},
+ {"crypto/internal/fips140/mlkem", "\x03 \x05\x02\x0f\x03\x053\xcc\x01"},
+ {"crypto/internal/fips140/nistec", "\x1f\t\r\f3\x95\x01*\r\x15"},
+ {"crypto/internal/fips140/nistec/fiat", "(\x148\x95\x01"},
+ {"crypto/internal/fips140/pbkdf2", "\x03 \x05\t\a<\x16"},
+ {"crypto/internal/fips140/rsa", "\x03\x1c\x04\x04\x01\x02\x0e\x01\x01\x028\x16pF"},
+ {"crypto/internal/fips140/sha256", "\x03 \x1e\x01\x06,\x16\x7f"},
+ {"crypto/internal/fips140/sha3", "\x03 \x19\x05\x012\x95\x01L"},
+ {"crypto/internal/fips140/sha512", "\x03 \x1e\x01\x06,\x16\x7f"},
+ {"crypto/internal/fips140/ssh", "(b"},
+ {"crypto/internal/fips140/subtle", "\x1f\a\x1b\xc8\x01"},
+ {"crypto/internal/fips140/tls12", "\x03 \x05\t\a\x02:\x16"},
+ {"crypto/internal/fips140/tls13", "\x03 \x05\b\b\t3\x16"},
+ {"crypto/internal/fips140cache", "\xb3\x02\r'"},
{"crypto/internal/fips140deps", ""},
- {"crypto/internal/fips140deps/byteorder", "\x9f\x01"},
- {"crypto/internal/fips140deps/cpu", "\xb4\x01\a"},
- {"crypto/internal/fips140deps/godebug", "\xbc\x01"},
- {"crypto/internal/fips140deps/time", "\xcd\x02"},
- {"crypto/internal/fips140hash", "8\x1d4\xca\x01"},
- {"crypto/internal/fips140only", ")\x0e\x01\x01P3="},
+ {"crypto/internal/fips140deps/byteorder", "\xa0\x01"},
+ {"crypto/internal/fips140deps/cpu", "\xb5\x01\a"},
+ {"crypto/internal/fips140deps/godebug", "\xbd\x01"},
+ {"crypto/internal/fips140deps/time", "\xcf\x02"},
+ {"crypto/internal/fips140hash", "9\x1d4\xcb\x01"},
+ {"crypto/internal/fips140only", "\x17\x13\x0e\x01\x01Pp"},
{"crypto/internal/fips140test", ""},
- {"crypto/internal/hpke", "\x03\v\x01\x01\x03\x055\x03\x04\x01\x01\x16\a\x03\x13\xcc\x01"},
- {"crypto/internal/impl", "\xbd\x02"},
- {"crypto/internal/randutil", "\xf9\x01\x12"},
- {"crypto/internal/sysrand", "sq! \r\r\x01\x01\f\x06"},
- {"crypto/internal/sysrand/internal/seccomp", "s"},
- {"crypto/md5", "\x0e7.\x16\x16i"},
- {"crypto/mlkem", "\x0e$"},
- {"crypto/mlkem/mlkemtest", "2\x1b&"},
- {"crypto/pbkdf2", "5\x0f\x01.\x16"},
- {"crypto/rand", "\x1a\b\a\x1c\x04\x01)\x86\x01\rM"},
- {"crypto/rc4", "% .\xc9\x01"},
- {"crypto/rsa", "\x0e\f\x01\v\x10\x0e\x01\x04\a\a\x1c\x03\x133=\f\x01"},
- {"crypto/sha1", "\x0e\f+\x03+\x16\x16\x15T"},
- {"crypto/sha256", "\x0e\f\x1dR"},
- {"crypto/sha3", "\x0e*Q\xca\x01"},
- {"crypto/sha512", "\x0e\f\x1fP"},
- {"crypto/subtle", "\x1e\x1d\x9f\x01X"},
- {"crypto/tls", "\x03\b\x02\x01\x01\x01\x01\x02\x01\x01\x01\x02\x01\x01\t\x01\x0e\n\x01\n\x05\x04\x01\x01\x01\x01\x02\x01\x02\x01\x17\x02\x03\x13\x16\x15\b=\x16\x16\r\b\x01\x01\x01\x02\x01\r\x06\x02\x01\x0f"},
- {"crypto/tls/internal/fips140tls", "\x17\xa9\x02"},
- {"crypto/x509", "\x03\v\x01\x01\x01\x01\x01\x01\x01\x016\x06\x01\x01\x02\x05\x0e\x06\x02\x02\x03F\x03:\x01\x02\b\x01\x01\x02\a\x10\x05\x01\x06\a\b\x02\x01\x02\x0e\x02\x01\x01\x02\x03\x01"},
- {"crypto/x509/pkix", "i\x06\a\x90\x01G"},
- {"database/sql", "\x03\nP\x16\x03\x83\x01\v\a\"\x05\b\x02\x03\x01\r\x02\x02\x02"},
- {"database/sql/driver", "\rf\x03\xb7\x01\x0f\x11"},
- {"debug/buildinfo", "\x03]\x02\x01\x01\b\a\x03g\x1a\x02\x01+\x0f\x1f"},
- {"debug/dwarf", "\x03i\a\x03\x83\x011\x11\x01\x01"},
- {"debug/elf", "\x03\x06V\r\a\x03g\x1b\x01\f \x17\x01\x16"},
- {"debug/gosym", "\x03i\n\xc5\x01\x01\x01\x02"},
- {"debug/macho", "\x03\x06V\r\ng\x1c,\x17\x01"},
- {"debug/pe", "\x03\x06V\r\a\x03g\x1c,\x17\x01\x16"},
- {"debug/plan9obj", "l\a\x03g\x1c,"},
- {"embed", "s+B\x19\x01S"},
+ {"crypto/internal/impl", "\xbe\x02"},
+ {"crypto/internal/rand", "\x1b\x0f s=["},
+ {"crypto/internal/randutil", "\xfa\x01\x12"},
+ {"crypto/internal/sysrand", "tq! \r\r\x01\x01\r\x06"},
+ {"crypto/internal/sysrand/internal/seccomp", "t"},
+ {"crypto/md5", "\x0e8.\x16\x16i"},
+ {"crypto/mlkem", "\x0e%"},
+ {"crypto/mlkem/mlkemtest", "3\x13\b&"},
+ {"crypto/pbkdf2", "6\x0f\x01.\x16"},
+ {"crypto/rand", "\x1b\x0f\x1c\x03+\x86\x01\rN"},
+ {"crypto/rc4", "& .\xc9\x01"},
+ {"crypto/rsa", "\x0e\r\x01\v\x10\x0e\x01\x03\b\a\x1c\x03\x133=\f\x01"},
+ {"crypto/sha1", "\x0e\r+\x02,\x16\x16\x15T"},
+ {"crypto/sha256", "\x0e\r\x1dR"},
+ {"crypto/sha3", "\x0e+Q\xcb\x01"},
+ {"crypto/sha512", "\x0e\r\x1fP"},
+ {"crypto/subtle", "\x1f\x1d\x9f\x01z"},
+ {"crypto/tls", "\x03\b\x02\x01\x01\x01\x01\x02\x01\x01\x01\x02\x01\x01\x01\t\x01\x18\x01\x0f\x01\x03\x01\x01\x01\x01\x02\x01\x02\x01\x17\x02\x03\x13\x16\x15\b=\x16\x16\r\b\x01\x01\x01\x02\x01\x0e\x06\x02\x01\x0f"},
+ {"crypto/tls/internal/fips140tls", "\x17\xaa\x02"},
+ {"crypto/x509", "\x03\v\x01\x01\x01\x01\x01\x01\x01\x017\x06\x01\x01\x02\x05\x0e\x06\x02\x02\x03F\x03:\x01\x02\b\x01\x01\x02\a\x10\x05\x01\x06\a\b\x02\x01\x02\x0f\x02\x01\x01\x02\x03\x01"},
+ {"crypto/x509/pkix", "j\x06\a\x90\x01H"},
+ {"database/sql", "\x03\nQ\x16\x03\x83\x01\v\a\"\x05\b\x02\x03\x01\x0e\x02\x02\x02"},
+ {"database/sql/driver", "\rg\x03\xb7\x01\x0f\x12"},
+ {"debug/buildinfo", "\x03^\x02\x01\x01\b\a\x03g\x1a\x02\x01+\x0f "},
+ {"debug/dwarf", "\x03j\a\x03\x83\x011\x11\x01\x01"},
+ {"debug/elf", "\x03\x06W\r\a\x03g\x1b\x01\f \x17\x01\x17"},
+ {"debug/gosym", "\x03j\n$\xa1\x01\x01\x01\x02"},
+ {"debug/macho", "\x03\x06W\r\ng\x1c,\x17\x01"},
+ {"debug/pe", "\x03\x06W\r\a\x03g\x1c,\x17\x01\x17"},
+ {"debug/plan9obj", "m\a\x03g\x1c,"},
+ {"embed", "t+B\x19\x01T"},
{"embed/internal/embedtest", ""},
{"encoding", ""},
- {"encoding/ascii85", "\xf9\x01C"},
- {"encoding/asn1", "\x03p\x03g(\x01'\r\x02\x01\x10\x03\x01"},
- {"encoding/base32", "\xf9\x01A\x02"},
- {"encoding/base64", "\x9f\x01ZA\x02"},
- {"encoding/binary", "s\x86\x01\f(\r\x05"},
- {"encoding/csv", "\x02\x01p\x03\x83\x01D\x12\x02"},
- {"encoding/gob", "\x02e\x05\a\x03g\x1c\v\x01\x03\x1d\b\x12\x01\x0f\x02"},
- {"encoding/hex", "s\x03\x83\x01A\x03"},
- {"encoding/json", "\x03\x01c\x04\b\x03\x83\x01\f(\r\x02\x01\x02\x10\x01\x01\x02"},
- {"encoding/pem", "\x03h\b\x86\x01A\x03"},
- {"encoding/xml", "\x02\x01d\f\x03\x83\x014\x05\n\x01\x02\x10\x02"},
- {"errors", "\xcf\x01\x84\x01"},
- {"expvar", "pLA\b\v\x15\r\b\x02\x03\x01\x11"},
- {"flag", "g\f\x03\x83\x01,\b\x05\b\x02\x01\x10"},
- {"fmt", "sF'\x19\f \b\r\x02\x03\x12"},
- {"go/ast", "\x03\x01r\x0f\x01s\x03)\b\r\x02\x01\x12\x02"},
- {"go/build", "\x02\x01p\x03\x01\x02\x02\b\x02\x01\x17\x1f\x04\x02\b\x1c\x13\x01+\x01\x04\x01\a\b\x02\x01\x12\x02\x02"},
- {"go/build/constraint", "s\xc9\x01\x01\x12\x02"},
- {"go/constant", "v\x10\x7f\x01\x024\x01\x02\x12"},
- {"go/doc", "\x04r\x01\x05\n=61\x10\x02\x01\x12\x02"},
- {"go/doc/comment", "\x03s\xc4\x01\x01\x01\x01\x12\x02"},
- {"go/format", "\x03s\x01\f\x01\x02sD"},
- {"go/importer", "x\a\x01\x02\x04\x01r9"},
- {"go/internal/gccgoimporter", "\x02\x01]\x13\x03\x04\f\x01p\x02,\x01\x05\x11\x01\f\b"},
- {"go/internal/gcimporter", "\x02t\x10\x010\x05\r0,\x15\x03\x02"},
- {"go/internal/scannerhooks", "\x86\x01"},
- {"go/internal/srcimporter", "v\x01\x01\v\x03\x01r,\x01\x05\x12\x02\x14"},
- {"go/parser", "\x03p\x03\x01\x02\b\x04\x01s\x01+\x06\x12"},
- {"go/printer", "v\x01\x02\x03\ns\f \x15\x02\x01\x02\v\x05\x02"},
- {"go/scanner", "\x03s\v\x05s2\x10\x01\x13\x02"},
- {"go/token", "\x04r\x86\x01>\x02\x03\x01\x0f\x02"},
- {"go/types", "\x03\x01\x06i\x03\x01\x03\t\x03\x024\x063\x04\x03\t \x06\a\b\x01\x01\x01\x02\x01\x0f\x02\x02"},
- {"go/version", "\xc1\x01|"},
- {"hash", "\xf9\x01"},
- {"hash/adler32", "s\x16\x16"},
- {"hash/crc32", "s\x16\x16\x15\x8b\x01\x01\x13"},
- {"hash/crc64", "s\x16\x16\xa0\x01"},
- {"hash/fnv", "s\x16\x16i"},
- {"hash/maphash", "\x89\x01\x11<}"},
- {"html", "\xbd\x02\x02\x12"},
- {"html/template", "\x03m\x06\x19-=\x01\n!\x05\x01\x02\x03\f\x01\x02\f\x01\x03\x02"},
- {"image", "\x02q\x1fg\x0f4\x03\x01"},
+ {"encoding/ascii85", "\xfa\x01C"},
+ {"encoding/asn1", "\x03q\x03g(\x01'\r\x02\x01\x11\x03\x01"},
+ {"encoding/base32", "\xfa\x01A\x02"},
+ {"encoding/base64", "\xa0\x01ZA\x02"},
+ {"encoding/binary", "t\x86\x01\f(\r\x05"},
+ {"encoding/csv", "\x02\x01q\x03\x83\x01D\x13\x02"},
+ {"encoding/gob", "\x02f\x05\a\x03g\x1c\v\x01\x03\x1d\b\x12\x01\x10\x02"},
+ {"encoding/hex", "t\x03\x83\x01A\x03"},
+ {"encoding/json", "\x03\x01d\x04\b\x03\x83\x01\f(\r\x02\x01\x02\x11\x01\x01\x02"},
+ {"encoding/pem", "\x03i\b\x86\x01A\x03"},
+ {"encoding/xml", "\x02\x01e\f\x03\x83\x014\x05\n\x01\x02\x11\x02"},
+ {"errors", "\xd0\x01\x85\x01"},
+ {"expvar", "qLA\b\v\x15\r\b\x02\x03\x01\x12"},
+ {"flag", "h\f\x03\x83\x01,\b\x05\b\x02\x01\x11"},
+ {"fmt", "tF'\x19\f \b\r\x02\x03\x13"},
+ {"go/ast", "\x03\x01s\x0f\x01s\x03)\b\r\x02\x01\x13\x02"},
+ {"go/build", "\x02\x01q\x03\x01\x02\x02\b\x02\x01\x17\x1f\x04\x02\b\x1c\x13\x01+\x01\x04\x01\a\b\x02\x01\x13\x02\x02"},
+ {"go/build/constraint", "t\xc9\x01\x01\x13\x02"},
+ {"go/constant", "w\x10\x7f\x01\x024\x01\x02\x13"},
+ {"go/doc", "\x04s\x01\x05\n=61\x10\x02\x01\x13\x02"},
+ {"go/doc/comment", "\x03t\xc4\x01\x01\x01\x01\x13\x02"},
+ {"go/format", "\x03t\x01\f\x01\x02sD"},
+ {"go/importer", "y\a\x01\x02\x04\x01r9"},
+ {"go/internal/gccgoimporter", "\x02\x01^\x13\x03\x04\f\x01p\x02,\x01\x05\x11\x01\r\b"},
+ {"go/internal/gcimporter", "\x02u\x10\x010\x05\r0,\x15\x03\x02"},
+ {"go/internal/scannerhooks", "\x87\x01"},
+ {"go/internal/srcimporter", "w\x01\x01\v\x03\x01r,\x01\x05\x12\x02\x15"},
+ {"go/parser", "\x03q\x03\x01\x02\b\x04\x01s\x01+\x06\x12"},
+ {"go/printer", "w\x01\x02\x03\ns\f \x15\x02\x01\x02\f\x05\x02"},
+ {"go/scanner", "\x03t\v\x05s2\x10\x01\x14\x02"},
+ {"go/token", "\x04s\x86\x01>\x02\x03\x01\x10\x02"},
+ {"go/types", "\x03\x01\x06j\x03\x01\x03\t\x03\x024\x063\x04\x03\t \x06\a\b\x01\x01\x01\x02\x01\x10\x02\x02"},
+ {"go/version", "\xc2\x01|"},
+ {"hash", "\xfa\x01"},
+ {"hash/adler32", "t\x16\x16"},
+ {"hash/crc32", "t\x16\x16\x15\x8b\x01\x01\x14"},
+ {"hash/crc64", "t\x16\x16\xa0\x01"},
+ {"hash/fnv", "t\x16\x16i"},
+ {"hash/maphash", "\x8a\x01\x11<~"},
+ {"html", "\xbe\x02\x02\x13"},
+ {"html/template", "\x03n\x06\x19-=\x01\n!\x05\x01\x02\x03\f\x01\x02\r\x01\x03\x02"},
+ {"image", "\x02r\x1fg\x0f4\x03\x01"},
{"image/color", ""},
- {"image/color/palette", "\x92\x01"},
- {"image/draw", "\x91\x01\x01\x04"},
- {"image/gif", "\x02\x01\x05k\x03\x1b\x01\x01\x01\vZ\x0f"},
- {"image/internal/imageutil", "\x91\x01"},
- {"image/jpeg", "\x02q\x1e\x01\x04c"},
- {"image/png", "\x02\ac\n\x13\x02\x06\x01gC"},
- {"index/suffixarray", "\x03i\a\x86\x01\f+\n\x01"},
- {"internal/abi", "\xbb\x01\x98\x01"},
- {"internal/asan", "\xd3\x02"},
- {"internal/bisect", "\xb2\x02\r\x01"},
- {"internal/buildcfg", "vHg\x06\x02\x05\n\x01"},
- {"internal/bytealg", "\xb4\x01\x9f\x01"},
+ {"image/color/palette", "\x93\x01"},
+ {"image/draw", "\x92\x01\x01\x04"},
+ {"image/gif", "\x02\x01\x05l\x03\x1b\x01\x01\x01\vZ\x0f"},
+ {"image/internal/imageutil", "\x92\x01"},
+ {"image/jpeg", "\x02r\x1e\x01\x04c"},
+ {"image/png", "\x02\ad\n\x13\x02\x06\x01gC"},
+ {"index/suffixarray", "\x03j\a\x86\x01\f+\n\x01"},
+ {"internal/abi", "\xbc\x01\x99\x01"},
+ {"internal/asan", "\xd5\x02"},
+ {"internal/bisect", "\xb3\x02\r\x01"},
+ {"internal/buildcfg", "wHg\x06\x02\x05\n\x01"},
+ {"internal/bytealg", "\xb5\x01\xa0\x01"},
{"internal/byteorder", ""},
{"internal/cfg", ""},
- {"internal/cgrouptest", "v[T\x06\x0f\x02\x01\x04\x01"},
- {"internal/chacha8rand", "\x9f\x01\x15\a\x98\x01"},
+ {"internal/cgrouptest", "w[T\x06\x0f\x02\x01\x04\x01"},
+ {"internal/chacha8rand", "\xa0\x01\x15\a\x99\x01"},
{"internal/copyright", ""},
{"internal/coverage", ""},
{"internal/coverage/calloc", ""},
- {"internal/coverage/cfile", "p\x06\x17\x17\x01\x02\x01\x01\x01\x01\x01\x01\x01\"\x02',\x06\a\n\x01\x03\r\x06"},
- {"internal/coverage/cformat", "\x04r.\x04Q\v6\x01\x02\r"},
- {"internal/coverage/cmerge", "v.a"},
- {"internal/coverage/decodecounter", "l\n.\v\x02H,\x17\x17"},
- {"internal/coverage/decodemeta", "\x02j\n\x17\x17\v\x02H,"},
- {"internal/coverage/encodecounter", "\x02j\n.\f\x01\x02F\v!\x15"},
- {"internal/coverage/encodemeta", "\x02\x01i\n\x13\x04\x17\r\x02F,."},
- {"internal/coverage/pods", "\x04r.\x81\x01\x06\x05\n\x02\x01"},
- {"internal/coverage/rtcov", "\xd3\x02"},
- {"internal/coverage/slicereader", "l\n\x83\x01Z"},
- {"internal/coverage/slicewriter", "v\x83\x01"},
- {"internal/coverage/stringtab", "v9\x04F"},
+ {"internal/coverage/cfile", "q\x06\x17\x17\x01\x02\x01\x01\x01\x01\x01\x01\x01\"\x02',\x06\a\n\x01\x03\x0e\x06"},
+ {"internal/coverage/cformat", "\x04s.\x04Q\v6\x01\x02\x0e"},
+ {"internal/coverage/cmerge", "w.a"},
+ {"internal/coverage/decodecounter", "m\n.\v\x02H,\x17\x18"},
+ {"internal/coverage/decodemeta", "\x02k\n\x17\x17\v\x02H,"},
+ {"internal/coverage/encodecounter", "\x02k\n.\f\x01\x02F\v!\x15"},
+ {"internal/coverage/encodemeta", "\x02\x01j\n\x13\x04\x17\r\x02F,/"},
+ {"internal/coverage/pods", "\x04s.\x81\x01\x06\x05\n\x02\x01"},
+ {"internal/coverage/rtcov", "\xd5\x02"},
+ {"internal/coverage/slicereader", "m\n\x83\x01["},
+ {"internal/coverage/slicewriter", "w\x83\x01"},
+ {"internal/coverage/stringtab", "w9\x04F"},
{"internal/coverage/test", ""},
{"internal/coverage/uleb128", ""},
- {"internal/cpu", "\xd3\x02"},
- {"internal/dag", "\x04r\xc4\x01\x03"},
- {"internal/diff", "\x03s\xc5\x01\x02"},
- {"internal/exportdata", "\x02\x01p\x03\x02e\x1c,\x01\x05\x11\x01\x02"},
- {"internal/filepathlite", "s+B\x1a@"},
- {"internal/fmtsort", "\x04\xa9\x02\r"},
- {"internal/fuzz", "\x03\nG\x18\x04\x03\x03\x01\f\x036=\f\x03\x1d\x01\x05\x02\x05\n\x01\x02\x01\x01\f\x04\x02"},
+ {"internal/cpu", "\xd5\x02"},
+ {"internal/dag", "\x04s\xc4\x01\x03"},
+ {"internal/diff", "\x03t\xc5\x01\x02"},
+ {"internal/exportdata", "\x02\x01q\x03\x02e\x1c,\x01\x05\x11\x01\x02"},
+ {"internal/filepathlite", "t+B\x1a@"},
+ {"internal/fmtsort", "\x04\xaa\x02\r"},
+ {"internal/fuzz", "\x03\nH\x18\x04\x03\x03\x01\f\x036=\f\x03\x1d\x01\x05\x02\x05\n\x01\x02\x01\x01\r\x04\x02"},
{"internal/goarch", ""},
- {"internal/godebug", "\x9c\x01!\x82\x01\x01\x13"},
+ {"internal/godebug", "\x9d\x01!\x82\x01\x01\x14"},
{"internal/godebugs", ""},
{"internal/goexperiment", ""},
{"internal/goos", ""},
- {"internal/goroot", "\xa5\x02\x01\x05\x12\x02"},
+ {"internal/goroot", "\xa6\x02\x01\x05\x12\x02"},
{"internal/gover", "\x04"},
{"internal/goversion", ""},
- {"internal/lazyregexp", "\xa5\x02\v\r\x02"},
- {"internal/lazytemplate", "\xf9\x01,\x18\x02\f"},
- {"internal/msan", "\xd3\x02"},
+ {"internal/lazyregexp", "\xa6\x02\v\r\x02"},
+ {"internal/lazytemplate", "\xfa\x01,\x18\x02\r"},
+ {"internal/msan", "\xd5\x02"},
{"internal/nettrace", ""},
- {"internal/obscuretestdata", "k\x8e\x01,"},
- {"internal/oserror", "s"},
- {"internal/pkgbits", "\x03Q\x18\a\x03\x04\fs\r\x1f\r\n\x01"},
+ {"internal/obscuretestdata", "l\x8e\x01,"},
+ {"internal/oserror", "t"},
+ {"internal/pkgbits", "\x03R\x18\a\x03\x04\fs\r\x1f\r\n\x01"},
{"internal/platform", ""},
- {"internal/poll", "sl\x05\x159\r\x01\x01\f\x06"},
- {"internal/profile", "\x03\x04l\x03\x83\x017\n\x01\x01\x01\x10"},
+ {"internal/poll", "tl\x05\x159\r\x01\x01\r\x06"},
+ {"internal/profile", "\x03\x04m\x03\x83\x017\n\x01\x01\x01\x11"},
{"internal/profilerecord", ""},
- {"internal/race", "\x9a\x01\xb9\x01"},
- {"internal/reflectlite", "\x9a\x01!;\x16"},
- {"vendor/golang.org/x/text/unicode/norm", "l\n\x83\x01F\x12\x11"},
- {"weak", "\x9a\x01\x98\x01!"},
+ {"vendor/golang.org/x/crypto/internal/alias", "\xd5\x02"},
+ {"vendor/golang.org/x/crypto/internal/poly1305", "X\x15\x9c\x01"},
+ {"vendor/golang.org/x/net/dns/dnsmessage", "t\xc7\x01"},
+ {"vendor/golang.org/x/net/http/httpguts", "\x90\x02\x14\x1a\x15\r"},
+ {"vendor/golang.org/x/net/http/httpproxy", "t\x03\x99\x01\x10\x05\x01\x18\x15\r"},
+ {"vendor/golang.org/x/net/http2/hpack", "\x03q\x03\x83\x01F"},
+ {"vendor/golang.org/x/net/idna", "w\x8f\x018\x15\x10\x02\x01"},
+ {"vendor/golang.org/x/net/nettest", "\x03j\a\x03\x83\x01\x11\x05\x16\x01\f\n\x01\x02\x02\x01\f"},
+ {"vendor/golang.org/x/sys/cpu", "\xa6\x02\r\n\x01\x17"},
+ {"vendor/golang.org/x/text/secure/bidirule", "t\xdf\x01\x11\x01"},
+ {"vendor/golang.org/x/text/transform", "\x03q\x86\x01Y"},
+ {"vendor/golang.org/x/text/unicode/bidi", "\x03\bl\x87\x01>\x17"},
+ {"vendor/golang.org/x/text/unicode/norm", "m\n\x83\x01F\x13\x11"},
+ {"weak", "\x9b\x01\x98\x01\""},
}
// bootstrap is the list of bootstrap packages extracted from cmd/dist.
diff --git a/vendor/golang.org/x/tools/internal/stdlib/manifest.go b/vendor/golang.org/x/tools/internal/stdlib/manifest.go
index f1e24625..33e4f505 100644
--- a/vendor/golang.org/x/tools/internal/stdlib/manifest.go
+++ b/vendor/golang.org/x/tools/internal/stdlib/manifest.go
@@ -626,7 +626,7 @@ var PackageSymbols = map[string][]Symbol{
{"PublicKey", Type, 0, ""},
{"PublicKey.Parameters", Field, 0, ""},
{"PublicKey.Y", Field, 0, ""},
- {"Sign", Func, 0, "func(rand io.Reader, priv *PrivateKey, hash []byte) (r *big.Int, s *big.Int, err error)"},
+ {"Sign", Func, 0, "func(random io.Reader, priv *PrivateKey, hash []byte) (r *big.Int, s *big.Int, err error)"},
{"Verify", Func, 0, "func(pub *PublicKey, hash []byte, r *big.Int, s *big.Int) bool"},
},
"crypto/ecdh": {
@@ -674,7 +674,7 @@ var PackageSymbols = map[string][]Symbol{
{"(PublicKey).Params", Method, 0, ""},
{"(PublicKey).ScalarBaseMult", Method, 0, ""},
{"(PublicKey).ScalarMult", Method, 0, ""},
- {"GenerateKey", Func, 0, "func(c elliptic.Curve, rand io.Reader) (*PrivateKey, error)"},
+ {"GenerateKey", Func, 0, "func(c elliptic.Curve, r io.Reader) (*PrivateKey, error)"},
{"ParseRawPrivateKey", Func, 25, "func(curve elliptic.Curve, data []byte) (*PrivateKey, error)"},
{"ParseUncompressedPublicKey", Func, 25, "func(curve elliptic.Curve, data []byte) (*PublicKey, error)"},
{"PrivateKey", Type, 0, ""},
@@ -685,7 +685,7 @@ var PackageSymbols = map[string][]Symbol{
{"PublicKey.X", Field, 0, ""},
{"PublicKey.Y", Field, 0, ""},
{"Sign", Func, 0, "func(rand io.Reader, priv *PrivateKey, hash []byte) (r *big.Int, s *big.Int, err error)"},
- {"SignASN1", Func, 15, "func(rand io.Reader, priv *PrivateKey, hash []byte) ([]byte, error)"},
+ {"SignASN1", Func, 15, "func(r io.Reader, priv *PrivateKey, hash []byte) ([]byte, error)"},
{"Verify", Func, 0, "func(pub *PublicKey, hash []byte, r *big.Int, s *big.Int) bool"},
{"VerifyASN1", Func, 15, "func(pub *PublicKey, hash []byte, sig []byte) bool"},
},
@@ -696,7 +696,7 @@ var PackageSymbols = map[string][]Symbol{
{"(PrivateKey).Seed", Method, 13, ""},
{"(PrivateKey).Sign", Method, 13, ""},
{"(PublicKey).Equal", Method, 15, ""},
- {"GenerateKey", Func, 13, "func(rand io.Reader) (PublicKey, PrivateKey, error)"},
+ {"GenerateKey", Func, 13, "func(random io.Reader) (PublicKey, PrivateKey, error)"},
{"NewKeyFromSeed", Func, 13, "func(seed []byte) PrivateKey"},
{"Options", Type, 20, ""},
{"Options.Context", Field, 20, ""},
@@ -745,7 +745,9 @@ var PackageSymbols = map[string][]Symbol{
},
"crypto/fips140": {
{"Enabled", Func, 24, "func() bool"},
+ {"Enforced", Func, 26, "func() bool"},
{"Version", Func, 26, "func() string"},
+ {"WithoutEnforcement", Func, 26, "func(f func())"},
},
"crypto/hkdf": {
{"Expand", Func, 24, "func[H hash.Hash](h func() H, pseudorandomKey []byte, info string, keyLength int) ([]byte, error)"},
@@ -756,6 +758,54 @@ var PackageSymbols = map[string][]Symbol{
{"Equal", Func, 1, "func(mac1 []byte, mac2 []byte) bool"},
{"New", Func, 0, "func(h func() hash.Hash, key []byte) hash.Hash"},
},
+ "crypto/hpke": {
+ {"(*Recipient).Export", Method, 26, ""},
+ {"(*Recipient).Open", Method, 26, ""},
+ {"(*Sender).Export", Method, 26, ""},
+ {"(*Sender).Seal", Method, 26, ""},
+ {"(AEAD).ID", Method, 26, ""},
+ {"(KDF).ID", Method, 26, ""},
+ {"(KEM).DeriveKeyPair", Method, 26, ""},
+ {"(KEM).GenerateKey", Method, 26, ""},
+ {"(KEM).ID", Method, 26, ""},
+ {"(KEM).NewPrivateKey", Method, 26, ""},
+ {"(KEM).NewPublicKey", Method, 26, ""},
+ {"(PrivateKey).Bytes", Method, 26, ""},
+ {"(PrivateKey).KEM", Method, 26, ""},
+ {"(PrivateKey).PublicKey", Method, 26, ""},
+ {"(PublicKey).Bytes", Method, 26, ""},
+ {"(PublicKey).KEM", Method, 26, ""},
+ {"AES128GCM", Func, 26, "func() AEAD"},
+ {"AES256GCM", Func, 26, "func() AEAD"},
+ {"ChaCha20Poly1305", Func, 26, "func() AEAD"},
+ {"DHKEM", Func, 26, "func(curve ecdh.Curve) KEM"},
+ {"ExportOnly", Func, 26, "func() AEAD"},
+ {"HKDFSHA256", Func, 26, "func() KDF"},
+ {"HKDFSHA384", Func, 26, "func() KDF"},
+ {"HKDFSHA512", Func, 26, "func() KDF"},
+ {"MLKEM1024", Func, 26, "func() KEM"},
+ {"MLKEM1024P384", Func, 26, "func() KEM"},
+ {"MLKEM768", Func, 26, "func() KEM"},
+ {"MLKEM768P256", Func, 26, "func() KEM"},
+ {"MLKEM768X25519", Func, 26, "func() KEM"},
+ {"NewAEAD", Func, 26, "func(id uint16) (AEAD, error)"},
+ {"NewDHKEMPrivateKey", Func, 26, "func(priv ecdh.KeyExchanger) (PrivateKey, error)"},
+ {"NewDHKEMPublicKey", Func, 26, "func(pub *ecdh.PublicKey) (PublicKey, error)"},
+ {"NewHybridPrivateKey", Func, 26, "func(pq crypto.Decapsulator, t ecdh.KeyExchanger) (PrivateKey, error)"},
+ {"NewHybridPublicKey", Func, 26, "func(pq crypto.Encapsulator, t *ecdh.PublicKey) (PublicKey, error)"},
+ {"NewKDF", Func, 26, "func(id uint16) (KDF, error)"},
+ {"NewKEM", Func, 26, "func(id uint16) (KEM, error)"},
+ {"NewMLKEMPrivateKey", Func, 26, "func(priv crypto.Decapsulator) (PrivateKey, error)"},
+ {"NewMLKEMPublicKey", Func, 26, "func(pub crypto.Encapsulator) (PublicKey, error)"},
+ {"NewRecipient", Func, 26, "func(enc []byte, k PrivateKey, kdf KDF, aead AEAD, info []byte) (*Recipient, error)"},
+ {"NewSender", Func, 26, "func(pk PublicKey, kdf KDF, aead AEAD, info []byte) (enc []byte, s *Sender, err error)"},
+ {"Open", Func, 26, "func(k PrivateKey, kdf KDF, aead AEAD, info []byte, ciphertext []byte) ([]byte, error)"},
+ {"Recipient", Type, 26, ""},
+ {"SHAKE128", Func, 26, "func() KDF"},
+ {"SHAKE256", Func, 26, "func() KDF"},
+ {"Seal", Func, 26, "func(pk PublicKey, kdf KDF, aead AEAD, info []byte, plaintext []byte) ([]byte, error)"},
+ {"Sender", Type, 26, ""},
+ },
"crypto/md5": {
{"BlockSize", Const, 0, ""},
{"New", Func, 0, "func() hash.Hash"},
@@ -801,7 +851,7 @@ var PackageSymbols = map[string][]Symbol{
},
"crypto/rand": {
{"Int", Func, 0, "func(rand io.Reader, max *big.Int) (n *big.Int, err error)"},
- {"Prime", Func, 0, "func(rand io.Reader, bits int) (*big.Int, error)"},
+ {"Prime", Func, 0, "func(r io.Reader, bits int) (*big.Int, error)"},
{"Read", Func, 0, "func(b []byte) (n int, err error)"},
{"Reader", Var, 0, ""},
{"Text", Func, 24, "func() string"},
@@ -865,7 +915,7 @@ var PackageSymbols = map[string][]Symbol{
{"PublicKey.E", Field, 0, ""},
{"PublicKey.N", Field, 0, ""},
{"SignPKCS1v15", Func, 0, "func(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)"},
- {"SignPSS", Func, 2, "func(rand io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error)"},
+ {"SignPSS", Func, 2, "func(random io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error)"},
{"VerifyPKCS1v15", Func, 0, "func(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error"},
{"VerifyPSS", Func, 2, "func(pub *PublicKey, hash crypto.Hash, digest []byte, sig []byte, opts *PSSOptions) error"},
},
@@ -1158,6 +1208,8 @@ var PackageSymbols = map[string][]Symbol{
{"RequestClientCert", Const, 0, ""},
{"RequireAndVerifyClientCert", Const, 0, ""},
{"RequireAnyClientCert", Const, 0, ""},
+ {"SecP256r1MLKEM768", Const, 26, ""},
+ {"SecP384r1MLKEM1024", Const, 26, ""},
{"Server", Func, 0, "func(conn net.Conn, config *Config) *Conn"},
{"SessionState", Type, 21, ""},
{"SessionState.EarlyData", Field, 21, ""},
@@ -1222,6 +1274,7 @@ var PackageSymbols = map[string][]Symbol{
{"(*RevocationList).CheckSignatureFrom", Method, 19, ""},
{"(CertificateInvalidError).Error", Method, 0, ""},
{"(ConstraintViolationError).Error", Method, 0, ""},
+ {"(ExtKeyUsage).OID", Method, 26, ""},
{"(ExtKeyUsage).String", Method, 26, ""},
{"(HostnameError).Error", Method, 0, ""},
{"(InsecureAlgorithmError).Error", Method, 6, ""},
@@ -1380,6 +1433,7 @@ var PackageSymbols = map[string][]Symbol{
{"NoValidChains", Const, 24, ""},
{"NotAuthorizedToSign", Const, 0, ""},
{"OID", Type, 22, ""},
+ {"OIDFromASN1OID", Func, 26, "func(asn1OID asn1.ObjectIdentifier) (OID, error)"},
{"OIDFromInts", Func, 22, "func(oid []uint64) (OID, error)"},
{"PEMCipher", Type, 1, ""},
{"PEMCipher3DES", Const, 1, ""},
@@ -1690,10 +1744,6 @@ var PackageSymbols = map[string][]Symbol{
{"(Rows).Next", Method, 0, ""},
{"(RowsAffected).LastInsertId", Method, 0, ""},
{"(RowsAffected).RowsAffected", Method, 0, ""},
- {"(RowsColumnScanner).Close", Method, 26, ""},
- {"(RowsColumnScanner).Columns", Method, 26, ""},
- {"(RowsColumnScanner).Next", Method, 26, ""},
- {"(RowsColumnScanner).ScanColumn", Method, 26, ""},
{"(RowsColumnTypeDatabaseTypeName).Close", Method, 8, ""},
{"(RowsColumnTypeDatabaseTypeName).ColumnTypeDatabaseTypeName", Method, 8, ""},
{"(RowsColumnTypeDatabaseTypeName).Columns", Method, 8, ""},
@@ -1765,7 +1815,6 @@ var PackageSymbols = map[string][]Symbol{
{"ResultNoRows", Var, 0, ""},
{"Rows", Type, 0, ""},
{"RowsAffected", Type, 0, ""},
- {"RowsColumnScanner", Type, 26, ""},
{"RowsColumnTypeDatabaseTypeName", Type, 8, ""},
{"RowsColumnTypeLength", Type, 8, ""},
{"RowsColumnTypeNullable", Type, 8, ""},
@@ -17367,6 +17416,9 @@ var PackageSymbols = map[string][]Symbol{
{"Testing", Func, 21, "func() bool"},
{"Verbose", Func, 1, "func() bool"},
},
+ "testing/cryptotest": {
+ {"SetGlobalRandom", Func, 26, "func(t *testing.T, seed uint64)"},
+ },
"testing/fstest": {
{"(MapFS).Glob", Method, 16, ""},
{"(MapFS).Lstat", Method, 25, ""},
diff --git a/vendor/golang.org/x/tools/internal/typeparams/coretype.go b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
index 27a2b179..2e05de46 100644
--- a/vendor/golang.org/x/tools/internal/typeparams/coretype.go
+++ b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
@@ -11,7 +11,9 @@ import (
// CoreType returns the core type of T or nil if T does not have a core type.
//
-// See https://go.dev/ref/spec#Core_types for the definition of a core type.
+// As of Go1.25, the notion of a core type has been removed from the language spec.
+// See https://go.dev/blog/coretypes for more details.
+// TODO(mkalil): We should eventually consider removing all uses of CoreType.
func CoreType(T types.Type) types.Type {
U := T.Underlying()
if _, ok := U.(*types.Interface); !ok {
@@ -34,7 +36,7 @@ func CoreType(T types.Type) types.Type {
}
if identical == len(terms) {
- // https://go.dev/ref/spec#Core_types
+ // From the deprecated core types spec:
// "There is a single type U which is the underlying type of all types in the type set of T"
return U
}
@@ -42,7 +44,7 @@ func CoreType(T types.Type) types.Type {
if !ok {
return nil // no core type as identical < len(terms) and U is not a channel.
}
- // https://go.dev/ref/spec#Core_types
+ // From the deprecated core types spec:
// "the type chan E if T contains only bidirectional channels, or the type chan<- E or
// <-chan E depending on the direction of the directional channels present."
for chans := identical; chans < len(terms); chans++ {
diff --git a/vendor/golang.org/x/tools/internal/typeparams/free.go b/vendor/golang.org/x/tools/internal/typeparams/free.go
index 709d2fc1..4c391876 100644
--- a/vendor/golang.org/x/tools/internal/typeparams/free.go
+++ b/vendor/golang.org/x/tools/internal/typeparams/free.go
@@ -6,8 +6,6 @@ package typeparams
import (
"go/types"
-
- "golang.org/x/tools/internal/aliases"
)
// Free is a memoization of the set of free type parameters within a
@@ -38,7 +36,7 @@ func (w *Free) Has(typ types.Type) (res bool) {
break
case *types.Alias:
- if aliases.TypeParams(t).Len() > aliases.TypeArgs(t).Len() {
+ if t.TypeParams().Len() > t.TypeArgs().Len() {
return true // This is an uninstantiated Alias.
}
// The expansion of an alias can have free type parameters,
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/typeindex/typeindex.go b/vendor/golang.org/x/tools/internal/typesinternal/typeindex/typeindex.go
index 01ad7b9c..222ada55 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/typeindex/typeindex.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/typeindex/typeindex.go
@@ -217,7 +217,7 @@ func (ix *Index) Selection(path, typename, name string) types.Object {
func (ix *Index) Calls(callee types.Object) iter.Seq[inspector.Cursor] {
return func(yield func(inspector.Cursor) bool) {
for cur := range ix.Uses(callee) {
- ek, _ := cur.ParentEdge()
+ ek := cur.ParentEdgeKind()
// The call may be of the form f() or x.f(),
// optionally with parens; ascend from f to call.
@@ -231,19 +231,19 @@ func (ix *Index) Calls(callee types.Object) iter.Seq[inspector.Cursor] {
// inverse unparen: f -> (f)
for ek == edge.ParenExpr_X {
cur = cur.Parent()
- ek, _ = cur.ParentEdge()
+ ek = cur.ParentEdgeKind()
}
// ascend selector: f -> x.f
if ek == edge.SelectorExpr_Sel {
cur = cur.Parent()
- ek, _ = cur.ParentEdge()
+ ek = cur.ParentEdgeKind()
}
// inverse unparen again
for ek == edge.ParenExpr_X {
cur = cur.Parent()
- ek, _ = cur.ParentEdge()
+ ek = cur.ParentEdgeKind()
}
// ascend from f or x.f to call
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/types.go b/vendor/golang.org/x/tools/internal/typesinternal/types.go
index 51001666..6582cc81 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/types.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/types.go
@@ -25,7 +25,6 @@ import (
"reflect"
"golang.org/x/tools/go/ast/inspector"
- "golang.org/x/tools/internal/aliases"
)
func SetUsesCgo(conf *types.Config) bool {
@@ -142,7 +141,7 @@ var (
func Origin(t NamedOrAlias) NamedOrAlias {
switch t := t.(type) {
case *types.Alias:
- return aliases.Origin(t)
+ return t.Origin()
case *types.Named:
return t.Origin()
}
@@ -195,3 +194,51 @@ func Imports(pkg *types.Package, path string) bool {
}
return false
}
+
+// ObjectKind returns a description of the object's kind.
+//
+// from objectKind in go/types
+func ObjectKind(obj types.Object) string {
+ switch obj := obj.(type) {
+ case *types.PkgName:
+ return "package name"
+ case *types.Const:
+ return "constant"
+ case *types.TypeName:
+ if obj.IsAlias() {
+ return "type alias"
+ } else if _, ok := obj.Type().(*types.TypeParam); ok {
+ return "type parameter"
+ } else {
+ return "defined type"
+ }
+ case *types.Var:
+ switch obj.Kind() {
+ case PackageVar:
+ return "package-level variable"
+ case LocalVar:
+ return "local variable"
+ case RecvVar:
+ return "receiver"
+ case ParamVar:
+ return "parameter"
+ case ResultVar:
+ return "result variable"
+ case FieldVar:
+ return "struct field"
+ }
+ case *types.Func:
+ if obj.Signature().Recv() != nil {
+ return "method"
+ } else {
+ return "function"
+ }
+ case *types.Label:
+ return "label"
+ case *types.Builtin:
+ return "built-in function"
+ case *types.Nil:
+ return "untyped nil"
+ }
+ return "unknown symbol"
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/features.go b/vendor/golang.org/x/tools/internal/versions/features.go
index cdd36c38..360a5b55 100644
--- a/vendor/golang.org/x/tools/internal/versions/features.go
+++ b/vendor/golang.org/x/tools/internal/versions/features.go
@@ -19,6 +19,7 @@ const (
Go1_24 = "go1.24"
Go1_25 = "go1.25"
Go1_26 = "go1.26"
+ Go1_27 = "go1.27"
)
// Future is an invalid unknown Go version sometime in the future.
diff --git a/vendor/golang.org/x/tools/refactor/satisfy/find.go b/vendor/golang.org/x/tools/refactor/satisfy/find.go
index bb383755..3d21ce6d 100644
--- a/vendor/golang.org/x/tools/refactor/satisfy/find.go
+++ b/vendor/golang.org/x/tools/refactor/satisfy/find.go
@@ -395,8 +395,11 @@ func (f *Finder) expr(e ast.Expr) types.Type {
f.expr(e.X)
case *ast.SelectorExpr:
- if _, ok := f.info.Selections[e]; ok {
- f.expr(e.X) // selection
+ if seln, ok := f.info.Selections[e]; ok {
+ // If e.X is a type (e.g., e is interface{ m() }.m), don't visit it.
+ if seln.Kind() != types.MethodExpr {
+ f.expr(e.X)
+ }
} else {
return f.info.Uses[e.Sel].Type() // qualified identifier
}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 446f3f82..898296ac 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -40,7 +40,7 @@ github.com/GaijinEntertainment/go-exhaustruct/v3/analyzer
github.com/GaijinEntertainment/go-exhaustruct/v3/internal/comment
github.com/GaijinEntertainment/go-exhaustruct/v3/internal/pattern
github.com/GaijinEntertainment/go-exhaustruct/v3/internal/structure
-# github.com/Masterminds/semver/v3 v3.3.0
+# github.com/Masterminds/semver/v3 v3.4.0
## explicit; go 1.21
github.com/Masterminds/semver/v3
# github.com/NVIDIA/go-nvlib v0.10.0
@@ -452,8 +452,8 @@ github.com/google/go-cmp/cmp/internal/value
## explicit; go 1.12
github.com/google/gofuzz
github.com/google/gofuzz/bytesource
-# github.com/google/pprof v0.0.0-20241210010833-40e02aabc2ad
-## explicit; go 1.22
+# github.com/google/pprof v0.0.0-20260402051712-545e8a4df936
+## explicit; go 1.24.0
github.com/google/pprof/profile
# github.com/google/uuid v1.6.0
## explicit
@@ -663,12 +663,13 @@ github.com/nunnatsa/ginkgolinter/version
# github.com/olekukonko/tablewriter v0.0.5
## explicit; go 1.12
github.com/olekukonko/tablewriter
-# github.com/onsi/ginkgo/v2 v2.22.2
-## explicit; go 1.22.0
+# github.com/onsi/ginkgo/v2 v2.28.3
+## explicit; go 1.25.0
github.com/onsi/ginkgo/v2
github.com/onsi/ginkgo/v2/config
github.com/onsi/ginkgo/v2/formatter
github.com/onsi/ginkgo/v2/ginkgo
+github.com/onsi/ginkgo/v2/ginkgo/automaxprocs
github.com/onsi/ginkgo/v2/ginkgo/build
github.com/onsi/ginkgo/v2/ginkgo/command
github.com/onsi/ginkgo/v2/ginkgo/generators
@@ -682,11 +683,12 @@ github.com/onsi/ginkgo/v2/internal
github.com/onsi/ginkgo/v2/internal/global
github.com/onsi/ginkgo/v2/internal/interrupt_handler
github.com/onsi/ginkgo/v2/internal/parallel_support
+github.com/onsi/ginkgo/v2/internal/reporters
github.com/onsi/ginkgo/v2/internal/testingtproxy
github.com/onsi/ginkgo/v2/reporters
github.com/onsi/ginkgo/v2/types
-# github.com/onsi/gomega v1.36.2
-## explicit; go 1.22.0
+# github.com/onsi/gomega v1.40.0
+## explicit; go 1.24.0
github.com/onsi/gomega
github.com/onsi/gomega/format
github.com/onsi/gomega/internal
@@ -963,17 +965,20 @@ go.uber.org/zap/internal/bufferpool
go.uber.org/zap/internal/color
go.uber.org/zap/internal/exit
go.uber.org/zap/zapcore
+# go.yaml.in/yaml/v3 v3.0.4
+## explicit; go 1.16
+go.yaml.in/yaml/v3
# golang.org/x/exp/typeparams v0.0.0-20250210185358-939b2ce775ac
## explicit; go 1.18
golang.org/x/exp/typeparams
-# golang.org/x/mod v0.31.0
-## explicit; go 1.24.0
+# golang.org/x/mod v0.35.0
+## explicit; go 1.25.0
golang.org/x/mod/internal/lazyregexp
golang.org/x/mod/modfile
golang.org/x/mod/module
golang.org/x/mod/semver
-# golang.org/x/net v0.49.0
-## explicit; go 1.24.0
+# golang.org/x/net v0.53.0
+## explicit; go 1.25.0
golang.org/x/net/html
golang.org/x/net/html/atom
golang.org/x/net/html/charset
@@ -982,26 +987,27 @@ golang.org/x/net/http2
golang.org/x/net/http2/hpack
golang.org/x/net/idna
golang.org/x/net/internal/httpcommon
+golang.org/x/net/internal/httpsfv
golang.org/x/net/internal/timeseries
golang.org/x/net/trace
# golang.org/x/oauth2 v0.34.0
## explicit; go 1.24.0
golang.org/x/oauth2
golang.org/x/oauth2/internal
-# golang.org/x/sync v0.19.0
-## explicit; go 1.24.0
+# golang.org/x/sync v0.20.0
+## explicit; go 1.25.0
golang.org/x/sync/errgroup
golang.org/x/sync/semaphore
-# golang.org/x/sys v0.40.0
-## explicit; go 1.24.0
+# golang.org/x/sys v0.43.0
+## explicit; go 1.25.0
golang.org/x/sys/plan9
golang.org/x/sys/unix
golang.org/x/sys/windows
-# golang.org/x/term v0.39.0
-## explicit; go 1.24.0
+# golang.org/x/term v0.42.0
+## explicit; go 1.25.0
golang.org/x/term
-# golang.org/x/text v0.33.0
-## explicit; go 1.24.0
+# golang.org/x/text v0.36.0
+## explicit; go 1.25.0
golang.org/x/text/encoding
golang.org/x/text/encoding/charmap
golang.org/x/text/encoding/htmlindex
@@ -1034,8 +1040,8 @@ golang.org/x/text/width
# golang.org/x/time v0.10.0
## explicit; go 1.18
golang.org/x/time/rate
-# golang.org/x/tools v0.40.0
-## explicit; go 1.24.0
+# golang.org/x/tools v0.44.0
+## explicit; go 1.25.0
golang.org/x/tools/cover
golang.org/x/tools/go/analysis
golang.org/x/tools/go/analysis/passes/appends
@@ -1060,7 +1066,6 @@ golang.org/x/tools/go/analysis/passes/framepointer
golang.org/x/tools/go/analysis/passes/httpresponse
golang.org/x/tools/go/analysis/passes/ifaceassert
golang.org/x/tools/go/analysis/passes/inspect
-golang.org/x/tools/go/analysis/passes/internal/ctrlflowinternal
golang.org/x/tools/go/analysis/passes/loopclosure
golang.org/x/tools/go/analysis/passes/lostcancel
golang.org/x/tools/go/analysis/passes/nilfunc
@@ -1104,7 +1109,6 @@ golang.org/x/tools/internal/aliases
golang.org/x/tools/internal/analysis/analyzerutil
golang.org/x/tools/internal/analysis/typeindex
golang.org/x/tools/internal/astutil
-golang.org/x/tools/internal/cfginternal
golang.org/x/tools/internal/event
golang.org/x/tools/internal/event/core
golang.org/x/tools/internal/event/keys
@@ -1114,13 +1118,11 @@ golang.org/x/tools/internal/gcimporter
golang.org/x/tools/internal/gocommand
golang.org/x/tools/internal/gopathwalk
golang.org/x/tools/internal/imports
-golang.org/x/tools/internal/modindex
golang.org/x/tools/internal/moreiters
golang.org/x/tools/internal/packagepath
golang.org/x/tools/internal/packagesinternal
golang.org/x/tools/internal/pkgbits
golang.org/x/tools/internal/refactor
-golang.org/x/tools/internal/ssainternal
golang.org/x/tools/internal/stdlib
golang.org/x/tools/internal/typeparams
golang.org/x/tools/internal/typesinternal
+
+