[chore]: Bump github.com/miekg/dns from 1.1.63 to 1.1.64 (#3936)

Bumps [github.com/miekg/dns](https://github.com/miekg/dns) from 1.1.63 to 1.1.64.
- [Changelog](https://github.com/miekg/dns/blob/master/Makefile.release)
- [Commits](https://github.com/miekg/dns/compare/v1.1.63...v1.1.64)

---
updated-dependencies:
- dependency-name: github.com/miekg/dns
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

vendor/golang.org/x/tools/internal/modindex/index.go

@@ -17,6 +17,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"testing"
 	"time"
 )
 
@@ -85,6 +86,28 @@ type Entry struct {
 	Names []string // exported names and information
 }
 
+// IndexDir is where the module index is stored.
+var IndexDir string
+
+// Set IndexDir
+func init() {
+	var dir string
+	var err error
+	if testing.Testing() {
+		dir = os.TempDir()
+	} else {
+		dir, err = os.UserCacheDir()
+		// shouldn't happen, but TempDir is better than
+		// creating ./go/imports
+		if err != nil {
+			dir = os.TempDir()
+		}
+	}
+	dir = filepath.Join(dir, "go", "imports")
+	os.MkdirAll(dir, 0777)
+	IndexDir = dir
+}
+
 // ReadIndex reads the latest version of the on-disk index
 // for the cache directory cd.
 // It returns (nil, nil) if there is no index, but returns
@@ -95,10 +118,7 @@ func ReadIndex(cachedir string) (*Index, error) {
 		return nil, err
 	}
 	cd := Abspath(cachedir)
-	dir, err := IndexDir()
-	if err != nil {
-		return nil, err
-	}
+	dir := IndexDir
 	base := indexNameBase(cd)
 	iname := filepath.Join(dir, base)
 	buf, err := os.ReadFile(iname)
@@ -185,12 +205,8 @@ func readIndexFrom(cd Abspath, bx io.Reader) (*Index, error) {
 
 // write the index as a text file
 func writeIndex(cachedir Abspath, ix *Index) error {
-	dir, err := IndexDir()
-	if err != nil {
-		return err
-	}
 	ipat := fmt.Sprintf("index-%d-*", CurrentVersion)
-	fd, err := os.CreateTemp(dir, ipat)
+	fd, err := os.CreateTemp(IndexDir, ipat)
 	if err != nil {
 		return err // can this happen?
 	}
@@ -201,7 +217,7 @@ func writeIndex(cachedir Abspath, ix *Index) error {
 	content := fd.Name()
 	content = filepath.Base(content)
 	base := indexNameBase(cachedir)
-	nm := filepath.Join(dir, base)
+	nm := filepath.Join(IndexDir, base)
 	err = os.WriteFile(nm, []byte(content), 0666)
 	if err != nil {
 		return err
@@ -241,18 +257,6 @@ func writeIndexToFile(x *Index, fd *os.File) error {
 	return nil
 }
 
-// tests can override this
-var IndexDir = indexDir
-
-// IndexDir computes the directory containing the index
-func indexDir() (string, error) {
-	dir, err := os.UserCacheDir()
-	if err != nil {
-		return "", fmt.Errorf("cannot open UserCacheDir, %w", err)
-	}
-	return filepath.Join(dir, "go", "imports"), nil
-}
-
 // return the base name of the file containing the name of the current index
 func indexNameBase(cachedir Abspath) string {
 	// crc64 is a way to convert path names into 16 hex digits.

vendor/golang.org/x/tools/internal/modindex/lookup.go

@@ -16,6 +16,7 @@ type Candidate struct {
 	Dir        string
 	ImportPath string
 	Type       LexType
+	Deprecated bool
 	// information for Funcs
 	Results int16   // how many results
 	Sig     []Field // arg names and types
@@ -34,6 +35,36 @@ const (
 	Func
 )
 
+// LookupAll only returns those Candidates whose import path
+// finds all the nms.
+func (ix *Index) LookupAll(pkg string, names ...string) map[string][]Candidate {
+	// this can be made faster when benchmarks show that it needs to be
+	names = uniquify(names)
+	byImpPath := make(map[string][]Candidate)
+	for _, nm := range names {
+		cands := ix.Lookup(pkg, nm, false)
+		for _, c := range cands {
+			byImpPath[c.ImportPath] = append(byImpPath[c.ImportPath], c)
+		}
+	}
+	for k, v := range byImpPath {
+		if len(v) != len(names) {
+			delete(byImpPath, k)
+		}
+	}
+	return byImpPath
+}
+
+// remove duplicates
+func uniquify(in []string) []string {
+	if len(in) == 0 {
+		return in
+	}
+	in = slices.Clone(in)
+	slices.Sort(in)
+	return slices.Compact(in)
+}
+
 // Lookup finds all the symbols in the index with the given PkgName and name.
 // If prefix is true, it finds all of these with name as a prefix.
 func (ix *Index) Lookup(pkg, name string, prefix bool) []Candidate {
@@ -79,8 +110,9 @@ func (ix *Index) Lookup(pkg, name string, prefix bool) []Candidate {
 				Dir:        string(e.Dir),
 				ImportPath: e.ImportPath,
 				Type:       asLexType(flds[1][0]),
+				Deprecated: len(flds[1]) > 1 && flds[1][1] == 'D',
 			}
-			if flds[1] == "F" {
+			if px.Type == Func {
 				n, err := strconv.Atoi(flds[2])
 				if err != nil {
 					continue // should never happen
@@ -111,6 +143,7 @@ func toFields(sig []string) []Field {
 }
 
 // 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

vendor/golang.org/x/tools/internal/modindex/symbols.go

@@ -12,6 +12,7 @@ import (
 	"go/types"
 	"os"
 	"path/filepath"
+	"runtime"
 	"slices"
 	"strings"
 
@@ -19,29 +20,30 @@ import (
 )
 
 // The name of a symbol contains information about the symbol:
-// <name> T for types
-// <name> C for consts
-// <name> V for vars
+// <name> T for types, TD if the type is deprecated
+// <name> C for consts, CD if the const is deprecated
+// <name> V for vars, VD if the var is deprecated
 // and for funcs: <name> F <num of return values> (<arg-name> <arg-type>)*
 // any spaces in <arg-type> are replaced by $s so that the fields
-// of the name are space separated
+// 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
+	kind string // T, C, V, or F, follwed by D if deprecated
 	sig  string // signature information, for F
 }
 
 // find the symbols for the best directories
 func getSymbols(cd Abspath, dirs map[string][]*directory) {
 	var g errgroup.Group
-	g.SetLimit(-1) // maybe throttle this some day
+	g.SetLimit(max(2, runtime.GOMAXPROCS(0)/2))
 	for _, vv := range dirs {
 		// throttling some day?
 		d := vv[0]
 		g.Go(func() error {
 			thedir := filepath.Join(string(cd), string(d.path))
-			mode := parser.SkipObjectResolution
+			mode := parser.SkipObjectResolution | parser.ParseComments
 
 			fi, err := os.ReadDir(thedir)
 			if err != nil {
@@ -84,6 +86,9 @@ func getFileExports(f *ast.File) []symbol {
 			// 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.
@@ -107,7 +112,7 @@ func getFileExports(f *ast.File) []symbol {
 				// print struct tags. So for this to happen the type of a formal parameter
 				// has to be a explict 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 not ignore such pathologies
+				// a waste of effort, but let's remember the possibility
 				if strings.Contains(tp, "$") {
 					continue
 				}
@@ -127,12 +132,16 @@ func getFileExports(f *ast.File) []symbol {
 				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 {
@@ -141,8 +150,12 @@ func getFileExports(f *ast.File) []symbol {
 					}
 				}
 			case token.TYPE:
+				tp := "T"
+				if depr {
+					tp += "D"
+				}
 				for _, sp := range decl.Specs {
-					if s := newsym(pkg, sp.(*ast.TypeSpec).Name.Name, "T", ""); s != nil {
+					if s := newsym(pkg, sp.(*ast.TypeSpec).Name.Name, tp, ""); s != nil {
 						ans = append(ans, *s)
 					}
 				}
@@ -160,6 +173,22 @@ func newsym(pkg, name, kind, sig string) *symbol {
 	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
+	lines := strings.Split(doc.Text(), "\n\n")
+	for _, line := range lines {
+		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