Update quic-go

vendor/golang.org/x/tools/go/ast/astutil/enclosing.go

@@ -106,21 +106,8 @@ func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Nod
 
 			// Does augmented child strictly contain [start, end)?
 			if augPos <= start && end <= augEnd {
-				if is[tokenNode](child) {
-					return true
-				}
-
-				// childrenOf elides the FuncType node beneath FuncDecl.
-				// Add it back here for TypeParams, Params, Results,
-				// all FieldLists). But we don't add it back for the "func" token
-				// even though it is is the tree at FuncDecl.Type.Func.
-				if decl, ok := node.(*ast.FuncDecl); ok {
-					if fields, ok := child.(*ast.FieldList); ok && fields != decl.Recv {
-						path = append(path, decl.Type)
-					}
-				}
-
-				return visit(child)
+				_, isToken := child.(tokenNode)
+				return isToken || visit(child)
 			}
 
 			// Does [start, end) overlap multiple children?
@@ -326,8 +313,6 @@ func childrenOf(n ast.Node) []ast.Node {
 		//
 		// As a workaround, we inline the case for FuncType
 		// here and order things correctly.
-		// We also need to insert the elided FuncType just
-		// before the 'visit' recursion.
 		//
 		children = nil // discard ast.Walk(FuncDecl) info subtrees
 		children = append(children, tok(n.Type.Func, len("func")))
@@ -647,8 +632,3 @@ func NodeDescription(n ast.Node) string {
 	}
 	panic(fmt.Sprintf("unexpected node type: %T", n))
 }
-
-func is[T any](x any) bool {
-	_, ok := x.(T)
-	return ok
-}

vendor/golang.org/x/tools/go/ast/astutil/imports.go

@@ -344,12 +344,7 @@ func RewriteImport(fset *token.FileSet, f *ast.File, oldPath, newPath string) (r
 }
 
 // UsesImport reports whether a given import is used.
