all: update vendored golang.org/x/tools

Pull in CL 593297:

	f2d2ebe4 go/analysis/passes/buildtag: retire Go 1.15 support

Along with other changes that have landed into x/tools.
This fixes a vet failure reported on longtest builders.

For #66092.

Change-Id: I549cc3f8e2c2033fe961bf014ff8cc1998021538
Cq-Include-Trybots: luci.golang.try:gotip-linux-amd64-longtest
Reviewed-on: https://go-review.googlesource.com/c/go/+/593376
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
TryBot-Bypass: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Auto-Submit: Dmitri Shuralyov <dmitshur@golang.org>

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index e9e742d7e3a903733c6639825f984b2f271bc088..559ffd1ccdc5b5d78f95cf78c1ab70a1a0f5a8ce 100644 (file)
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -11,7 +11,7 @@ require (
        golang.org/x/sys v0.21.0
        golang.org/x/telemetry v0.0.0-20240612191826-8cad58b3fcbb
        golang.org/x/term v0.20.0
-       golang.org/x/tools v0.21.1-0.20240604144337-208808308b70
+       golang.org/x/tools v0.22.1-0.20240618181713-f2d2ebe43e72
 )
 
 require (

diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index e6f1abd80ffd979c5f24c38a0be15630e8dd688e..8f9517bc624754d183b8a1293a92940dada732c1 100644 (file)
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -22,7 +22,7 @@ golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
 golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/tools v0.21.1-0.20240604144337-208808308b70 h1:UmSJS6pdDoRwdDCbOwHnsOCHhVUhmdhF0m1Cfb82ts8=
-golang.org/x/tools v0.21.1-0.20240604144337-208808308b70/go.mod h1:bqv7PJ/TtlrzgJKhOAGdDUkUltQapRik/UEHubLVBWo=
+golang.org/x/tools v0.22.1-0.20240618181713-f2d2ebe43e72 h1:YEy0SBExcUlHkZSzP6yv3BTwAUH6FK1XWDyC27AE+0I=
+golang.org/x/tools v0.22.1-0.20240618181713-f2d2ebe43e72/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c=
 rsc.io/markdown v0.0.0-20240306144322-0bf8f97ee8ef h1:mqLYrXCXYEZOop9/Dbo6RPX11539nwiCNBb1icVPmw8=
 rsc.io/markdown v0.0.0-20240306144322-0bf8f97ee8ef/go.mod h1:8xcPgWmwlZONN1D9bjxtHEjrUtSEa3fakVF8iaewYKQ=

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go
index 4eb90599808e67fc245e6675fe978832b9bea2a8..ee083a2d686723b887413e3bab1f17c28365562b 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/diagnostic.go
@@ -33,8 +33,17 @@ type Diagnostic struct {
        URL string
 
        // SuggestedFixes is an optional list of fixes to address the
-       // problem described by the diagnostic, each one representing
+       // problem described by the diagnostic. Each one represents
        // an alternative strategy; at most one may be applied.
+       //
+       // Fixes for different diagnostics should be treated as
+       // independent changes to the same baseline file state,
+       // analogous to a set of git commits all with the same parent.
+       // Combining fixes requires resolving any conflicts that
+       // arise, analogous to a git merge.
+       // Any conflicts that remain may be dealt with, depending on
+       // the tool, by discarding fixes, consulting the user, or
+       // aborting the operation.
        SuggestedFixes []SuggestedFix
 
        // Related contains optional secondary positions and messages
@@ -58,8 +67,10 @@ type RelatedInformation struct {
 //
 // The TextEdits must not overlap, nor contain edits for other packages.
 type SuggestedFix struct {
-       // A description for this suggested fix to be shown to a user deciding
-       // whether to accept it.
+       // A verb phrase describing the fix, to be shown to
+       // a user trying to decide whether to accept it.
+       //
+       // Example: "Remove the surplus argument"
        Message   string
        TextEdits []TextEdit
 }

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
index 51ba2a91e5b94d2cbf570296ffd0139cd7416fbb..5b4cf9d9edcdd4d831075ab9ba2ab6a323374977 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag.go
@@ -2,9 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build go1.16
-// +build go1.16
-
 // Package buildtag defines an Analyzer that checks build tags.
 package buildtag
 

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag_old.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag_old.go
deleted file mode 100644 (file)
index 19ef6b9..0000000
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/buildtag/buildtag_old.go
+++ /dev/null
@@ -1,174 +0,0 @@
-// Copyright 2013 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.
-
-// TODO(rsc): Delete this file once Go 1.17 comes out and we can retire Go 1.15 support.
-
-//go:build !go1.16
-// +build !go1.16
-
-// Package buildtag defines an Analyzer that checks build tags.
-package buildtag
-
-import (
-       "bytes"
-       "fmt"
-       "go/ast"
-       "go/parser"
-       "strings"
-       "unicode"
-
-       "golang.org/x/tools/go/analysis"
-       "golang.org/x/tools/go/analysis/passes/internal/analysisutil"
-)
-
-const Doc = "check // +build directives"
-
-var Analyzer = &analysis.Analyzer{
-       Name: "buildtag",
-       Doc:  Doc,
-       Run:  runBuildTag,
-}
-
-func runBuildTag(pass *analysis.Pass) (interface{}, error) {
-       for _, f := range pass.Files {
-               checkGoFile(pass, f)
-       }
-       for _, name := range pass.OtherFiles {
-               if err := checkOtherFile(pass, name); err != nil {
-                       return nil, err
-               }
-       }
-       for _, name := range pass.IgnoredFiles {
-               if strings.HasSuffix(name, ".go") {
-                       f, err := parser.ParseFile(pass.Fset, name, nil, parser.ParseComments)
-                       if err != nil {
-                               // Not valid Go source code - not our job to diagnose, so ignore.
-                               return nil, nil
-                       }
-                       checkGoFile(pass, f)
-               } else {
-                       if err := checkOtherFile(pass, name); err != nil {
-                               return nil, err
-                       }
-               }
-       }
-       return nil, nil
-}
-
-func checkGoFile(pass *analysis.Pass, f *ast.File) {
-       pastCutoff := false
-       for _, group := range f.Comments {
-               // A +build comment is ignored after or adjoining the package declaration.
-               if group.End()+1 >= f.Package {
-                       pastCutoff = true
-               }
-
-               // "+build" is ignored within or after a /*...*/ comment.
-               if !strings.HasPrefix(group.List[0].Text, "//") {
-                       pastCutoff = true
-                       continue
-               }
-
-               // Check each line of a //-comment.
-               for _, c := range group.List {
-                       if !strings.Contains(c.Text, "+build") {
-                               continue
-                       }
-                       if err := checkLine(c.Text, pastCutoff); err != nil {
-                               pass.Reportf(c.Pos(), "%s", err)
-                       }
-               }
-       }
-}
-
-func checkOtherFile(pass *analysis.Pass, filename string) error {
-       content, tf, err := analysisutil.ReadFile(pass, filename)
-       if err != nil {
-               return err
-       }
-
-       // We must look at the raw lines, as build tags may appear in non-Go
-       // files such as assembly files.
-       lines := bytes.SplitAfter(content, nl)
-
-       // Determine cutpoint where +build comments are no longer valid.
-       // They are valid in leading // comments in the file followed by
-       // a blank line.
-       //
-       // This must be done as a separate pass because of the
-       // requirement that the comment be followed by a blank line.
-       var cutoff int
-       for i, line := range lines {
-               line = bytes.TrimSpace(line)
-               if !bytes.HasPrefix(line, slashSlash) {
-                       if len(line) > 0 {
-                               break
-                       }
-                       cutoff = i
-               }
-       }
-
-       for i, line := range lines {
-               line = bytes.TrimSpace(line)
-               if !bytes.HasPrefix(line, slashSlash) {
-                       continue
-               }
-               if !bytes.Contains(line, []byte("+build")) {
-                       continue
-               }
-               if err := checkLine(string(line), i >= cutoff); err != nil {
-                       pass.Reportf(analysisutil.LineStart(tf, i+1), "%s", err)
-                       continue
-               }
-       }
-       return nil
-}
-
-// checkLine checks a line that starts with "//" and contains "+build".
-func checkLine(line string, pastCutoff bool) error {
-       line = strings.TrimPrefix(line, "//")
-       line = strings.TrimSpace(line)
-
-       if strings.HasPrefix(line, "+build") {
-               fields := strings.Fields(line)
-               if fields[0] != "+build" {
-                       // Comment is something like +buildasdf not +build.
-                       return fmt.Errorf("possible malformed +build comment")
-               }
-               if pastCutoff {
-                       return fmt.Errorf("+build comment must appear before package clause and be followed by a blank line")
-               }
-               if err := checkArguments(fields); err != nil {
-                       return err
-               }
-       } else {
-               // Comment with +build but not at beginning.
-               if !pastCutoff {
-                       return fmt.Errorf("possible malformed +build comment")
-               }
-       }
-       return nil
-}
-
-func checkArguments(fields []string) error {
-       for _, arg := range fields[1:] {
-               for _, elem := range strings.Split(arg, ",") {
-                       if strings.HasPrefix(elem, "!!") {
-                               return fmt.Errorf("invalid double negative in build constraint: %s", arg)
-                       }
-                       elem = strings.TrimPrefix(elem, "!")
-                       for _, c := range elem {
-                               if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' {
-                                       return fmt.Errorf("invalid non-alphanumeric build constraint: %s", arg)
-                               }
-                       }
-               }
-       }
-       return nil
-}
-
-var (
-       nl         = []byte("\n")
-       slashSlash = []byte("//")
-)

diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
index c77182daef6633455cf64d27cbe29e59017ebc33..c91f6bc4745f52f855a4ed66ae42ebbe6fb60a04 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
@@ -16,6 +16,7 @@ import (
        "golang.org/x/tools/go/analysis/passes/internal/analysisutil"
        "golang.org/x/tools/go/ast/inspector"
        "golang.org/x/tools/internal/aliases"
+       "golang.org/x/tools/internal/analysisinternal"
        "golang.org/x/tools/internal/typeparams"
 )
 
@@ -73,9 +74,15 @@ func typeName(t types.Type) string {
 func run(pass *analysis.Pass) (interface{}, error) {
        inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
        nodeFilter := []ast.Node{
+               (*ast.File)(nil),
                (*ast.CallExpr)(nil),
        }
+       var file *ast.File
        inspect.Preorder(nodeFilter, func(n ast.Node) {
+               if n, ok := n.(*ast.File); ok {
+                       file = n
+                       return
+               }
                call := n.(*ast.CallExpr)
 
                if len(call.Args) != 1 {
@@ -167,27 +174,74 @@ func run(pass *analysis.Pass) (interface{}, error) {
 
                diag := analysis.Diagnostic{
                        Pos:     n.Pos(),
-                       Message: fmt.Sprintf("conversion from %s to %s yields a string of one rune, not a string of digits (did you mean fmt.Sprint(x)?)", source, target),
+                       Message: fmt.Sprintf("conversion from %s to %s yields a string of one rune, not a string of digits", source, target),
+               }
+               addFix := func(message string, edits []analysis.TextEdit) {
+                       diag.SuggestedFixes = append(diag.SuggestedFixes, analysis.SuggestedFix{
+                               Message:   message,
+                               TextEdits: edits,
+                       })
                }
 
+               // Fix 1: use fmt.Sprint(x)
+               //
+               // Prefer fmt.Sprint over strconv.Itoa, FormatInt,
+               // or FormatUint, as it works for any type.
+               // Add an import of "fmt" as needed.
+               //
+               // Unless the type is exactly string, we must retain the conversion.
+               //
+               // Do not offer this fix if type parameters are involved,
+               // as there are too many combinations and subtleties.
+               // Consider x = rune | int16 | []byte: in all cases,
+               // string(x) is legal, but the appropriate diagnostic
+               // and fix differs. Similarly, don't offer the fix if
+               // the type has methods, as some {String,GoString,Format}
+               // may change the behavior of fmt.Sprint.
+               if len(ttypes) == 1 && len(vtypes) == 1 && types.NewMethodSet(V0).Len() == 0 {
+                       fmtName, importEdit := analysisinternal.AddImport(pass.TypesInfo, file, arg.Pos(), "fmt", "fmt")
+                       if types.Identical(T0, types.Typ[types.String]) {
+                               // string(x) -> fmt.Sprint(x)
+                               addFix("Format the number as a decimal", []analysis.TextEdit{
+                                       importEdit,
+                                       {
+                                               Pos:     call.Fun.Pos(),
+                                               End:     call.Fun.End(),
+                                               NewText: []byte(fmtName + ".Sprint"),
+                                       },
+                               })
+                       } else {
+                               // mystring(x) -> mystring(fmt.Sprint(x))
+                               addFix("Format the number as a decimal", []analysis.TextEdit{
+                                       importEdit,
+                                       {
+                                               Pos:     call.Lparen + 1,
+                                               End:     call.Lparen + 1,
+                                               NewText: []byte(fmtName + ".Sprint("),
+                                       },
+                                       {
+                                               Pos:     call.Rparen,
+                                               End:     call.Rparen,
+                                               NewText: []byte(")"),
+                                       },
+                               })
+                       }
+               }
+
+               // Fix 2: use string(rune(x))
                if convertibleToRune {
-                       diag.SuggestedFixes = []analysis.SuggestedFix{
+                       addFix("Convert a single rune to a string", []analysis.TextEdit{
                                {
-                                       Message: "Did you mean to convert a rune to a string?",
-                                       TextEdits: []analysis.TextEdit{
-                                               {
-                                                       Pos:     arg.Pos(),
-                                                       End:     arg.Pos(),
-                                                       NewText: []byte("rune("),
-                                               },
-                                               {
-                                                       Pos:     arg.End(),
-                                                       End:     arg.End(),
-                                                       NewText: []byte(")"),
-                                               },
-                                       },
+                                       Pos:     arg.Pos(),
+                                       End:     arg.Pos(),
+                                       NewText: []byte("rune("),
                                },
-                       }
+                               {
+                                       Pos:     arg.End(),
+                                       End:     arg.End(),
+                                       NewText: []byte(")"),
+                               },
+                       })
                }
                pass.Report(diag)
        })

diff --git a/src/cmd/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go b/src/cmd/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go
index 9ba3a8efb9eea0654cfa5c60ed297e9f28e4ca20..4000d27d8ee73e6313b1f06f96ad5d46662f0fc7 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go
+++ b/src/cmd/vendor/golang.org/x/tools/internal/analysisinternal/analysis.go
@@ -13,6 +13,7 @@ import (
        "go/token"
        "go/types"
        "os"
+       pathpkg "path"
        "strconv"
 
        "golang.org/x/tools/go/analysis"
@@ -269,6 +270,8 @@ func StmtToInsertVarBefore(path []ast.Node) ast.Stmt {
                if expr.Init == enclosingStmt || expr.Post == enclosingStmt {
                        return expr
                }
+       case *ast.SwitchStmt, *ast.TypeSwitchStmt:
+               return expr.(ast.Stmt)
        }
        return enclosingStmt.(ast.Stmt)
 }
@@ -430,3 +433,81 @@ func slicesContains[S ~[]E, E comparable](slice S, x E) bool {
        }
        return false
 }
+
+// AddImport checks whether this file already imports pkgpath and
+// that import is in scope at pos. If so, it returns the name under
+// which it was imported and a zero edit. Otherwise, it adds a new
+// import of pkgpath, using a name derived from the preferred name,
+// and returns the chosen name along with the edit for the new import.
+//
+// It does not mutate its arguments.
+func AddImport(info *types.Info, file *ast.File, pos token.Pos, pkgpath, preferredName string) (name string, newImport analysis.TextEdit) {
+       // Find innermost enclosing lexical block.
+       scope := info.Scopes[file].Innermost(pos)
+       if scope == nil {
+               panic("no enclosing lexical block")
+       }
+
+       // Is there an existing import of this package?
+       // If so, are we in its scope? (not shadowed)
+       for _, spec := range file.Imports {
+               pkgname, ok := importedPkgName(info, spec)
+               if ok && pkgname.Imported().Path() == pkgpath {
+                       if _, obj := scope.LookupParent(pkgname.Name(), pos); obj == pkgname {
+                               return pkgname.Name(), analysis.TextEdit{}
+                       }
+               }
+       }
+
+       // We must add a new import.
+       // Ensure we have a fresh name.
+       newName := preferredName
+       for i := 0; ; i++ {
+               if _, obj := scope.LookupParent(newName, pos); obj == nil {
+                       break // fresh
+               }
+               newName = fmt.Sprintf("%s%d", preferredName, i)
+       }
+
+       // For now, keep it real simple: create a new import
+       // declaration before the first existing declaration (which
+       // must exist), including its comments, and let goimports tidy it up.
+       //
+       // Use a renaming import whenever the preferred name is not
+       // available, or the chosen name does not match the last
+       // segment of its path.
+       newText := fmt.Sprintf("import %q\n\n", pkgpath)
+       if newName != preferredName || newName != pathpkg.Base(pkgpath) {
+               newText = fmt.Sprintf("import %s %q\n\n", newName, pkgpath)
+       }
+       decl0 := file.Decls[0]
+       var before ast.Node = decl0
+       switch decl0 := decl0.(type) {
+       case *ast.GenDecl:
+               if decl0.Doc != nil {
+                       before = decl0.Doc
+               }
+       case *ast.FuncDecl:
+               if decl0.Doc != nil {
+                       before = decl0.Doc
+               }
+       }
+       return newName, analysis.TextEdit{
+               Pos:     before.Pos(),
+               End:     before.Pos(),
+               NewText: []byte(newText),
+       }
+}
+
+// importedPkgName returns the PkgName object declared by an ImportSpec.
+// TODO(adonovan): use go1.22's Info.PkgNameOf.
+func importedPkgName(info *types.Info, imp *ast.ImportSpec) (*types.PkgName, bool) {
+       var obj types.Object
+       if imp.Name != nil {
+               obj = info.Defs[imp.Name]
+       } else {
+               obj = info.Implicits[imp]
+       }
+       pkgname, ok := obj.(*types.PkgName)
+       return pkgname, ok
+}

diff --git a/src/cmd/vendor/golang.org/x/tools/internal/stdlib/manifest.go b/src/cmd/vendor/golang.org/x/tools/internal/stdlib/manifest.go
index fd6892075ee4bed106b1cdea50607d8e0e5c98c2..a928acf29facfe4415df7b6091e85462337a2b9e 100644 (file)
--- a/src/cmd/vendor/golang.org/x/tools/internal/stdlib/manifest.go
+++ b/src/cmd/vendor/golang.org/x/tools/internal/stdlib/manifest.go
@@ -23,6 +23,7 @@ var PackageSymbols = map[string][]Symbol{
                {"ErrWriteAfterClose", Var, 0},
                {"ErrWriteTooLong", Var, 0},
                {"FileInfoHeader", Func, 1},
+               {"FileInfoNames", Type, 23},
                {"Format", Type, 10},
                {"FormatGNU", Const, 10},
                {"FormatPAX", Const, 10},
@@ -820,6 +821,7 @@ var PackageSymbols = map[string][]Symbol{
                {"(*ConnectionState).ExportKeyingMaterial", Method, 11},
                {"(*Dialer).Dial", Method, 15},
                {"(*Dialer).DialContext", Method, 15},
+               {"(*ECHRejectionError).Error", Method, 23},
                {"(*QUICConn).Close", Method, 21},
                {"(*QUICConn).ConnectionState", Method, 21},
                {"(*QUICConn).HandleData", Method, 21},
@@ -827,6 +829,7 @@ var PackageSymbols = map[string][]Symbol{
                {"(*QUICConn).SendSessionTicket", Method, 21},
                {"(*QUICConn).SetTransportParameters", Method, 21},
                {"(*QUICConn).Start", Method, 21},
+               {"(*QUICConn).StoreSession", Method, 23},
                {"(*SessionState).Bytes", Method, 21},
                {"(AlertError).Error", Method, 21},
                {"(ClientAuthType).String", Method, 15},
@@ -877,6 +880,8 @@ var PackageSymbols = map[string][]Symbol{
                {"Config.ClientSessionCache", Field, 3},
                {"Config.CurvePreferences", Field, 3},
                {"Config.DynamicRecordSizingDisabled", Field, 7},
+               {"Config.EncryptedClientHelloConfigList", Field, 23},
+               {"Config.EncryptedClientHelloRejectionVerify", Field, 23},
                {"Config.GetCertificate", Field, 4},
                {"Config.GetClientCertificate", Field, 8},
                {"Config.GetConfigForClient", Field, 8},
@@ -902,6 +907,7 @@ var PackageSymbols = map[string][]Symbol{
                {"ConnectionState", Type, 0},
                {"ConnectionState.CipherSuite", Field, 0},
                {"ConnectionState.DidResume", Field, 1},
+               {"ConnectionState.ECHAccepted", Field, 23},
                {"ConnectionState.HandshakeComplete", Field, 0},
                {"ConnectionState.NegotiatedProtocol", Field, 0},
                {"ConnectionState.NegotiatedProtocolIsMutual", Field, 0},
@@ -925,6 +931,8 @@ var PackageSymbols = map[string][]Symbol{
                {"ECDSAWithP384AndSHA384", Const, 8},
                {"ECDSAWithP521AndSHA512", Const, 8},
                {"ECDSAWithSHA1", Const, 10},
+               {"ECHRejectionError", Type, 23},
+               {"ECHRejectionError.RetryConfigList", Field, 23},
                {"Ed25519", Const, 13},
                {"InsecureCipherSuites", Func, 14},
                {"Listen", Func, 0},
@@ -943,6 +951,7 @@ var PackageSymbols = map[string][]Symbol{
                {"ParseSessionState", Func, 21},
                {"QUICClient", Func, 21},
                {"QUICConfig", Type, 21},
+               {"QUICConfig.EnableStoreSessionEvent", Field, 23},
                {"QUICConfig.TLSConfig", Field, 21},
                {"QUICConn", Type, 21},
                {"QUICEncryptionLevel", Type, 21},
@@ -954,16 +963,20 @@ var PackageSymbols = map[string][]Symbol{
                {"QUICEvent.Data", Field, 21},
                {"QUICEvent.Kind", Field, 21},
                {"QUICEvent.Level", Field, 21},
+               {"QUICEvent.SessionState", Field, 23},
                {"QUICEvent.Suite", Field, 21},
                {"QUICEventKind", Type, 21},
                {"QUICHandshakeDone", Const, 21},
                {"QUICNoEvent", Const, 21},
                {"QUICRejectedEarlyData", Const, 21},
+               {"QUICResumeSession", Const, 23},
                {"QUICServer", Func, 21},
                {"QUICSessionTicketOptions", Type, 21},
                {"QUICSessionTicketOptions.EarlyData", Field, 21},
+               {"QUICSessionTicketOptions.Extra", Field, 23},
                {"QUICSetReadSecret", Const, 21},
                {"QUICSetWriteSecret", Const, 21},
+               {"QUICStoreSession", Const, 23},
                {"QUICTransportParameters", Const, 21},
                {"QUICTransportParametersRequired", Const, 21},
                {"QUICWriteData", Const, 21},
@@ -1036,6 +1049,8 @@ var PackageSymbols = map[string][]Symbol{
                {"(*Certificate).Verify", Method, 0},
                {"(*Certificate).VerifyHostname", Method, 0},
                {"(*CertificateRequest).CheckSignature", Method, 5},
+               {"(*OID).UnmarshalBinary", Method, 23},
+               {"(*OID).UnmarshalText", Method, 23},
                {"(*RevocationList).CheckSignatureFrom", Method, 19},
                {"(CertificateInvalidError).Error", Method, 0},
                {"(ConstraintViolationError).Error", Method, 0},
@@ -1043,6 +1058,8 @@ var PackageSymbols = map[string][]Symbol{
                {"(InsecureAlgorithmError).Error", Method, 6},
                {"(OID).Equal", Method, 22},
                {"(OID).EqualASN1OID", Method, 22},
+               {"(OID).MarshalBinary", Method, 23},
+               {"(OID).MarshalText", Method, 23},
                {"(OID).String", Method, 22},
                {"(PublicKeyAlgorithm).String", Method, 10},
                {"(SignatureAlgorithm).String", Method, 6},
@@ -1196,6 +1213,7 @@ var PackageSymbols = map[string][]Symbol{
                {"ParseCertificates", Func, 0},
                {"ParseDERCRL", Func, 0},
                {"ParseECPrivateKey", Func, 1},
+               {"ParseOID", Func, 23},
                {"ParsePKCS1PrivateKey", Func, 0},
                {"ParsePKCS1PublicKey", Func, 10},
                {"ParsePKCS8PrivateKey", Func, 0},
@@ -2541,6 +2559,7 @@ var PackageSymbols = map[string][]Symbol{
                {"PT_NOTE", Const, 0},
                {"PT_NULL", Const, 0},
                {"PT_OPENBSD_BOOTDATA", Const, 16},
+               {"PT_OPENBSD_NOBTCFI", Const, 23},
                {"PT_OPENBSD_RANDOMIZE", Const, 16},
                {"PT_OPENBSD_WXNEEDED", Const, 16},
                {"PT_PAX_FLAGS", Const, 16},
@@ -3620,13 +3639,16 @@ var PackageSymbols = map[string][]Symbol{
                {"STT_COMMON", Const, 0},
                {"STT_FILE", Const, 0},
                {"STT_FUNC", Const, 0},
+               {"STT_GNU_IFUNC", Const, 23},
                {"STT_HIOS", Const, 0},
                {"STT_HIPROC", Const, 0},
                {"STT_LOOS", Const, 0},
                {"STT_LOPROC", Const, 0},
                {"STT_NOTYPE", Const, 0},
                {"STT_OBJECT", Const, 0},
+               {"STT_RELC", Const, 23},
                {"STT_SECTION", Const, 0},
+               {"STT_SRELC", Const, 23},
                {"STT_TLS", Const, 0},
                {"STV_DEFAULT", Const, 0},
                {"STV_HIDDEN", Const, 0},
@@ -4544,11 +4566,14 @@ var PackageSymbols = map[string][]Symbol{
                {"URLEncoding", Var, 0},
        },
        "encoding/binary": {
+               {"Append", Func, 23},
                {"AppendByteOrder", Type, 19},
                {"AppendUvarint", Func, 19},
                {"AppendVarint", Func, 19},
                {"BigEndian", Var, 0},
                {"ByteOrder", Type, 0},
+               {"Decode", Func, 23},
+               {"Encode", Func, 23},
                {"LittleEndian", Var, 0},
                {"MaxVarintLen16", Const, 0},
                {"MaxVarintLen32", Const, 0},
@@ -5308,6 +5333,7 @@ var PackageSymbols = map[string][]Symbol{
                {"ParenExpr.Rparen", Field, 0},
                {"ParenExpr.X", Field, 0},
                {"Pkg", Const, 0},
+               {"Preorder", Func, 23},
                {"Print", Func, 0},
                {"RECV", Const, 0},
                {"RangeStmt", Type, 0},
@@ -5898,7 +5924,12 @@ var PackageSymbols = map[string][]Symbol{
        },
        "go/types": {
                {"(*Alias).Obj", Method, 22},
+               {"(*Alias).Origin", Method, 23},
+               {"(*Alias).Rhs", Method, 23},
+               {"(*Alias).SetTypeParams", Method, 23},
                {"(*Alias).String", Method, 22},
+               {"(*Alias).TypeArgs", Method, 23},
+               {"(*Alias).TypeParams", Method, 23},
                {"(*Alias).Underlying", Method, 22},
                {"(*ArgumentError).Error", Method, 18},
                {"(*ArgumentError).Unwrap", Method, 18},
@@ -5943,6 +5974,7 @@ var PackageSymbols = map[string][]Symbol{
                {"(*Func).Pkg", Method, 5},
                {"(*Func).Pos", Method, 5},
                {"(*Func).Scope", Method, 5},
+               {"(*Func).Signature", Method, 23},
                {"(*Func).String", Method, 5},
                {"(*Func).Type", Method, 5},
                {"(*Info).ObjectOf", Method, 5},
@@ -6992,6 +7024,12 @@ var PackageSymbols = map[string][]Symbol{
                {"TempFile", Func, 0},
                {"WriteFile", Func, 0},
        },
+       "iter": {
+               {"Pull", Func, 23},
+               {"Pull2", Func, 23},
+               {"Seq", Type, 23},
+               {"Seq2", Type, 23},
+       },
        "log": {
                {"(*Logger).Fatal", Method, 0},
                {"(*Logger).Fatalf", Method, 0},
@@ -7222,11 +7260,16 @@ var PackageSymbols = map[string][]Symbol{
                {"Writer", Type, 0},
        },
        "maps": {
+               {"All", Func, 23},
                {"Clone", Func, 21},
+               {"Collect", Func, 23},
                {"Copy", Func, 21},
                {"DeleteFunc", Func, 21},
                {"Equal", Func, 21},
                {"EqualFunc", Func, 21},
+               {"Insert", Func, 23},
+               {"Keys", Func, 23},
+               {"Values", Func, 23},
        },
        "math": {
                {"Abs", Func, 0},
@@ -7617,6 +7660,7 @@ var PackageSymbols = map[string][]Symbol{
        },
        "math/rand/v2": {
                {"(*ChaCha8).MarshalBinary", Method, 22},
+               {"(*ChaCha8).Read", Method, 23},
                {"(*ChaCha8).Seed", Method, 22},
                {"(*ChaCha8).Uint64", Method, 22},
                {"(*ChaCha8).UnmarshalBinary", Method, 22},
@@ -7636,6 +7680,7 @@ var PackageSymbols = map[string][]Symbol{
                {"(*Rand).NormFloat64", Method, 22},
                {"(*Rand).Perm", Method, 22},
                {"(*Rand).Shuffle", Method, 22},
+               {"(*Rand).Uint", Method, 23},
                {"(*Rand).Uint32", Method, 22},
                {"(*Rand).Uint32N", Method, 22},
                {"(*Rand).Uint64", Method, 22},
@@ -7663,6 +7708,7 @@ var PackageSymbols = map[string][]Symbol{
                {"Rand", Type, 22},
                {"Shuffle", Func, 22},
                {"Source", Type, 22},
+               {"Uint", Func, 23},
                {"Uint32", Func, 22},
                {"Uint32N", Func, 22},
                {"Uint64", Func, 22},
@@ -7743,6 +7789,7 @@ var PackageSymbols = map[string][]Symbol{
                {"(*DNSError).Error", Method, 0},
                {"(*DNSError).Temporary", Method, 0},
                {"(*DNSError).Timeout", Method, 0},
+               {"(*DNSError).Unwrap", Method, 23},
                {"(*Dialer).Dial", Method, 1},
                {"(*Dialer).DialContext", Method, 7},
                {"(*Dialer).MultipathTCP", Method, 21},
@@ -7809,6 +7856,7 @@ var PackageSymbols = map[string][]Symbol{
                {"(*TCPConn).RemoteAddr", Method, 0},
                {"(*TCPConn).SetDeadline", Method, 0},
                {"(*TCPConn).SetKeepAlive", Method, 0},
+               {"(*TCPConn).SetKeepAliveConfig", Method, 23},
                {"(*TCPConn).SetKeepAlivePeriod", Method, 2},
                {"(*TCPConn).SetLinger", Method, 0},
                {"(*TCPConn).SetNoDelay", Method, 0},
@@ -7922,6 +7970,7 @@ var PackageSymbols = map[string][]Symbol{
                {"DNSError.IsTimeout", Field, 0},
                {"DNSError.Name", Field, 0},
                {"DNSError.Server", Field, 0},
+               {"DNSError.UnwrapErr", Field, 23},
                {"DefaultResolver", Var, 8},
                {"Dial", Func, 0},
                {"DialIP", Func, 0},
@@ -7937,6 +7986,7 @@ var PackageSymbols = map[string][]Symbol{
                {"Dialer.DualStack", Field, 2},
                {"Dialer.FallbackDelay", Field, 5},
                {"Dialer.KeepAlive", Field, 3},
+               {"Dialer.KeepAliveConfig", Field, 23},
                {"Dialer.LocalAddr", Field, 1},
                {"Dialer.Resolver", Field, 8},
                {"Dialer.Timeout", Field, 1},
@@ -7989,10 +8039,16 @@ var PackageSymbols = map[string][]Symbol{
                {"Interfaces", Func, 0},
                {"InvalidAddrError", Type, 0},
                {"JoinHostPort", Func, 0},
+               {"KeepAliveConfig", Type, 23},
+               {"KeepAliveConfig.Count", Field, 23},
+               {"KeepAliveConfig.Enable", Field, 23},
+               {"KeepAliveConfig.Idle", Field, 23},
+               {"KeepAliveConfig.Interval", Field, 23},
                {"Listen", Func, 0},
                {"ListenConfig", Type, 11},
                {"ListenConfig.Control", Field, 11},
                {"ListenConfig.KeepAlive", Field, 13},
+               {"ListenConfig.KeepAliveConfig", Field, 23},
                {"ListenIP", Func, 0},
                {"ListenMulticastUDP", Func, 0},
                {"ListenPacket", Func, 0},
@@ -8081,6 +8137,7 @@ var PackageSymbols = map[string][]Symbol{
                {"(*Request).Context", Method, 7},
                {"(*Request).Cookie", Method, 0},
                {"(*Request).Cookies", Method, 0},
+               {"(*Request).CookiesNamed", Method, 23},
                {"(*Request).FormFile", Method, 0},
                {"(*Request).FormValue", Method, 0},
                {"(*Request).MultipartReader", Method, 0},
@@ -8148,7 +8205,9 @@ var PackageSymbols = map[string][]Symbol{
                {"Cookie.HttpOnly", Field, 0},
                {"Cookie.MaxAge", Field, 0},
                {"Cookie.Name", Field, 0},
+               {"Cookie.Partitioned", Field, 23},
                {"Cookie.Path", Field, 0},
+               {"Cookie.Quoted", Field, 23},
                {"Cookie.Raw", Field, 0},
                {"Cookie.RawExpires", Field, 0},
                {"Cookie.SameSite", Field, 11},
@@ -8225,7 +8284,9 @@ var PackageSymbols = map[string][]Symbol{
                {"NoBody", Var, 8},
                {"NotFound", Func, 0},
                {"NotFoundHandler", Func, 0},
+               {"ParseCookie", Func, 23},
                {"ParseHTTPVersion", Func, 0},
+               {"ParseSetCookie", Func, 23},
                {"ParseTime", Func, 1},
                {"Post", Func, 0},
                {"PostForm", Func, 0},
@@ -8252,6 +8313,7 @@ var PackageSymbols = map[string][]Symbol{
                {"Request.Host", Field, 0},
                {"Request.Method", Field, 0},
                {"Request.MultipartForm", Field, 0},
+               {"Request.Pattern", Field, 23},
                {"Request.PostForm", Field, 1},
                {"Request.Proto", Field, 0},
                {"Request.ProtoMajor", Field, 0},
@@ -8453,6 +8515,7 @@ var PackageSymbols = map[string][]Symbol{
                {"DefaultRemoteAddr", Const, 0},
                {"NewRecorder", Func, 0},
                {"NewRequest", Func, 7},
+               {"NewRequestWithContext", Func, 23},
                {"NewServer", Func, 0},
                {"NewTLSServer", Func, 0},
                {"NewUnstartedServer", Func, 0},
@@ -8917,6 +8980,7 @@ var PackageSymbols = map[string][]Symbol{
                {"Chown", Func, 0},
                {"Chtimes", Func, 0},
                {"Clearenv", Func, 0},
+               {"CopyFS", Func, 23},
                {"Create", Func, 0},
                {"CreateTemp", Func, 16},
                {"DevNull", Const, 0},
@@ -9150,6 +9214,7 @@ var PackageSymbols = map[string][]Symbol{
                {"IsLocal", Func, 20},
                {"Join", Func, 0},
                {"ListSeparator", Const, 0},
+               {"Localize", Func, 23},
                {"Match", Func, 0},
                {"Rel", Func, 0},
                {"Separator", Const, 0},
@@ -9232,6 +9297,8 @@ var PackageSymbols = map[string][]Symbol{
                {"(Value).Pointer", Method, 0},
                {"(Value).Recv", Method, 0},
                {"(Value).Send", Method, 0},
+               {"(Value).Seq", Method, 23},
+               {"(Value).Seq2", Method, 23},
                {"(Value).Set", Method, 0},
                {"(Value).SetBool", Method, 0},
                {"(Value).SetBytes", Method, 0},
@@ -9314,6 +9381,7 @@ var PackageSymbols = map[string][]Symbol{
                {"SelectSend", Const, 1},
                {"SendDir", Const, 0},
                {"Slice", Const, 0},
+               {"SliceAt", Func, 23},
                {"SliceHeader", Type, 0},
                {"SliceHeader.Cap", Field, 0},
                {"SliceHeader.Data", Field, 0},
@@ -9655,6 +9723,7 @@ var PackageSymbols = map[string][]Symbol{
                {"BuildSetting", Type, 18},
                {"BuildSetting.Key", Field, 18},
                {"BuildSetting.Value", Field, 18},
+               {"CrashOptions", Type, 23},
                {"FreeOSMemory", Func, 1},
                {"GCStats", Type, 1},
                {"GCStats.LastGC", Field, 1},
@@ -9672,6 +9741,7 @@ var PackageSymbols = map[string][]Symbol{
                {"PrintStack", Func, 0},
                {"ReadBuildInfo", Func, 12},
                {"ReadGCStats", Func, 1},
+               {"SetCrashOutput", Func, 23},
                {"SetGCPercent", Func, 1},
                {"SetMaxStack", Func, 2},
                {"SetMaxThreads", Func, 2},
@@ -9742,10 +9812,15 @@ var PackageSymbols = map[string][]Symbol{
                {"WithRegion", Func, 11},
        },
        "slices": {
+               {"All", Func, 23},
+               {"AppendSeq", Func, 23},
+               {"Backward", Func, 23},
                {"BinarySearch", Func, 21},
                {"BinarySearchFunc", Func, 21},
+               {"Chunk", Func, 23},
                {"Clip", Func, 21},
                {"Clone", Func, 21},
+               {"Collect", Func, 23},
                {"Compact", Func, 21},
                {"CompactFunc", Func, 21},
                {"Compare", Func, 21},
@@ -9767,11 +9842,16 @@ var PackageSymbols = map[string][]Symbol{
                {"MaxFunc", Func, 21},
                {"Min", Func, 21},
                {"MinFunc", Func, 21},
+               {"Repeat", Func, 23},
                {"Replace", Func, 21},
                {"Reverse", Func, 21},
                {"Sort", Func, 21},
                {"SortFunc", Func, 21},
                {"SortStableFunc", Func, 21},
+               {"Sorted", Func, 23},
+               {"SortedFunc", Func, 23},
+               {"SortedStableFunc", Func, 23},
+               {"Values", Func, 23},
        },
        "sort": {
                {"(Float64Slice).Len", Method, 0},
@@ -9936,10 +10016,14 @@ var PackageSymbols = map[string][]Symbol{
                {"TrimSpace", Func, 0},
                {"TrimSuffix", Func, 1},
        },
+       "structs": {
+               {"HostLayout", Type, 23},
+       },
        "sync": {
                {"(*Cond).Broadcast", Method, 0},
                {"(*Cond).Signal", Method, 0},
                {"(*Cond).Wait", Method, 0},
+               {"(*Map).Clear", Method, 23},
                {"(*Map).CompareAndDelete", Method, 20},
                {"(*Map).CompareAndSwap", Method, 20},
                {"(*Map).Delete", Method, 9},
@@ -9986,13 +10070,17 @@ var PackageSymbols = map[string][]Symbol{
                {"(*Bool).Store", Method, 19},
                {"(*Bool).Swap", Method, 19},
                {"(*Int32).Add", Method, 19},
+               {"(*Int32).And", Method, 23},
                {"(*Int32).CompareAndSwap", Method, 19},
                {"(*Int32).Load", Method, 19},
+               {"(*Int32).Or", Method, 23},
                {"(*Int32).Store", Method, 19},
                {"(*Int32).Swap", Method, 19},
                {"(*Int64).Add", Method, 19},
+               {"(*Int64).And", Method, 23},
                {"(*Int64).CompareAndSwap", Method, 19},
                {"(*Int64).Load", Method, 19},
+               {"(*Int64).Or", Method, 23},
                {"(*Int64).Store", Method, 19},
                {"(*Int64).Swap", Method, 19},
                {"(*Pointer).CompareAndSwap", Method, 19},
@@ -10000,18 +10088,24 @@ var PackageSymbols = map[string][]Symbol{
                {"(*Pointer).Store", Method, 19},
                {"(*Pointer).Swap", Method, 19},
                {"(*Uint32).Add", Method, 19},
+               {"(*Uint32).And", Method, 23},
                {"(*Uint32).CompareAndSwap", Method, 19},
                {"(*Uint32).Load", Method, 19},
+               {"(*Uint32).Or", Method, 23},
                {"(*Uint32).Store", Method, 19},
                {"(*Uint32).Swap", Method, 19},
                {"(*Uint64).Add", Method, 19},
+               {"(*Uint64).And", Method, 23},
                {"(*Uint64).CompareAndSwap", Method, 19},
                {"(*Uint64).Load", Method, 19},
+               {"(*Uint64).Or", Method, 23},
                {"(*Uint64).Store", Method, 19},
                {"(*Uint64).Swap", Method, 19},
                {"(*Uintptr).Add", Method, 19},
+               {"(*Uintptr).And", Method, 23},
                {"(*Uintptr).CompareAndSwap", Method, 19},
                {"(*Uintptr).Load", Method, 19},
+               {"(*Uintptr).Or", Method, 23},
                {"(*Uintptr).Store", Method, 19},
                {"(*Uintptr).Swap", Method, 19},
                {"(*Value).CompareAndSwap", Method, 17},
@@ -10023,6 +10117,11 @@ var PackageSymbols = map[string][]Symbol{
                {"AddUint32", Func, 0},
                {"AddUint64", Func, 0},
                {"AddUintptr", Func, 0},
+               {"AndInt32", Func, 23},
+               {"AndInt64", Func, 23},
+               {"AndUint32", Func, 23},
+               {"AndUint64", Func, 23},
+               {"AndUintptr", Func, 23},
                {"Bool", Type, 19},
                {"CompareAndSwapInt32", Func, 0},
                {"CompareAndSwapInt64", Func, 0},
@@ -10038,6 +10137,11 @@ var PackageSymbols = map[string][]Symbol{
                {"LoadUint32", Func, 0},
                {"LoadUint64", Func, 0},
                {"LoadUintptr", Func, 0},
+               {"OrInt32", Func, 23},
+               {"OrInt64", Func, 23},
+               {"OrUint32", Func, 23},
+               {"OrUint64", Func, 23},
+               {"OrUintptr", Func, 23},
                {"Pointer", Type, 19},
                {"StoreInt32", Func, 0},
                {"StoreInt64", Func, 0},
@@ -16200,6 +16304,7 @@ var PackageSymbols = map[string][]Symbol{
                {"WSAEACCES", Const, 2},
                {"WSAECONNABORTED", Const, 9},
                {"WSAECONNRESET", Const, 3},
+               {"WSAENOPROTOOPT", Const, 23},
                {"WSAEnumProtocols", Func, 2},
                {"WSAID_CONNECTEX", Var, 1},
                {"WSAIoctl", Func, 0},
@@ -17284,6 +17389,7 @@ var PackageSymbols = map[string][]Symbol{
                {"Encode", Func, 0},
                {"EncodeRune", Func, 0},
                {"IsSurrogate", Func, 0},
+               {"RuneLen", Func, 23},
        },
        "unicode/utf8": {
                {"AppendRune", Func, 18},
@@ -17306,6 +17412,11 @@ var PackageSymbols = map[string][]Symbol{
                {"ValidRune", Func, 1},
                {"ValidString", Func, 0},
        },
+       "unique": {
+               {"(Handle).Value", Method, 23},
+               {"Handle", Type, 23},
+               {"Make", Func, 23},
+       },
        "unsafe": {
                {"Add", Func, 0},
                {"Alignof", Func, 0},

diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 14c7a3edb459c41e2f33a9d5b8bfa320f12a1030..8ba7df290fa0c1b012ada0b6601570d6ef2d3958 100644 (file)
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -70,7 +70,7 @@ golang.org/x/text/internal/tag
 golang.org/x/text/language
 golang.org/x/text/transform
 golang.org/x/text/unicode/norm
-# golang.org/x/tools v0.21.1-0.20240604144337-208808308b70
+# golang.org/x/tools v0.22.1-0.20240618181713-f2d2ebe43e72
 ## explicit; go 1.19
 golang.org/x/tools/cmd/bisect
 golang.org/x/tools/cover