Merge branch 'master' into 12ya-patch

Author: 12ya

go/analysis/passes/printf/printf.go

@@ -22,6 +22,7 @@ import (
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
 	"golang.org/x/tools/internal/analysisinternal"
+	"golang.org/x/tools/internal/astutil"
 	"golang.org/x/tools/internal/fmtstr"
 	"golang.org/x/tools/internal/typeparams"
 	"golang.org/x/tools/internal/versions"
@@ -540,7 +541,7 @@ func checkPrintf(pass *analysis.Pass, fileVersion string, kind Kind, call *ast.C
 	firstArg := idx + 1 // Arguments are immediately after format string.
 	if !strings.Contains(format, "%") {
 		if len(call.Args) > firstArg {
-			pass.Reportf(call.Lparen, "%s call has arguments but no formatting directives", name)
+			pass.ReportRangef(call.Args[firstArg], "%s call has arguments but no formatting directives", name)
 		}
 		return
 	}
@@ -552,28 +553,29 @@ func checkPrintf(pass *analysis.Pass, fileVersion string, kind Kind, call *ast.C
 	if err != nil {
 		// All error messages are in predicate form ("call has a problem")
 		// so that they may be affixed into a subject ("log.Printf ").
-		pass.ReportRangef(call.Args[idx], "%s %s", name, err)
+		pass.ReportRangef(formatArg, "%s %s", name, err)
 		return
 	}
 
 	// index of the highest used index.
 	maxArgIndex := firstArg - 1
 	anyIndex := false
 	// Check formats against args.
-	for _, operation := range operations {
-		if operation.Prec.Index != -1 ||
-			operation.Width.Index != -1 ||
-			operation.Verb.Index != -1 {
+	for _, op := range operations {
+		if op.Prec.Index != -1 ||
+			op.Width.Index != -1 ||
+			op.Verb.Index != -1 {
 			anyIndex = true
 		}
-		if !okPrintfArg(pass, call, &maxArgIndex, firstArg, name, operation) {
+		rng := opRange(formatArg, op)
+		if !okPrintfArg(pass, call, rng, &maxArgIndex, firstArg, name, op) {
 			// One error per format is enough.
 			return
 		}
-		if operation.Verb.Verb == 'w' {
+		if op.Verb.Verb == 'w' {
 			switch kind {
 			case KindNone, KindPrint, KindPrintf:
-				pass.Reportf(call.Pos(), "%s does not support error-wrapping directive %%w", name)
+				pass.ReportRangef(rng, "%s does not support error-wrapping directive %%w", name)
 				return
 			}
 		}
@@ -594,6 +596,18 @@ func checkPrintf(pass *analysis.Pass, fileVersion string, kind Kind, call *ast.C
 	}
 }
 
+// opRange returns the source range for the specified printf operation,
+// such as the position of the %v substring of "...%v...".
+func opRange(formatArg ast.Expr, op *fmtstr.Operation) analysis.Range {
+	if lit, ok := formatArg.(*ast.BasicLit); ok {
+		start, end, err := astutil.RangeInStringLiteral(lit, op.Range.Start, op.Range.End)
+		if err == nil {
+			return analysisinternal.Range(start, end) // position of "%v"
+		}
+	}
+	return formatArg // entire format string
+}
+
 // printfArgType encodes the types of expressions a printf verb accepts. It is a bitmask.
 type printfArgType int
 
@@ -657,7 +671,7 @@ var printVerbs = []printVerb{
 // okPrintfArg compares the operation to the arguments actually present,
 // reporting any discrepancies it can discern, maxArgIndex was the index of the highest used index.
 // If the final argument is ellipsissed, there's little it can do for that.
-func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firstArg int, name string, operation *fmtstr.Operation) (ok bool) {
+func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, rng analysis.Range, maxArgIndex *int, firstArg int, name string, operation *fmtstr.Operation) (ok bool) {
 	verb := operation.Verb.Verb
 	var v printVerb
 	found := false
@@ -680,7 +694,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 
 	if !formatter {
 		if !found {
-			pass.ReportRangef(call, "%s format %s has unknown verb %c", name, operation.Text, verb)
+			pass.ReportRangef(rng, "%s format %s has unknown verb %c", name, operation.Text, verb)
 			return false
 		}
 		for _, flag := range operation.Flags {
@@ -690,7 +704,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 				continue
 			}
 			if !strings.ContainsRune(v.flags, rune(flag)) {
-				pass.ReportRangef(call, "%s format %s has unrecognized flag %c", name, operation.Text, flag)
+				pass.ReportRangef(rng, "%s format %s has unrecognized flag %c", name, operation.Text, flag)
 				return false
 			}
 		}
@@ -707,7 +721,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 	// If len(argIndexes)>0, we have something like %.*s and all
 	// indexes in argIndexes must be an integer.
 	for _, argIndex := range argIndexes {
-		if !argCanBeChecked(pass, call, argIndex, firstArg, operation, name) {
+		if !argCanBeChecked(pass, call, rng, argIndex, firstArg, operation, name) {
 			return
 		}
 		arg := call.Args[argIndex]
@@ -716,7 +730,7 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 			if reason != "" {
 				details = " (" + reason + ")"
 			}
-			pass.ReportRangef(call, "%s format %s uses non-int %s%s as argument of *", name, operation.Text, analysisinternal.Format(pass.Fset, arg), details)
+			pass.ReportRangef(rng, "%s format %s uses non-int %s%s as argument of *", name, operation.Text, analysisinternal.Format(pass.Fset, arg), details)
 			return false
 		}
 	}
@@ -738,12 +752,12 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 
 	// Now check verb's type.
 	verbArgIndex := operation.Verb.ArgIndex
-	if !argCanBeChecked(pass, call, verbArgIndex, firstArg, operation, name) {
+	if !argCanBeChecked(pass, call, rng, verbArgIndex, firstArg, operation, name) {
 		return false
 	}
 	arg := call.Args[verbArgIndex]
 	if isFunctionValue(pass, arg) && verb != 'p' && verb != 'T' {
-		pass.ReportRangef(call, "%s format %s arg %s is a func value, not called", name, operation.Text, analysisinternal.Format(pass.Fset, arg))
+		pass.ReportRangef(rng, "%s format %s arg %s is a func value, not called", name, operation.Text, analysisinternal.Format(pass.Fset, arg))
 		return false
 	}
 	if reason, ok := matchArgType(pass, v.typ, arg); !ok {
@@ -755,14 +769,14 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, maxArgIndex *int, firs
 		if reason != "" {
 			details = " (" + reason + ")"
 		}
-		pass.ReportRangef(call, "%s format %s has arg %s of wrong type %s%s", name, operation.Text, analysisinternal.Format(pass.Fset, arg), typeString, details)
+		pass.ReportRangef(rng, "%s format %s has arg %s of wrong type %s%s", name, operation.Text, analysisinternal.Format(pass.Fset, arg), typeString, details)
 		return false
 	}
 	// Detect recursive formatting via value's String/Error methods.
 	// The '#' flag suppresses the methods, except with %x, %X, and %q.
 	if v.typ&argString != 0 && v.verb != 'T' && (!strings.Contains(operation.Flags, "#") || strings.ContainsRune("qxX", v.verb)) {
 		if methodName, ok := recursiveStringer(pass, arg); ok {
-			pass.ReportRangef(call, "%s format %s with arg %s causes recursive %s method call", name, operation.Text, analysisinternal.Format(pass.Fset, arg), methodName)
+			pass.ReportRangef(rng, "%s format %s with arg %s causes recursive %s method call", name, operation.Text, analysisinternal.Format(pass.Fset, arg), methodName)
 			return false
 		}
 	}
@@ -846,7 +860,7 @@ func isFunctionValue(pass *analysis.Pass, e ast.Expr) bool {
 // argCanBeChecked reports whether the specified argument is statically present;
 // it may be beyond the list of arguments or in a terminal slice... argument, which
 // means we can't see it.
-func argCanBeChecked(pass *analysis.Pass, call *ast.CallExpr, argIndex, firstArg int, operation *fmtstr.Operation, name string) bool {
+func argCanBeChecked(pass *analysis.Pass, call *ast.CallExpr, rng analysis.Range, argIndex, firstArg int, operation *fmtstr.Operation, name string) bool {
 	if argIndex <= 0 {
 		// Shouldn't happen, so catch it with prejudice.
 		panic("negative argIndex")
@@ -863,7 +877,7 @@ func argCanBeChecked(pass *analysis.Pass, call *ast.CallExpr, argIndex, firstArg
 	// There are bad indexes in the format or there are fewer arguments than the format needs.
 	// This is the argument number relative to the format: Printf("%s", "hi") will give 1 for the "hi".
 	arg := argIndex - firstArg + 1 // People think of arguments as 1-indexed.
-	pass.ReportRangef(call, "%s format %s reads arg #%d, but call has %v", name, operation.Text, arg, count(len(call.Args)-firstArg, "arg"))
+	pass.ReportRangef(rng, "%s format %s reads arg #%d, but call has %v", name, operation.Text, arg, count(len(call.Args)-firstArg, "arg"))
 	return false
 }
 

go/analysis/passes/tests/tests.go

@@ -447,18 +447,6 @@ func checkExampleName(pass *analysis.Pass, fn *ast.FuncDecl) {
 	}
 }
 
-type tokenRange struct {
-	p, e token.Pos
-}
-
-func (r tokenRange) Pos() token.Pos {
-	return r.p
-}
-
-func (r tokenRange) End() token.Pos {
-	return r.e
-}
-
 func checkTest(pass *analysis.Pass, fn *ast.FuncDecl, prefix string) {
 	// Want functions with 0 results and 1 parameter.
 	if fn.Type.Results != nil && len(fn.Type.Results.List) > 0 ||
@@ -476,8 +464,9 @@ func checkTest(pass *analysis.Pass, fn *ast.FuncDecl, prefix string) {
 	if tparams := fn.Type.TypeParams; tparams != nil && len(tparams.List) > 0 {
 		// Note: cmd/go/internal/load also errors about TestXXX and BenchmarkXXX functions with type parameters.
 		// We have currently decided to also warn before compilation/package loading. This can help users in IDEs.
-		at := tokenRange{tparams.Opening, tparams.Closing}
-		pass.ReportRangef(at, "%s has type parameters: it will not be run by go test as a %sXXX function", fn.Name.Name, prefix)
+		pass.ReportRangef(analysisinternal.Range(tparams.Opening, tparams.Closing),
+			"%s has type parameters: it will not be run by go test as a %sXXX function",
+			fn.Name.Name, prefix)
 	}
 
 	if !isTestSuffix(fn.Name.Name[len(prefix):]) {

go/analysis/unitchecker/separate_test.go

@@ -222,7 +222,7 @@ func MyPrintf(format string, args ...any) {
 	// Observe that the example produces a fact-based diagnostic
 	// from separate analysis of "main", "lib", and "fmt":
 
-	const want = `/main/main.go:6:2: [printf] separate/lib.MyPrintf format %s has arg 123 of wrong type int`
+	const want = `/main/main.go:6:16: [printf] separate/lib.MyPrintf format %s has arg 123 of wrong type int`
 	sort.Strings(allDiagnostics)
 	if got := strings.Join(allDiagnostics, "\n"); got != want {
 		t.Errorf("Got: %s\nWant: %s", got, want)

gopls/doc/analyzers.md

@@ -1875,7 +1875,7 @@ In a type switch like the following
     type T struct{}
     func (T) Read(b []byte) (int, error) { return 0, nil }
 
-    var v interface{} = T{}
+    var v any = T{}
 
     switch v.(type) {
     case io.Reader:
@@ -1893,7 +1893,7 @@ Another example:
     func (T) Read(b []byte) (int, error) { return 0, nil }
     func (T) Close() error { return nil }
 
-    var v interface{} = T{}
+    var v any = T{}
 
     switch v.(type) {
     case io.Reader:
@@ -3488,6 +3488,96 @@ Package documentation: [framepointer](https://pkg.go.dev/golang.org/x/tools/go/a
 
 The gofix analyzer inlines functions and constants that are marked for inlining.
 
+## Functions
+
+Given a function that is marked for inlining, like this one:
+
+	//go:fix inline
+	func Square(x int) int { return Pow(x, 2) }
+
+this analyzer will recommend that calls to the function elsewhere, in the same
+or other packages, should be inlined.
+
+Inlining can be used to move off of a deprecated function:
+
+	// Deprecated: prefer Pow(x, 2).
+	//go:fix inline
+	func Square(x int) int { return Pow(x, 2) }
+
+It can also be used to move off of an obsolete package,
+as when the import path has changed or a higher major version is available:
+
+	package pkg
+
+	import pkg2 "pkg/v2"
+
+	//go:fix inline
+	func F() { pkg2.F(nil) }
+
+Replacing a call pkg.F() by pkg2.F(nil) can have no effect on the program,
+so this mechanism provides a low-risk way to update large numbers of calls.
+We recommend, where possible, expressing the old API in terms of the new one
+to enable automatic migration.
+
+The inliner takes care to avoid behavior changes, even subtle ones,
+such as changes to the order in which argument expressions are
+evaluated. When it cannot safely eliminate all parameter variables,
+it may introduce a "binding declaration" of the form
+
+	var params = args
+
+to evaluate argument expressions in the correct order and bind them to
+parameter variables. Since the resulting code transformation may be
+stylistically suboptimal, such inlinings may be disabled by specifying
+the -gofix.allow_binding_decl=false flag to the analyzer driver.
+
+(In cases where it is not safe to "reduce" a call—that is, to replace
+a call f(x) by the body of function f, suitably substituted—the
+inliner machinery is capable of replacing f by a function literal,
+func(){...}(). However, the gofix analyzer discards all such
+"literalizations" unconditionally, again on grounds of style.)
+
+## Constants
+
+Given a constant that is marked for inlining, like this one:
+
+	//go:fix inline
+	const Ptr = Pointer
+
+this analyzer will recommend that uses of Ptr should be replaced with Pointer.
+
+As with functions, inlining can be used to replace deprecated constants and
+constants in obsolete packages.
+
+A constant definition can be marked for inlining only if it refers to another
+named constant.
+
+The "//go:fix inline" comment must appear before a single const declaration on its own,
+as above; before a const declaration that is part of a group, as in this case:
+
+	const (
+	   C = 1
+	   //go:fix inline
+	   Ptr = Pointer
+	)
+
+or before a group, applying to every constant in the group:
+
+	//go:fix inline
+	const (
+		Ptr = Pointer
+	    Val = Value
+	)
+
+The proposal https://go.dev/issue/32816 introduces the "//go:fix" directives.
+
+You can use this (officially unsupported) command to apply gofix fixes en masse:
+
+	$ go run golang.org/x/tools/gopls/internal/analysis/gofix/cmd/gofix@latest -test ./...
+
+(Do not use "go get -tool" to add gopls as a dependency of your
+module; gopls commands must be built from their release branch.)
+
 Default: on.
 
 Package documentation: [gofix](https://pkg.go.dev/golang.org/x/tools/internal/gofix)

gopls/go.mod

@@ -11,10 +11,10 @@ require (
 	golang.org/x/sys v0.33.0
 	golang.org/x/telemetry v0.0.0-20250417124945-06ef541f3fa3
 	golang.org/x/text v0.25.0
-	golang.org/x/tools v0.30.0
+	golang.org/x/tools v0.33.1-0.20250521210010-423c5afcceff
 	golang.org/x/vuln v1.1.4
 	gopkg.in/yaml.v3 v3.0.1
-	honnef.co/go/tools v0.6.1
+	honnef.co/go/tools v0.7.0-0.dev.0.20250523013057-bbc2f4dd71ea
 	mvdan.cc/gofumpt v0.7.0
 	mvdan.cc/xurls/v2 v2.6.0
 )

gopls/go.sum

@@ -59,8 +59,8 @@ gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogR
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.6.1 h1:R094WgE8K4JirYjBaOpz/AvTyUu/3wbmAoskKN/pxTI=
-honnef.co/go/tools v0.6.1/go.mod h1:3puzxxljPCe8RGJX7BIy1plGbxEOZni5mR2aXe3/uk4=
+honnef.co/go/tools v0.7.0-0.dev.0.20250523013057-bbc2f4dd71ea h1:fj8r9irJSpolAGUdZBxJIRY3lLc4jH2Dt4lwnWyWwpw=
+honnef.co/go/tools v0.7.0-0.dev.0.20250523013057-bbc2f4dd71ea/go.mod h1:EPDDhEZqVHhWuPI5zPAsjU0U7v9xNIWjoOVyZ5ZcniQ=
 mvdan.cc/gofumpt v0.7.0 h1:bg91ttqXmi9y2xawvkuMXyvAA/1ZGJqYAEGjXuP0JXU=
 mvdan.cc/gofumpt v0.7.0/go.mod h1:txVFJy/Sc/mvaycET54pV8SW8gWxTlUuGHVEcncmNUo=
 mvdan.cc/xurls/v2 v2.6.0 h1:3NTZpeTxYVWNSokW3MKeyVkz/j7uYXYiMtXRUfmjbgI=