-// The provided File must have been parsed with syntactic object resolution
-// (not using go/parser.SkipObjectResolution).
 func UsesImport(f *ast.File, path string) (used bool) {
-	if f.Scope == nil {
-		panic("file f was not parsed with syntactic object resolution")
-	}
 	spec := importSpec(f, path)
 	if spec == nil {
 		return

vendor/golang.org/x/tools/go/ast/astutil/util.go

@@ -7,5 +7,12 @@ package astutil
 import "go/ast"
 
 // Unparen returns e with any enclosing parentheses stripped.
-// Deprecated: use [ast.Unparen].
-func Unparen(e ast.Expr) ast.Expr { return ast.Unparen(e) }
+func Unparen(e ast.Expr) ast.Expr {
+	for {
+		p, ok := e.(*ast.ParenExpr)
+		if !ok {
+			return e
+		}
+		e = p.X
+	}
+}

vendor/golang.org/x/tools/go/ast/inspector/inspector.go

@@ -36,7 +36,6 @@ package inspector
 
 import (
 	"go/ast"
-	_ "unsafe"
 )
 
 // An Inspector provides methods for inspecting
@@ -45,9 +44,6 @@ type Inspector struct {
 	events []event
 }
 
-//go:linkname events
-func events(in *Inspector) []event { return in.events }
-
 // New returns an Inspector for the specified syntax trees.
 func New(files []*ast.File) *Inspector {
 	return &Inspector{traverse(files)}
@@ -56,10 +52,9 @@ func New(files []*ast.File) *Inspector {
 // An event represents a push or a pop
 // of an ast.Node during a traversal.
 type event struct {
-	node   ast.Node
-	typ    uint64 // typeOf(node) on push event, or union of typ strictly between push and pop events on pop events
-	index  int32  // index of corresponding push or pop event
-	parent int32  // index of parent's push node (defined for push nodes only)
+	node  ast.Node
+	typ   uint64 // typeOf(node) on push event, or union of typ strictly between push and pop events on pop events
+	index int    // index of corresponding push or pop event
 }
 
 // TODO: Experiment with storing only the second word of event.node (unsafe.Pointer).
@@ -78,17 +73,8 @@ func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
 	// check, Preorder is almost twice as fast as Nodes. The two
 	// features seem to contribute similar slowdowns (~1.4x each).
 
-	// This function is equivalent to the PreorderSeq call below,
-	// but to avoid the additional dynamic call (which adds 13-35%
-	// to the benchmarks), we expand it out.
-	//
-	// in.PreorderSeq(types...)(func(n ast.Node) bool {
-	// 	f(n)
-	// 	return true
-	// })
-
 	mask := maskOf(types)
-	for i := int32(0); i < int32(len(in.events)); {
+	for i := 0; i < len(in.events); {
 		ev := in.events[i]
 		if ev.index > i {
 			// push
@@ -118,7 +104,7 @@ func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
 // matches an element of the types slice.
 func (in *Inspector) Nodes(types []ast.Node, f func(n ast.Node, push bool) (proceed bool)) {
 	mask := maskOf(types)
-	for i := int32(0); i < int32(len(in.events)); {
+	for i := 0; i < len(in.events); {
 		ev := in.events[i]
 		if ev.index > i {
 			// push
@@ -152,7 +138,7 @@ func (in *Inspector) Nodes(types []ast.Node, f func(n ast.Node, push bool) (proc
 func (in *Inspector) WithStack(types []ast.Node, f func(n ast.Node, push bool, stack []ast.Node) (proceed bool)) {
 	mask := maskOf(types)
 	var stack []ast.Node
-	for i := int32(0); i < int32(len(in.events)); {
+	for i := 0; i < len(in.events); {
 		ev := in.events[i]
 		if ev.index > i {
 			// push
@@ -185,9 +171,7 @@ func (in *Inspector) WithStack(types []ast.Node, f func(n ast.Node, push bool, s
 // traverse builds the table of events representing a traversal.
 func traverse(files []*ast.File) []event {
 	// Preallocate approximate number of events
-	// based on source file extent of the declarations.
-	// (We use End-Pos not FileStart-FileEnd to neglect
-	// the effect of long doc comments.)
+	// based on source file extent.
 	// This makes traverse faster by 4x (!).
 	var extent int
 	for _, f := range files {
@@ -201,24 +185,18 @@ func traverse(files []*ast.File) []event {
 	events := make([]event, 0, capacity)
 
 	var stack []event
-	stack = append(stack, event{index: -1}) // include an extra event so file nodes have a parent
+	stack = append(stack, event{}) // include an extra event so file nodes have a parent
 	for _, f := range files {
 		ast.Inspect(f, func(n ast.Node) bool {
 			if n != nil {
 				// push
 				ev := event{
-					node:   n,
-					typ:    0,                  // temporarily used to accumulate type bits of subtree
-					index:  int32(len(events)), // push event temporarily holds own index
-					parent: stack[len(stack)-1].index,
+					node:  n,
+					typ:   0,           // temporarily used to accumulate type bits of subtree
+					index: len(events), // push event temporarily holds own index
 				}
 				stack = append(stack, ev)
 				events = append(events, ev)
-
-				// 2B nodes ought to be enough for anyone!
-				if int32(len(events)) < 0 {
-					panic("event index exceeded int32")
-				}
 			} else {
 				// pop
 				top := len(stack) - 1
@@ -227,9 +205,9 @@ func traverse(files []*ast.File) []event {
 				push := ev.index
 				parent := top - 1
 
-				events[push].typ = typ                  // set type of push
-				stack[parent].typ |= typ | ev.typ       // parent's typ contains push and pop's typs.
-				events[push].index = int32(len(events)) // make push refer to pop
+				events[push].typ = typ            // set type of push
+				stack[parent].typ |= typ | ev.typ // parent's typ contains push and pop's typs.
+				events[push].index = len(events)  // make push refer to pop
 
 				stack = stack[:top]
 				events = append(events, ev)

vendor/golang.org/x/tools/go/ast/inspector/iter.go

@@ -1,85 +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.
-
-//go:build go1.23
-
-package inspector
-
-import (
-	"go/ast"
-	"iter"
-)
-
-// PreorderSeq returns an iterator that visits all the
-// 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.
-func (in *Inspector) PreorderSeq(types ...ast.Node) iter.Seq[ast.Node] {
-
-	// This implementation is identical to Preorder,
-	// except that it supports breaking out of the loop.
-
-	return func(yield func(ast.Node) bool) {
-		mask := maskOf(types)
-		for i := int32(0); i < int32(len(in.events)); {
-			ev := in.events[i]
-			if ev.index > i {
-				// push
-				if ev.typ&mask != 0 {
-					if !yield(ev.node) {
-						break
-					}
-				}
-				pop := ev.index
-				if in.events[pop].typ&mask == 0 {
-					// Subtrees do not contain types: skip them and pop.
-					i = pop + 1
-					continue
-				}
-			}
-			i++
-		}
-	}
-}
-
-// All[N] returns an iterator over all the nodes of type N.
-// N must be a pointer-to-struct type that implements ast.Node.
-//
-// Example:
-//
-//	for call := range All[*ast.CallExpr](in) { ... }
-func All[N interface {
-	*S
-	ast.Node
-}, S any](in *Inspector) iter.Seq[N] {
-
-	// To avoid additional dynamic call overheads,
-	// we duplicate rather than call the logic of PreorderSeq.
-
-	mask := typeOf((N)(nil))
-	return func(yield func(N) bool) {
-		for i := int32(0); i < int32(len(in.events)); {
-			ev := in.events[i]
-			if ev.index > i {
-				// push
-				if ev.typ&mask != 0 {
-					if !yield(ev.node.(N)) {
-						break
-					}
-				}
-				pop := ev.index
-				if in.events[pop].typ&mask == 0 {
-					// Subtrees do not contain types: skip them and pop.
-					i = pop + 1
-					continue
-				}
-			}
-			i++
-		}
-	}
-}

vendor/golang.org/x/tools/go/ast/inspector/typeof.go

@@ -12,8 +12,6 @@ package inspector
 import (
 	"go/ast"
 	"math"
-
-	_ "unsafe"
 )
 
 const (
@@ -217,7 +215,6 @@ func typeOf(n ast.Node) uint64 {
 	return 0
 }
 
-//go:linkname maskOf
 func maskOf(nodes []ast.Node) uint64 {
 	if nodes == nil {
 		return math.MaxUint64 // match all node types