go/analysis/passes/modernize: errorsastype: errors.As -> AsType[T]

This CL adds a modernizer that replaces simple uses of
errors.As such as:

	var myerr *MyErr
	if errors.As(err, &myerr) {
		handle(myerr)
	}

with the less error-prone generic [errors.AsType] function,
introduced in Go 1.26:

	if myerr, ok := errors.AsType[*MyErr](err); ok {
		handle(myerr)
	}

Also, redo the existing errorsas vet check (for actual bugs)
to take advantage of newer analysis features.

Fixes golang/go#75692
Updates golang/go#51945

Change-Id: I56bd5370449daeacedf5634e46c2a29697dcbf19
Reviewed-on: https://go-review.googlesource.com/c/tools/+/708895
Reviewed-by: Robert Findley <rfindley@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: adonovan

go/analysis/passes/errorsas/errorsas.go

@@ -12,22 +12,20 @@ import (
 	"go/types"
 
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
-	"golang.org/x/tools/go/ast/inspector"
-	"golang.org/x/tools/go/types/typeutil"
-	"golang.org/x/tools/internal/analysisinternal"
+	typeindexanalyzer "golang.org/x/tools/internal/analysisinternal/typeindex"
+	"golang.org/x/tools/internal/typesinternal/typeindex"
 )
 
 const Doc = `report passing non-pointer or non-error values to errors.As
 
-The errorsas analysis reports calls to errors.As where the type
+The errorsas analyzer reports calls to errors.As where the type
 of the second argument is not a pointer to a type implementing error.`
 
 var Analyzer = &analysis.Analyzer{
 	Name:     "errorsas",
 	Doc:      Doc,
 	URL:      "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/errorsas",
-	Requires: []*analysis.Analyzer{inspect.Analyzer},
+	Requires: []*analysis.Analyzer{typeindexanalyzer.Analyzer},
 	Run:      run,
 }
 
@@ -39,51 +37,48 @@ func run(pass *analysis.Pass) (any, error) {
 		return nil, nil
 	}
 
-	if !analysisinternal.Imports(pass.Pkg, "errors") {
-		return nil, nil // doesn't directly import errors
-	}
-
-	inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	var (
+		index = pass.ResultOf[typeindexanalyzer.Analyzer].(*typeindex.Index)
+		info  = pass.TypesInfo
+	)
 
-	nodeFilter := []ast.Node{
-		(*ast.CallExpr)(nil),
-	}
-	inspect.Preorder(nodeFilter, func(n ast.Node) {
-		call := n.(*ast.CallExpr)
-		obj := typeutil.Callee(pass.TypesInfo, call)
-		if !analysisinternal.IsFunctionNamed(obj, "errors", "As") {
-			return
-		}
+	for curCall := range index.Calls(index.Object("errors", "As")) {
+		call := curCall.Node().(*ast.CallExpr)
 		if len(call.Args) < 2 {
-			return // not enough arguments, e.g. called with return values of another function
+			continue // spread call: errors.As(pair())
 		}
-		if err := checkAsTarget(pass, call.Args[1]); err != nil {
+
+		// Check for incorrect arguments.
+		if err := checkAsTarget(info, call.Args[1]); err != nil {
 			pass.ReportRangef(call, "%v", err)
+			continue
 		}
-	})
+	}
 	return nil, nil
 }
 
-var errorType = types.Universe.Lookup("error").Type()
-
 // checkAsTarget reports an error if the second argument to errors.As is invalid.
-func checkAsTarget(pass *analysis.Pass, e ast.Expr) error {
-	t := pass.TypesInfo.Types[e].Type
-	if it, ok := t.Underlying().(*types.Interface); ok && it.NumMethods() == 0 {
-		// A target of interface{} is always allowed, since it often indicates
+func checkAsTarget(info *types.Info, e ast.Expr) error {
+	t := info.Types[e].Type
+	if types.Identical(t.Underlying(), anyType) {
+		// A target of any is always allowed, since it often indicates
 		// a value forwarded from another source.
 		return nil
 	}
 	pt, ok := t.Underlying().(*types.Pointer)
 	if !ok {
 		return errors.New("second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type")
 	}
-	if pt.Elem() == errorType {
+	if types.Identical(pt.Elem(), errorType) {
 		return errors.New("second argument to errors.As should not be *error")
 	}
-	_, ok = pt.Elem().Underlying().(*types.Interface)
-	if ok || types.Implements(pt.Elem(), errorType.Underlying().(*types.Interface)) {
-		return nil
+	if !types.IsInterface(pt.Elem()) && !types.AssignableTo(pt.Elem(), errorType) {
+		return errors.New("second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type")
 	}
-	return errors.New("second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type")
+	return nil
 }
+
+var (
+	anyType   = types.Universe.Lookup("any").Type()
+	errorType = types.Universe.Lookup("error").Type()
+)

go/analysis/passes/errorsas/errorsas_test.go

@@ -2,8 +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.13
-
 package errorsas_test
 
 import (

go/analysis/passes/errorsas/main.go

@@ -0,0 +1,16 @@
+// 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.
+
+//go:build ignore
+
+// The errorsas command applies the golang.org/x/tools/go/analysis/passes/errorsas
+// analysis to the specified packages of Go source code.
+package main
+
+import (
+	"golang.org/x/tools/go/analysis/passes/errorsas"
+	"golang.org/x/tools/go/analysis/singlechecker"
+)
+
+func main() { singlechecker.Main(errorsas.Analyzer) }

go/analysis/passes/modernize/doc.go

@@ -89,6 +89,28 @@ The any analyzer suggests replacing uses of the empty interface type,
 `interface{}`, with the `any` alias, which was introduced in Go 1.18.
 This is a purely stylistic change that makes code more readable.
 
+# Analyzer errorsastype
+
+errorsastype: replace errors.As with errors.AsType[T]
+
+This analyzer suggests fixes to simplify uses of [errors.As] of
+this form:
+
+	var myerr *MyErr
+	if errors.As(err, &myerr) {
+		handle(myerr)
+	}
+
+by using the less error-prone generic [errors.AsType] function,
+introduced in Go 1.26:
+
+	if myerr, ok := errors.AsType[*MyErr](err); ok {
+		handle(myerr)
+	}
+
+The fix is only offered if the var declaration has the form shown and
+there are no uses of myerr outside the if statement.
+
 # Analyzer fmtappendf
 
 fmtappendf: replace []byte(fmt.Sprintf) with fmt.Appendf