go/ast/inspector: add Cursor.ParentEdge{Kind,Index} methods

adonovan · adonovan · commit 2182926e3014 · 2026-02-09T09:22:12.000-08:00
These methods return just one or the other component of ParentEdge, making them more convenient to use than ParentEdge in most cases, obviating astutil.IsChildOf. Also, fix some doc links, and use plain "valid" instead of [Cursor.Valid] in adjectival contexts; the meaning is clear. Fixes golang/go#77195 Change-Id: Id9521a67cda78958ed799874a38ff3f039e4a564 Reviewed-on: https://go-review.googlesource.com/c/tools/+/740280 Reviewed-by: Madeline Kalil <mkalil@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
diff --git a/go/analysis/passes/inline/inline.go b/go/analysis/passes/inline/inline.go
@@ -364,13 +364,13 @@ func (a *analyzer) inlineAlias(tn *types.TypeName, curId inspector.Cursor) {
 	//   pkg.Id[T]
 	//   pkg.Id[K, V]
 	var expr ast.Expr = id
-	if astutil.IsChildOf(curId, edge.SelectorExpr_Sel) {
+	if curId.ParentEdgeKind() == edge.SelectorExpr_Sel {
 		curId = curId.Parent()
 		expr = curId.Node().(ast.Expr)
 	}
 	// If expr is part of an IndexExpr or IndexListExpr, we'll need that node.
 	// Given C[int], TypeOf(C) is generic but TypeOf(C[int]) is instantiated.
-	switch ek, _ := curId.ParentEdge(); ek {
+	switch curId.ParentEdgeKind() {
 	case edge.IndexExpr_X:
 		expr = curId.Parent().Node().(*ast.IndexExpr)
 	case edge.IndexListExpr_X:
@@ -526,7 +526,7 @@ func (a *analyzer) inlineConst(con *types.Const, cur inspector.Cursor) {
 	}
 	// If n is qualified by a package identifier, we'll need the full selector expression.
 	var expr ast.Expr = n
-	if astutil.IsChildOf(cur, edge.SelectorExpr_Sel) {
+	if cur.ParentEdgeKind() == edge.SelectorExpr_Sel {
 		expr = cur.Parent().Node().(ast.Expr)
 	}
 	a.reportInline("constant", "Constant", expr, edits, importPrefix+incon.RHSName)
diff --git a/go/analysis/passes/modernize/errorsastype.go b/go/analysis/passes/modernize/errorsastype.go
@@ -189,7 +189,7 @@ func errorsastype(pass *analysis.Pass) (any, error) {
 // declaration of the typed error var. The var must not be
 // used outside the if statement.
 func canUseErrorsAsType(info *types.Info, index *typeindex.Index, curCall inspector.Cursor) (_ *types.Var, _ inspector.Cursor) {
-	if !astutil.IsChildOf(curCall, edge.IfStmt_Cond) {
+	if curCall.ParentEdgeKind() != edge.IfStmt_Cond {
 		return // not beneath if statement
 	}
 	var (
@@ -221,7 +221,7 @@ func canUseErrorsAsType(info *types.Info, index *typeindex.Index, curCall inspec
 			return // v used before/after if statement
 		}
 	}
-	if !astutil.IsChildOf(curDef, edge.ValueSpec_Names) {
+	if curDef.ParentEdgeKind() != edge.ValueSpec_Names {
 		return // v not declared by "var v T"
 	}
 	var (
diff --git a/go/analysis/passes/modernize/minmax.go b/go/analysis/passes/modernize/minmax.go
@@ -209,7 +209,7 @@ func minmax(pass *analysis.Pass) (any, error) {
 			// (This case would require introducing another block
 			//    if cond { ... } else { if a < b { lhs = rhs } }
 			// and checking that there is no following "else".)
-			if astutil.IsChildOf(curIfStmt, edge.IfStmt_Else) {
+			if curIfStmt.ParentEdgeKind() == edge.IfStmt_Else {
 				continue
 			}
 
diff --git a/go/analysis/passes/modernize/modernize.go b/go/analysis/passes/modernize/modernize.go
@@ -20,7 +20,7 @@ import (
 	"golang.org/x/tools/go/ast/edge"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/internal/analysis/analyzerutil"
-	"golang.org/x/tools/internal/astutil"
+
 	"golang.org/x/tools/internal/moreiters"
 	"golang.org/x/tools/internal/packagepath"
 	"golang.org/x/tools/internal/stdlib"
@@ -114,7 +114,7 @@ func within(pass *analysis.Pass, pkgs ...string) bool {
 // unparenEnclosing removes enclosing parens from cur in
 // preparation for a call to [Cursor.ParentEdge].
 func unparenEnclosing(cur inspector.Cursor) inspector.Cursor {
-	for astutil.IsChildOf(cur, edge.ParenExpr_X) {
+	for cur.ParentEdgeKind() == edge.ParenExpr_X {
 		cur = cur.Parent()
 	}
 	return cur
diff --git a/go/analysis/passes/modernize/rangeint.go b/go/analysis/passes/modernize/rangeint.go
@@ -316,10 +316,10 @@ func isScalarLvalue(info *types.Info, curId inspector.Cursor) bool {
 	cur := curId
 
 	// Strip enclosing parens.
-	ek, _ := cur.ParentEdge()
+	ek := cur.ParentEdgeKind()
 	for ek == edge.ParenExpr_X {
 		cur = cur.Parent()
-		ek, _ = cur.ParentEdge()
+		ek = cur.ParentEdgeKind()
 	}
 
 	switch ek {
diff --git a/go/analysis/passes/modernize/reflect.go b/go/analysis/passes/modernize/reflect.go
@@ -56,9 +56,9 @@ func reflecttypefor(pass *analysis.Pass) (any, error) {
 
 		// Special case for TypeOf((*T)(nil)).Elem(),
 		// needed when T is an interface type.
-		if astutil.IsChildOf(curCall, edge.SelectorExpr_X) {
+		if curCall.ParentEdgeKind() == edge.SelectorExpr_X {
 			curSel := unparenEnclosing(curCall).Parent()
-			if astutil.IsChildOf(curSel, edge.CallExpr_Fun) {
+			if curSel.ParentEdgeKind() == edge.CallExpr_Fun {
 				call2 := unparenEnclosing(curSel).Parent().Node().(*ast.CallExpr)
 				obj := typeutil.Callee(info, call2)
 				if typesinternal.IsMethodNamed(obj, "reflect", "Type", "Elem") {
diff --git a/go/analysis/passes/modernize/stditerators.go b/go/analysis/passes/modernize/stditerators.go
@@ -220,15 +220,15 @@ func stditerators(pass *analysis.Pass) (any, error) {
 			)
 
 			// Analyze enclosing loop.
-			switch first(curLenCall.ParentEdge()) {
+			switch curLenCall.ParentEdgeKind() {
 			case edge.BinaryExpr_Y:
 				// pattern 1: for i := 0; i < x.Len(); i++ { ... }
 				var (
 					curCmp = curLenCall.Parent()
 					cmp    = curCmp.Node().(*ast.BinaryExpr)
 				)
 				if cmp.Op != token.LSS ||
-					!astutil.IsChildOf(curCmp, edge.ForStmt_Cond) {
+					curCmp.ParentEdgeKind() != edge.ForStmt_Cond {
 					continue
 				}
 				if id, ok := cmp.X.(*ast.Ident); ok {
diff --git a/go/analysis/passes/modernize/stringsbuilder.go b/go/analysis/passes/modernize/stringsbuilder.go
@@ -102,7 +102,7 @@ nextcand:
 			continue
 		}
 
-		ek, _ := def.ParentEdge()
+		ek := def.ParentEdgeKind()
 		if ek == edge.AssignStmt_Lhs &&
 			len(def.Parent().Node().(*ast.AssignStmt).Lhs) == 1 {
 			// Have: s := expr
@@ -274,10 +274,10 @@ nextcand:
 		)
 		for curUse := range index.Uses(v) {
 			// Strip enclosing parens around Ident.
-			ek, _ := curUse.ParentEdge()
+			ek := curUse.ParentEdgeKind()
 			for ek == edge.ParenExpr_X {
 				curUse = curUse.Parent()
-				ek, _ = curUse.ParentEdge()
+				ek = curUse.ParentEdgeKind()
 			}
 
 			// The rvalueUse must be the lexically last use.
diff --git a/go/analysis/passes/modernize/stringscut.go b/go/analysis/passes/modernize/stringscut.go
@@ -376,7 +376,7 @@ func indexArgValid(info *types.Info, index *typeindex.Index, expr ast.Expr, afte
 // 4. afterSlice - a slice of `s` that matches one of: s[i+len(substr):], s[len(substr) + i:], s[i + const], s[k + i] (where k = len(substr))
 func checkIdxUses(info *types.Info, uses iter.Seq[inspector.Cursor], s, substr ast.Expr) (negative, nonnegative, beforeSlice, afterSlice []ast.Expr) {
 	use := func(cur inspector.Cursor) bool {
-		ek, _ := cur.ParentEdge()
+		ek := cur.ParentEdgeKind()
 		n := cur.Parent().Node()
 		switch ek {
 		case edge.BinaryExpr_X, edge.BinaryExpr_Y:
@@ -435,7 +435,7 @@ func checkIdxUses(info *types.Info, uses iter.Seq[inspector.Cursor], s, substr a
 // considered.
 func hasModifyingUses(info *types.Info, uses iter.Seq[inspector.Cursor], afterPos token.Pos) bool {
 	for curUse := range uses {
-		ek, _ := curUse.ParentEdge()
+		ek := curUse.ParentEdgeKind()
 		if ek == edge.AssignStmt_Lhs {
 			if curUse.Node().Pos() <= afterPos {
 				continue
diff --git a/go/analysis/passes/modernize/unsafefuncs.go b/go/analysis/passes/modernize/unsafefuncs.go
@@ -88,7 +88,7 @@ func unsafefuncs(pass *analysis.Pass) (any, error) {
 		if sum, ok := curSum.Node().(*ast.BinaryExpr); ok &&
 			sum.Op == token.ADD &&
 			types.Identical(info.TypeOf(sum.X), types.Typ[types.Uintptr]) &&
-			astutil.IsChildOf(curSum, edge.CallExpr_Args) {
+			curSum.ParentEdgeKind() == edge.CallExpr_Args {
 			// Have: sum ≡ T(x:...uintptr... + y:...uintptr...)
 			curX := curSum.ChildAt(edge.BinaryExpr_X, -1)
 			curY := curSum.ChildAt(edge.BinaryExpr_Y, -1)
diff --git a/go/ast/inspector/cursor.go b/go/ast/inspector/cursor.go
@@ -18,10 +18,10 @@ import (
 //
 // Two Cursors compare equal if they represent the same node.
 //
-// The zero value of Cursor is not [Valid].
+// 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 [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:
@@ -40,7 +40,7 @@ type Cursor struct {
 	index int32 // index of push node; -1 for virtual root node
 }
 
-// Root returns a [Valid] 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.
@@ -73,14 +73,14 @@ func (c Cursor) Valid() bool {
 }
 
 // Inspector returns the cursor's Inspector.
-// It returns nil if the Cursor is not [Valid]
+// 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 {
@@ -245,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.
diff --git a/gopls/internal/analysis/maprange/maprange.go b/gopls/internal/analysis/maprange/maprange.go
@@ -49,7 +49,7 @@ func run(pass *analysis.Pass) (any, error) {
 	)
 	for _, callee := range []types.Object{mapsKeys, mapsValues, xmapsKeys, xmapsValues} {
 		for curCall := range index.Calls(callee) {
-			if astutil.IsChildOf(curCall, edge.RangeStmt_X) {
+			if curCall.ParentEdgeKind() == edge.RangeStmt_X {
 				analyzeRangeStmt(pass, callee, curCall)
 			}
 		}
diff --git a/gopls/internal/golang/codeaction.go b/gopls/internal/golang/codeaction.go
@@ -28,7 +28,7 @@ import (
 	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/gopls/internal/protocol/command"
 	"golang.org/x/tools/gopls/internal/settings"
-	"golang.org/x/tools/internal/astutil"
+
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/imports"
 	"golang.org/x/tools/internal/typesinternal"
@@ -757,7 +757,7 @@ func refactorRewriteEliminateDotImport(ctx context.Context, req *codeActionsRequ
 		// that reference package-level symbols.
 		// All other references to a symbol imported from another package
 		// are nested within a select expression (pkg.Foo, v.Method, v.Field).
-		if astutil.IsChildOf(curId, edge.SelectorExpr_Sel) {
+		if curId.ParentEdgeKind() == edge.SelectorExpr_Sel {
 			continue // qualified identifier (pkg.X) or selector (T.X or e.X)
 		}
 		if !typesinternal.IsPackageLevel(use) {
diff --git a/gopls/internal/golang/extract.go b/gopls/internal/golang/extract.go
@@ -326,7 +326,7 @@ func stmtToInsertVarBefore(cur inspector.Cursor, variables []*variable) (token.P
 	// baseIfStmt walks up the if/else-if chain until we get to
 	// the top of the current if chain.
 	baseIfStmt := func(curIf inspector.Cursor) (token.Pos, error) {
-		for astutil.IsChildOf(curIf, edge.IfStmt_Else) {
+		for curIf.ParentEdgeKind() == edge.IfStmt_Else {
 			curIf = curIf.Parent()
 			if hasFreeVar(curIf.Node().(*ast.IfStmt).Init) {
 				return 0, fmt.Errorf("else-if's init has free variable")
@@ -483,7 +483,7 @@ func canExtractVariable(info *types.Info, curFile inspector.Cursor, start, end t
 	//   x := *newVar + 1
 	//   *newVar = 2
 	for _, curExpr := range curExprs {
-		switch ek, _ := curExpr.ParentEdge(); ek {
+		switch curExpr.ParentEdgeKind() {
 		case edge.AssignStmt_Lhs:
 			return nil, fmt.Errorf("node %T is in LHS of an AssignStmt", expr)
 		case edge.ValueSpec_Names:
@@ -609,7 +609,7 @@ func extractFunctionMethod(cpkg *cache.Package, pgf *parsego.File, start, end to
 	// If the end cursor is the identifier in a labeled statement,
 	// we expand the range to include the colon.
 	// That way, we include the label, but not the statement being labeled
-	if astutil.IsChildOf(curEnd, edge.LabeledStmt_Label) {
+	if curEnd.ParentEdgeKind() == edge.LabeledStmt_Label {
 		end = curEnd.Parent().Node().(*ast.LabeledStmt).Colon + 1
 	}
 
diff --git a/gopls/internal/golang/highlight.go b/gopls/internal/golang/highlight.go
@@ -333,7 +333,7 @@ loop:
 		}
 
 		// If cursor is an arg in a callExpr, we don't want control flow highlighting.
-		if astutil.IsChildOf(cur, edge.CallExpr_Args) {
+		if cur.ParentEdgeKind() == edge.CallExpr_Args {
 			return
 		}
 	}
diff --git a/gopls/internal/golang/implementation.go b/gopls/internal/golang/implementation.go
@@ -1039,7 +1039,7 @@ func funcDefs(pkg *cache.Package, t types.Type) ([]protocol.Location, error) {
 // beneathFuncDef reports whether the specified FuncType cursor is a
 // child of Func{Decl,Lit}.
 func beneathFuncDef(cur inspector.Cursor) bool {
-	switch ek, _ := cur.ParentEdge(); ek {
+	switch cur.ParentEdgeKind() {
 	case edge.FuncDecl_Type, edge.FuncLit_Type:
 		return true
 	}
diff --git a/gopls/internal/golang/inline.go b/gopls/internal/golang/inline.go
@@ -180,8 +180,7 @@ func canInlineVariable(info *types.Info, curFile inspector.Cursor, start, end to
 func isLvalueUse(cur inspector.Cursor, info *types.Info) bool {
 	cur = unparenEnclosing(cur)
 
-	kind, _ := cur.ParentEdge()
-	switch kind {
+	switch cur.ParentEdgeKind() {
 	case edge.AssignStmt_Lhs, edge.IncDecStmt_X:
 		return true // v=..., v++
 
@@ -206,7 +205,7 @@ func isLvalueUse(cur inspector.Cursor, info *types.Info) bool {
 // unparenEnclosing removes enclosing parens from cur in
 // preparation for a call to [Cursor.ParentEdge].
 func unparenEnclosing(cur inspector.Cursor) inspector.Cursor {
-	for astutil.IsChildOf(cur, edge.ParenExpr_X) {
+	for cur.ParentEdgeKind() == edge.ParenExpr_X {
 		cur = cur.Parent()
 	}
 	return cur
@@ -230,7 +229,7 @@ func inlineVariableOne(pkg *cache.Package, pgf *parsego.File, start, end token.P
 		scope = info.Scopes[pgf.File].Innermost(pos)
 	)
 	for curIdent := range curRHS.Preorder((*ast.Ident)(nil)) {
-		if astutil.IsChildOf(curIdent, edge.SelectorExpr_Sel) {
+		if curIdent.ParentEdgeKind() == edge.SelectorExpr_Sel {
 			continue // ignore f in x.f
 		}
 		id := curIdent.Node().(*ast.Ident)
diff --git a/gopls/internal/golang/lines.go b/gopls/internal/golang/lines.go
@@ -176,8 +176,7 @@ func findSplitJoinTarget(fset *token.FileSet, curFile inspector.Cursor, src []by
 		cur, _ := curFile.FindByPos(start, end)
 		for cur := range cur.Enclosing() {
 			// TODO: do cur = enclosingUnparen(cur) first, once CL 701035 lands.
-			ek, _ := cur.ParentEdge()
-			switch ek {
+			switch cur.ParentEdgeKind() {
 			// params or results of func signature
 			// Note:
 			// - each ast.Field (e.g. "x, y, z int") is considered a single item.
diff --git a/gopls/internal/golang/references.go b/gopls/internal/golang/references.go
@@ -35,7 +35,7 @@ import (
 	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/gopls/internal/util/cursorutil"
 	"golang.org/x/tools/gopls/internal/util/safetoken"
-	"golang.org/x/tools/internal/astutil"
+
 	"golang.org/x/tools/internal/event"
 )
 
@@ -644,7 +644,7 @@ func objectsAt(info *types.Info, cur inspector.Cursor) ([]objectAt, error) {
 
 	// Within an ImportSpec, return the PkgName
 	// and its .Name (if explicit) or the spec if not.
-	if astutil.IsChildOf(cur, edge.ImportSpec_Path) {
+	if cur.ParentEdgeKind() == edge.ImportSpec_Path {
 		cur = cur.Parent() // ImportSpec
 		spec := cur.Node().(*ast.ImportSpec)
 		pkgname := info.PkgNameOf(spec)
diff --git a/gopls/internal/golang/stubmethods/stubmethods.go b/gopls/internal/golang/stubmethods/stubmethods.go
@@ -55,8 +55,7 @@ func GetIfaceStubInfo(fset *token.FileSet, info *types.Info, pgf *parsego.File,
 	cur, _ := pgf.Cursor().FindByPos(pos, end)
 	for cur := range cur.Enclosing() {
 		// TODO: do cur = unparenEnclosing(cur) first, once CL 701035 lands.
-		ek, _ := cur.ParentEdge()
-		switch ek {
+		switch cur.ParentEdgeKind() {
 		case edge.ValueSpec_Values:
 			return fromValueSpec(fset, info, cur)
 		case edge.ReturnStmt_Results:
@@ -217,7 +216,7 @@ func fromCallExpr(fset *token.FileSet, info *types.Info, curCallArg inspector.Cu
 		return nil
 	}
 
-	_, argIdx := curCallArg.ParentEdge()
+	argIdx := curCallArg.ParentEdgeIndex()
 	var paramType types.Type
 	if sig.Variadic() && argIdx >= sig.Params().Len()-1 {
 		v := sig.Params().At(sig.Params().Len() - 1)
@@ -277,8 +276,7 @@ func fromReturnStmt(fset *token.FileSet, info *types.Info, curResult inspector.C
 			len(ret.Results),
 			rets.Len())
 	}
-	_, resultIdx := curResult.ParentEdge()
-	iface := ifaceObjFromType(rets.At(resultIdx).Type())
+	iface := ifaceObjFromType(rets.At(curResult.ParentEdgeIndex()).Type())
 	if iface == nil {
 		return nil, nil
 	}
@@ -336,8 +334,7 @@ func fromAssignStmt(fset *token.FileSet, info *types.Info, curRhs inspector.Curs
 	//          ^^^^
 
 	assign := curRhs.Parent().Node().(*ast.AssignStmt)
-	_, idx := curRhs.ParentEdge()
-	lhs, rhs := assign.Lhs[idx], curRhs.Node().(ast.Expr)
+	lhs, rhs := assign.Lhs[curRhs.ParentEdgeIndex()], curRhs.Node().(ast.Expr)
 
 	ifaceObj := ifaceType(lhs, info)
 	if ifaceObj == nil {
diff --git a/gopls/internal/golang/type_definition.go b/gopls/internal/golang/type_definition.go
@@ -47,8 +47,8 @@ func TypeDefinition(ctx context.Context, snapshot *cache.Snapshot, fh file.Handl
 
 		// edge case: switch id := expr.(type) {}
 		// id has no type; use expr instead.
-		if astutil.IsChildOf(cur, edge.AssignStmt_Lhs) &&
-			astutil.IsChildOf(cur.Parent(), edge.TypeSwitchStmt_Assign) {
+		if cur.ParentEdgeKind() == edge.AssignStmt_Lhs &&
+			cur.Parent().ParentEdgeKind() == edge.TypeSwitchStmt_Assign {
 			expr = cur.Parent().Node().(*ast.AssignStmt).Rhs[0].(*ast.TypeAssertExpr).X
 		}
 
diff --git a/gopls/internal/golang/undeclared.go b/gopls/internal/golang/undeclared.go
diff --git a/gopls/internal/util/typesutil/typesutil.go b/gopls/internal/util/typesutil/typesutil.go
diff --git a/internal/astutil/util.go b/internal/astutil/util.go
diff --git a/internal/refactor/delete.go b/internal/refactor/delete.go
diff --git a/internal/typesinternal/typeindex/typeindex.go b/internal/typesinternal/typeindex/typeindex.go

Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ func errorsastype(pass *analysis.Pass) (any, error) {`
`189`	`189`	`// declaration of the typed error var. The var must not be`
`190`	`190`	`// used outside the if statement.`
`191`	`191`	`func canUseErrorsAsType(info types.Info, index typeindex.Index, curCall inspector.Cursor) (_ *types.Var, _ inspector.Cursor) {`
`192`		`- if !astutil.IsChildOf(curCall, edge.IfStmt_Cond) {`
	`192`	`+ if curCall.ParentEdgeKind() != edge.IfStmt_Cond {`
`193`	`193`	`return // not beneath if statement`
`194`	`194`	`}`
`195`	`195`	`var (`
`@@ -221,7 +221,7 @@ func canUseErrorsAsType(info types.Info, index typeindex.Index, curCall inspec`
`221`	`221`	`return // v used before/after if statement`
`222`	`222`	`}`
`223`	`223`	`}`
`224`		`- if !astutil.IsChildOf(curDef, edge.ValueSpec_Names) {`
	`224`	`+ if curDef.ParentEdgeKind() != edge.ValueSpec_Names {`
`225`	`225`	`return // v not declared by "var v T"`
`226`	`226`	`}`
`227`	`227`	`var (`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ func minmax(pass *analysis.Pass) (any, error) {`
`209`	`209`	`// (This case would require introducing another block`
`210`	`210`	`// if cond { ... } else { if a < b { lhs = rhs } }`
`211`	`211`	`// and checking that there is no following "else".)`
`212`		`- if astutil.IsChildOf(curIfStmt, edge.IfStmt_Else) {`
	`212`	`+ if curIfStmt.ParentEdgeKind() == edge.IfStmt_Else {`
`213`	`213`	`continue`
`214`	`214`	`}`
`215`	`215`
Original file line number	Diff line number	Diff line change
`@@ -220,15 +220,15 @@ func stditerators(pass *analysis.Pass) (any, error) {`
`220`	`220`	`)`
`221`	`221`
`222`	`222`	`// Analyze enclosing loop.`
`223`		`- switch first(curLenCall.ParentEdge()) {`
	`223`	`+ switch curLenCall.ParentEdgeKind() {`
`224`	`224`	`case edge.BinaryExpr_Y:`
`225`	`225`	`// pattern 1: for i := 0; i < x.Len(); i++ { ... }`
`226`	`226`	`var (`
`227`	`227`	`curCmp = curLenCall.Parent()`
`228`	`228`	`cmp = curCmp.Node().(*ast.BinaryExpr)`
`229`	`229`	`)`
`230`	`230`	`if cmp.Op != token.LSS \|\|`
`231`		`- !astutil.IsChildOf(curCmp, edge.ForStmt_Cond) {`
	`231`	`+ curCmp.ParentEdgeKind() != edge.ForStmt_Cond {`
`232`	`232`	`continue`
`233`	`233`	`}`
`234`	`234`	`if id, ok := cmp.X.(*ast.Ident); ok {`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ nextcand:`
`102`	`102`	`continue`
`103`	`103`	`}`
`104`	`104`
`105`		`- ek, _ := def.ParentEdge()`
	`105`	`+ ek := def.ParentEdgeKind()`
`106`	`106`	`if ek == edge.AssignStmt_Lhs &&`
`107`	`107`	`len(def.Parent().Node().(*ast.AssignStmt).Lhs) == 1 {`
`108`	`108`	`// Have: s := expr`
`@@ -274,10 +274,10 @@ nextcand:`
`274`	`274`	`)`
`275`	`275`	`for curUse := range index.Uses(v) {`
`276`	`276`	`// Strip enclosing parens around Ident.`
`277`		`- ek, _ := curUse.ParentEdge()`
	`277`	`+ ek := curUse.ParentEdgeKind()`
`278`	`278`	`for ek == edge.ParenExpr_X {`
`279`	`279`	`curUse = curUse.Parent()`
`280`		`- ek, _ = curUse.ParentEdge()`
	`280`	`+ ek = curUse.ParentEdgeKind()`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`// The rvalueUse must be the lexically last use.`