cmd/vet: report printf calls with non-const format and no args #60529

adonovan · 2023-05-31T03:56:47Z

A common mistake not caught by the existing printf vet checker is Printf(v), where v is a variable, when the user intended Printf("%s", v). If the value of v contains an unexpected percent sign, the program has a bug.

I feel like I see this mistake in Google Go readability reviews at least once a week, and the Google corpus shows up hundreds of violations with what looks like close to 100% precision:
https://source.corp.google.com/search?q=%5B.%5DPrintf%5C(%5Ba-z%5D*%5C)%20lang:go&sq=
(Apologies, link to Google internal service.)

Printf and similar functions are usually called with a literal format string, followed by zero or more arguments. Occasionally the format string argument is a variable, either because preceding logic chooses between two alternative formats, or because the call appears in a wrapper function that takes both the format and its arguments as parameters, but in both those cases the format is followed by other arguments. It's hard to imagine any good reason one would call printf with a variable format string and no arguments.

We should make the printf checker report this error.

@timothy-king @findleyr

The text was updated successfully, but these errors were encountered:

adonovan · 2023-05-31T04:11:06Z

It's hard to imagine any good reason one would call printf with a variable format string and no arguments.

Ok, I imagined one (having found https://github.com/golang/tools/blob/master/gopls/internal/lsp/cache/load.go#L378):
you want to call a printf wrapper function such as fmt.Errorf with a choice of two format strings both of which you know are percent-free, and there is no non-Printf variant ("fmt.Error") of the function in question.

var msg string
if cond {
    msg = "percent-free error message a"
} else {
    msg = "percent-free error message b"
}
return fmt.Errorf(msg)

The code would be improved by calling fmt.Errorf("%s", msg), since it would be safer in the face of later changes to the logic that assigns msg, but it's not actually wrong.

robpike · 2023-05-31T04:36:27Z

The technique you're forbidding is used to generate messages in different languages:

greet := map[string]string{ "en": "hello", "fr": "bonjour"}
fmt.Printf(greet[lang])

(In fact, the $[1] notation is there precisely for the general form of this when word order can vary between languages.)

I realize in this case you're arguing for the case with zero arguments, and my example is a bit contrived that way, but still, to me it feels too useful a technique to be forbidden outright. And there are other ways to do this, of course. Yet, one person's bad code is another's useful technique.

ianlancetaylor · 2023-05-31T14:15:00Z

@robpike Sorry, I'm not sure I understand your example. The proposed checker wouldn't report anything for that code.
And wouldn't that use fmt.Println, not fmt.Printf?

findleyr · 2023-05-31T14:19:06Z

I guess the question is whether it should be OK to use fmt.Printf when fmt.Print would do. By comparison, it is generally accepted that fmt.Errorf is OK to use instead of errors.New even when there are no formatted arguments. Of course, that is typically with a constant error string.

I am not sure if this rule should be applied to Printf wrappers (as with other checks in the printf analyzer). Often Printf wrappers have no corresponding Print wrapper alternative. EDIT: of course the user could always convert to ...Printf("%s", msg), but may require a lot of code to be updated.

robpike · 2023-06-01T00:15:49Z

@robpike Sorry, I'm not sure I understand your example. The proposed checker wouldn't report anything for that code. And wouldn't that use fmt.Println, not fmt.Printf?

Sorry, editing mistake. Example updated to drop the user name. And yes, you could use Println instead, but @findleyr gets to the nub: Do we force (through vet) people to use a different printer when there are no arguments? That's really what this is about.

timothy-king · 2023-06-01T04:05:14Z

If the value of v contains an unexpected percent sign, the program has a bug.

If we know "v" contains a verb this is clearly a bug. Maybe it is okay to warn if v may conditionally contain a verb?

I feel like I see this mistake in Google Go readability reviews at least once a week, and the Google corpus shows up hundreds of violations with what looks like close to 100% precision:

For the handful I have looked at (~5), I am a bit wishy-washy on whether these are buggy. This particular pattern seems common:

        msg := fmt.Sprintf(format, args...)
	// do something else with msg
	logger.Printf(msg)

Printf("%s", msg) or Print does seem like what is intended the examples I have seen. To know that this is bug though seems to require knowing about args, which is often out of scope.

(Another example I have seen is when msg is a constant. The existing checker should already work IIUC.)

adonovan · 2024-04-08T21:26:22Z

To know that this is bug though seems to require knowing about args, which is often out of scope.

That's true, but in all the examples I've looked it, it requires knowledge of a non-local and undocumented invariant that the args are percent-free.

I would usually run a measurement over the module mirror corpus and then analyze the rate of true and false positives, but a quick experiment on a single repo (kubernetes) turned up plenty of findings, nearly all bugs.

Here's the new logic:

tools$ git diff
diff --git a/go/analysis/passes/printf/printf.go b/go/analysis/passes/printf/printf.go
index 3235019258..a0ecc5d2eb 100644
--- a/go/analysis/passes/printf/printf.go
+++ b/go/analysis/passes/printf/printf.go
@@ -536,6 +536,18 @@ type formatState struct {
 
 // checkPrintf checks a call to a formatted print routine such as Printf.
 func checkPrintf(pass *analysis.Pass, kind Kind, call *ast.CallExpr, fn *types.Func) {
+       // Calls to fmt.Printf(msg), with a non-constant
+       // format string and no arguments, seem to be a common
+       // mistake.
+       if len(call.Args) == 1 && pass.TypesInfo.Types[call.Args[0]].Value == nil {
+               pass.Reportf(call.Lparen,
+                       "non-constant format string in call to %s (did you mean %s(\"%%s\", %s)?)",
+                       fn.FullName(),
+                       fn.Name(),
+                       analysisutil.Format(pass.Fset, call.Args[0]))
+               return
+       }
+

And here are a random 25 of its 182 findings:

https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/statefulset/stateful_set_test.go#L894: non-constant format string in call to (*testing.common).Errorf (did you mean Errorf("%s", onPolicy("Expected set to stay at two replicas"))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/volume/expand/expand_controller.go#L266: non-constant format string in call to fmt.Errorf (did you mean Errorf("%s", errorMsg)?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/secret/secret.go#L286: non-constant format string in call to fmt.Errorf (did you mean Errorf("%s", errMsg)?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/test/e2e_node/util_sriov.go#L47: non-constant format string in call to k8s.io/kubernetes/test/e2e/framework/skipper.Skipf (did you mean Skipf("%s", msg)?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/test/images/agnhost/crd-conversion-webhook/converter/framework.go#L129: non-constant format string in call to k8s.io/klog/v2.Errorf (did you mean Errorf("%s", msg)?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/nodelifecycle/node_lifecycle_controller_test.go#L2562: non-constant format string in call to (*testing.common).Errorf (did you mean Errorf("%s", err.Error())?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/test/e2e/framework/statefulset/rest.go#L53: non-constant format string in call to fmt.Sprintf (did you mean Sprintf("%s", "creating " + ss.Name + " service")?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/util/operationexecutor/operation_generator.go#L1610: non-constant format string in call to k8s.io/klog/v2.Warningf (did you mean Warningf("%s", volumeToDetach.GenerateMsgDetailed("Node not found on API server. DetachVolume will skip safe to detach check", ""))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/downwardapi/downwardapi_test.go#L361: non-constant format string in call to (*testing.common).Errorf (did you mean Errorf("%s", err.Error())?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/csi/csi_block.go#L411: non-constant format string in call to (k8s.io/klog/v2.Verbose).Infof (did you mean Infof("%s", log("blockMapper.unpublishVolumeForBlock NodeUnpublished successfully [%s]", publishPath))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/csi/csi_block.go#L215: non-constant format string in call to (k8s.io/klog/v2.Verbose).Infof (did you mean Infof("%s", log("blockMapper.publishVolumeForBlock called"))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/statefulset/stateful_set_test.go#L891: non-constant format string in call to (*testing.common).Errorf (did you mean Errorf("%s", onPolicy("Could not get scaled down StatefulSet: %v", err))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/test/integration/garbagecollector/garbage_collector_test.go#L698: non-constant format string in call to (*testing.common).Fatalf (did you mean Fatalf("%s", errString)?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/test/e2e/upgrades/apps/etcd.go#L149: non-constant format string in call to fmt.Errorf (did you mean Errorf("%s", string(b))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/util/operationexecutor/operation_generator.go#L831: non-constant format string in call to k8s.io/klog/v2.Errorf (did you mean Errorf("%s", volumeToMount.GenerateErrorDetailed("MountVolume.MarkVolumeMountAsUncertain failed", t).Error())?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/test/e2e/windows/gmsa_full.go#L194: non-constant format string in call to k8s.io/kubernetes/test/e2e/framework.Failf (did you mean Failf("%s", err.Error())?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/csi/csi_block.go#L140: non-constant format string in call to (k8s.io/klog/v2.Verbose).Infof (did you mean Infof("%s", log("blockMapper.GetPodDeviceMapPath [path=%s; name=%s]", path, m.specName))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/statefulset/stateful_set_test.go#L913: non-constant format string in call to (*testing.common).Errorf (did you mean Errorf("%s", onPolicy("Claim ref unexpectedly changed: %v", refs))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/csi/csi_mounter.go#L445: non-constant format string in call to (k8s.io/klog/v2.Verbose).Infof (did you mean Infof("%s", log("Unmounter.TearDownAt successfully unmounted dir [%s]", dir))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/csi/csi_plugin.go#L842: non-constant format string in call to (k8s.io/klog/v2.Verbose).Infof (did you mean Infof("%s", log("CSIDriver %q not found, not adding pod information", driverName))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/util/operationexecutor/operation_generator.go#L1239: non-constant format string in call to k8s.io/klog/v2.Errorf (did you mean Errorf("%s", volumeToMount.GenerateErrorDetailed("MountVolume.MarkVolumeMountAsUncertain failed", err).Error())?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/util/operationexecutor/operation_generator.go#L1467: non-constant format string in call to k8s.io/klog/v2.Infof (did you mean Infof("%s", deviceToDetach.GenerateMsgDetailed("UnmapDevice succeeded", ""))?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/volume/util/operationexecutor/operation_executor.go#L367: non-constant format string in call to fmt.Errorf (did you mean Errorf("%s", detailedMsg)?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/podautoscaler/horizontal.go#L416: non-constant format string in call to fmt.Errorf (did you mean Errorf("%s", errMsg)?)
https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/statefulset/stateful_set_test.go#L903: non-constant format string in call to (*testing.common).Errorf (did you mean Errorf("%s", onPolicy("Unexpected change to condemned pvc ownerRefs: %v", refs))?)

All but one are true positives: bugs (sometimes more than one in the same call!). The one false positive was of the form:

var s = "benign"
fmt.Printf(s)

So that's a 96% success rate.

timothy-king · 2024-04-09T17:57:32Z

I was looking into https://go-mod-viewer.appspot.com/k8s.io/[email protected]/pkg/controller/statefulset/stateful_set_test.go#L891: non-constant format string in call to (*testing.common).Errorf (did you mean Errorf("%s", onPolicy("Could not get scaled down StatefulSet: %v", err))?)

   834  		onPolicy := func(msg string, args ...interface{}) string {
   835  			return fmt.Sprintf(fmt.Sprintf("(%s) %s", policy, msg), args...)
   836  		}
   ...
   891  			t.Errorf(onPolicy("Could not get scaled down StatefulSet: %v", err))

The diagnostic given on t.Errorf seems correct to me. Should be t.Error. (Diagnostic should maybe say that.) The outer fmt.Sprintf(...) is debatable though. The intention here is to copy the %v from msg and use it as a formatting string. This is debatable style, but it should work. Just kinda interesting that something immediately adjacent to the example illustrated something that should not be warned on. This example would not be warned on due to len(call.Args) == 1.

timothy-king · 2024-04-09T18:03:10Z

+       if len(call.Args) == 1 && pass.TypesInfo.Types[call.Args[0]].Value == nil {

call.Args[0] could be a function call. We should also check that if call.Args[0]'s type is a tuple, that it is 1 element.

adonovan · 2024-04-09T18:12:46Z

The outer fmt.Sprintf(...) is debatable though. The intention here is to copy the %v from msg and use it as a formatting string. This is debatable style, but it should work.

The code assumes that that the result of applying %s to policy (i.e. calling the String method of StatefulSetPersistentVolumeClaimRetentionPolicy, a protocol message) is percent-free. In this particular test, that is true, but in general, the string of this type contains arbitrary characters, and would cause this formatting to fail. So I would describe this as a latent bug just waiting for someone to add a new row to the test table.

Just kinda interesting that something immediately adjacent to the example illustrated something that should not be warned on. This example would not be warned on due to len(call.Args) == 1.

Yes, the lesson is that non-const formats are often a mistake for any value of len(Args), but they are nearly always a mistake for len(Args)=0.

rsc · 2024-04-10T18:39:38Z

Side note but please do not add "did you mean" to error messages. Report the problem, then stop.

rsc · 2024-04-10T18:42:45Z

This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group

rsc · 2024-04-24T17:21:36Z

The Kubernetes results definitely look like mostly/all bugs, but we should try more of the ecosystem to estimate the false positive rate. Thanks.

dominikh · 2024-04-24T18:10:52Z

Note that this corresponds to Staticcheck's SA1006, which might skew your estimates.

adonovan · 2024-04-24T21:57:39Z

Running across a sample of 13,000 modules in the module mirror corpus, I got about 50,000 unique diagnostics in 3847 modules. Below are 100 diagnostics selected at random. I sampled a couple dozen and all looked like latent bugs.

rsc · 2024-05-08T17:27:21Z

We should drop the 'did you mean' but otherwise it looks like high-quality signal.

rsc · 2024-05-08T21:24:20Z

Have all remaining concerns about this proposal been addressed?

The proposal is to report calls to printf-like functions in which the format is a non-constant string and there are no arguments. In the ecosystem these are overwhelmingly misuses where the caller has prepared arguments for a print-like function, not a printf-like function.

rsc · 2024-05-15T13:39:21Z

By the way, while we should definitely drop "did you mean" from the analyzer diagnostic text, it would be completely reasonable to make that code a SuggestedFix in the Diagnostic for people using the analyzer in IDEs.

The cmd/vet in Go 1.24 reports printf calls with non-const format and no args, causing one test in logp to fail. See golang/go#60529. ``` $ go install golang.org/dl/gotip@latest $ gotip download $ gotip test ./logp -count=1 logp/core_test.go:714:7: non-constant format string in call to github.com/elastic/elastic-agent-libs/logp.Info FAIL github.com/elastic/elastic-agent-libs/logp [build failed] ```

``` $ make GO=gotip build gotip version go version devel go1.24-4865aadc Fri Nov 22 05:22:24 2024 +0000 linux/amd64 gofmt (simplify) vet dump_region/main.go:59:14: non-constant format string in call to fmt.Printf pkg/check/privilege.go:146:51: non-constant format string in call to github.com/pingcap/tidb-tools/pkg/check.NewError pkg/check/table_structure.go:130:19: non-constant format string in call to github.com/pingcap/tidb-tools/pkg/check.NewError pkg/check/table_structure.go:136:19: non-constant format string in call to github.com/pingcap/tidb-tools/pkg/check.NewError importer/config.go:73:14: non-constant format string in call to fmt.Printf make: *** [Makefile:86: check] Error 1 ``` Related: golang/go#60529

dmitshur · 2024-11-26T20:23:21Z

This vet change is new to Go 1.24 and still needs to be mentioned in Go 1.24 release notes, right? Reopening with a release blocker label to track that.

gopherbot · 2024-11-26T20:35:08Z

Change https://go.dev/cl/631682 mentions this issue: doc/next: add release note for vet on Printf(s) with non-const s

@pierreprinetti

We were incorrectly using 'fmt.Printf', 'fmt.Errorf' and 't.Logf' with non-template strings/no arguments. The fix to this is replace these calls with the non-suffixed variants. There are many users of 'fmt.Fprint' - too many to do by hand - so this replacement was resolved using 'sed': sed 's/Fprintf/Fprint/g' -i $(ag fmt.Fprintf -l) We then manually fix the 25 cases where 'fmt.Fprintf' is actually warranted and manually replaced the errant users of 'fmt.Errorf' and 't.Logf'. We also rework 'internal/acceptance/clients/clients.go' slightly to make the code a bit clearer. PS: This is apparently going to be an issue in go 1.24 (specifically in 'go vet') [1] so this is not just golangci-lint being annoying. @pierreprinetti, that's directed at you ;) [1] golang/go#60529 Signed-off-by: Stephen Finucane <[email protected]>

@pierreprinetti

We were incorrectly using 'fmt.Printf', 'fmt.Errorf' and 't.Logf' with non-template strings/no arguments. The fix to this is replace these calls with the non-suffixed variants. There are many users of 'fmt.Fprint' - too many to do by hand - so this replacement was resolved using 'sed': sed 's/Fprintf/Fprint/g' -i $(ag fmt.Fprintf -l) We then manually fix the 25 cases where 'fmt.Fprintf' is actually warranted and manually replaced the errant users of 'fmt.Errorf' and 't.Logf'. We also rework 'internal/acceptance/clients/clients.go' slightly to make the code a bit clearer. PS: This is apparently going to be an issue in go 1.24 (specifically in 'go vet') [1] so this is not just golangci-lint being annoying. @pierreprinetti, that's directed at you ;) [1] golang/go#60529 Signed-off-by: Stephen Finucane <[email protected]>

@pierreprinetti

We were incorrectly using 'fmt.Printf', 'fmt.Errorf' and 't.Logf' with non-template strings/no arguments. The fix to this is replace these calls with the non-suffixed variants. There are many users of 'fmt.Fprint' - too many to do by hand - so this replacement was resolved using 'sed': sed 's/Fprintf/Fprint/g' -i $(ag fmt.Fprintf -l) We then manually fix the 25 cases where 'fmt.Fprintf' is actually warranted and manually replaced the errant users of 'fmt.Errorf' and 't.Logf'. We also rework 'internal/acceptance/clients/clients.go' slightly to make the code a bit clearer. PS: This is apparently going to be an issue in go 1.24 (specifically in 'go vet') [1] so this is not just golangci-lint being annoying. @pierreprinetti, that's directed at you ;) [1] golang/go#60529 Signed-off-by: Stephen Finucane <[email protected]>

@pierreprinetti

We were incorrectly using 'fmt.Printf', 'fmt.Errorf' and 't.Logf' with non-template strings/no arguments. The fix to this is replace these calls with the non-suffixed variants. There are many users of 'fmt.Fprint' - too many to do by hand - so this replacement was resolved using 'sed': sed 's/Fprintf/Fprint/g' -i $(ag fmt.Fprintf -l) We then manually fix the 25 cases where 'fmt.Fprintf' is actually warranted and manually replaced the errant users of 'fmt.Errorf' and 't.Logf'. We also rework 'internal/acceptance/clients/clients.go' slightly to make the code a bit clearer. PS: This is apparently going to be an issue in go 1.24 (specifically in 'go vet') [1] so this is not just golangci-lint being annoying. @pierreprinetti, that's directed at you ;) [1] golang/go#60529 Signed-off-by: Stephen Finucane <[email protected]>

@pierreprinetti

We were incorrectly using 'fmt.Printf', 'fmt.Errorf' and 't.Logf' with non-template strings/no arguments. The fix to this is replace these calls with the non-suffixed variants. There are many users of 'fmt.Fprint' - too many to do by hand - so this replacement was resolved using 'sed': sed 's/Fprintf/Fprint/g' -i $(ag fmt.Fprintf -l) We then manually fix the 25 cases where 'fmt.Fprintf' is actually warranted and manually replaced the errant users of 'fmt.Errorf' and 't.Logf'. We also rework 'internal/acceptance/clients/clients.go' slightly to make the code a bit clearer. PS: This is apparently going to be an issue in go 1.24 (specifically in 'go vet') [1] so this is not just golangci-lint being annoying. @pierreprinetti, that's directed at you ;) [1] golang/go#60529 Signed-off-by: Stephen Finucane <[email protected]>

@pierreprinetti

We were incorrectly using 'fmt.Printf', 'fmt.Errorf' and 't.Logf' with non-template strings/no arguments. The fix to this is replace these calls with the non-suffixed variants. There are many users of 'fmt.Fprint' - too many to do by hand - so this replacement was resolved using 'sed': sed 's/Fprintf/Fprint/g' -i $(ag fmt.Fprintf -l) We then manually fix the 25 cases where 'fmt.Fprintf' is actually warranted and manually replaced the errant users of 'fmt.Errorf' and 't.Logf'. We also rework 'internal/acceptance/clients/clients.go' slightly to make the code a bit clearer. PS: This is apparently going to be an issue in go 1.24 (specifically in 'go vet') [1] so this is not just golangci-lint being annoying. @pierreprinetti, that's directed at you ;) [1] golang/go#60529 Signed-off-by: Stephen Finucane <[email protected]>

See golang/go#60529

adonovan added help wanted gopls/analysis Issues related to running analysis in gopls Analysis Issues related to static analysis (vet, x/tools/go/analysis) labels May 31, 2023

adonovan mentioned this issue May 31, 2023

go/types: error diagnostics reported by go/types contain %!v(MISSING) #60500

Closed

mknyszek added this to the Backlog milestone May 31, 2023

mknyszek added the NeedsInvestigation Someone must examine and confirm this is a valid issue and not a duplicate of an existing one. label May 31, 2023

adonovan changed the title ~~cmd/vet: printf: report calls to printf(format) with variable format and no arguments~~ proposal: cmd/vet: printf: report calls to printf(format) with variable format and no arguments Apr 8, 2024

gopherbot added the Proposal label Apr 8, 2024

adonovan added this to Proposals Apr 8, 2024

adonovan moved this to Incoming in Proposals Apr 8, 2024

rsc changed the title ~~proposal: cmd/vet: printf: report calls to printf(format) with variable format and no arguments~~ proposal: cmd/vet: report printf calls with non-const format and no args Apr 10, 2024

rsc moved this from Incoming to Active in Proposals Apr 10, 2024

dmitshur added NeedsFix The path to resolution is known, but the work has not been done. and removed NeedsInvestigation Someone must examine and confirm this is a valid issue and not a duplicate of an existing one. labels Sep 16, 2024

hyangah mentioned this issue Sep 18, 2024

x/tools/go/analysis/passes/printf: suggest Printf calls without args to use Print #69515

Open

mauri870 mentioned this issue Oct 1, 2024

fix(logp): TestConfigureWithCore fails with Go 1.24 elastic/elastic-agent-libs#233

Merged

3 tasks

0x2b3bfa0 mentioned this issue Oct 18, 2024

cmd/age-keygen: fix non-constant format string in log.Printf FiloSottile/age#593

Closed

itchyny mentioned this issue Oct 26, 2024

Fix non-constant format string in call in tests mackerelio/mackerel-client-go#162

Merged

ianlancetaylor mentioned this issue Oct 29, 2024

x/tools/go/analysis/passes/printf: catches dual use variable strings passed to fmt.Sprintf #70088

Closed

dveeden mentioned this issue Nov 22, 2024

Fix non-constant format strings pingcap/tidb-tools#824

Merged

dmitshur reopened this Nov 26, 2024

dmitshur added the release-blocker label Nov 26, 2024

dmitshur mentioned this issue Nov 26, 2024

doc: write release notes for Go 1.24 #68545

Open

gopherbot closed this as completed in 0751f3a Nov 26, 2024

darccio mentioned this issue Dec 2, 2024

fix(ddtrace/tracer): avoid tests to fail with error "non-constant format string" from upcoming Go 1.24 release DataDog/dd-trace-go#3002

Closed

7 tasks

meling mentioned this issue Dec 14, 2024

feat(kit): methods for adding test details to score objects quickfeed/quickfeed#1149

Draft

darccio mentioned this issue Dec 18, 2024

fix(ddtrace/tracer): avoid tests to fail with error "non-constant format string" from upcoming Go 1.24 release DataDog/dd-trace-go#3048

Open

7 tasks

chajath mentioned this issue Dec 20, 2024

Fix non-constant format string errors GoogleCloudPlatform/cluster-toolkit#3451

Merged

Kesuaheli added a commit to cake4everyone/cake4everybot that referenced this issue Dec 21, 2024

fix: non-constant format string for upcomming go 1.24

a4d1de4

See golang/go#60529

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

cmd/vet: report printf calls with non-const format and no args #60529

cmd/vet: report printf calls with non-const format and no args #60529

adonovan commented May 31, 2023 •

edited

Loading

adonovan commented May 31, 2023 •

edited

Loading

robpike commented May 31, 2023 •

edited

Loading

ianlancetaylor commented May 31, 2023

findleyr commented May 31, 2023 •

edited

Loading

robpike commented Jun 1, 2023

timothy-king commented Jun 1, 2023

adonovan commented Apr 8, 2024

timothy-king commented Apr 9, 2024

timothy-king commented Apr 9, 2024

adonovan commented Apr 9, 2024 •

edited

Loading

rsc commented Apr 10, 2024

rsc commented Apr 10, 2024

rsc commented Apr 24, 2024

dominikh commented Apr 24, 2024

adonovan commented Apr 24, 2024

rsc commented May 8, 2024

rsc commented May 8, 2024

rsc commented May 15, 2024

dmitshur commented Nov 26, 2024

gopherbot commented Nov 26, 2024

cmd/vet: report printf calls with non-const format and no args #60529

cmd/vet: report printf calls with non-const format and no args #60529

Comments

adonovan commented May 31, 2023 • edited Loading

adonovan commented May 31, 2023 • edited Loading

robpike commented May 31, 2023 • edited Loading

ianlancetaylor commented May 31, 2023

findleyr commented May 31, 2023 • edited Loading

robpike commented Jun 1, 2023

timothy-king commented Jun 1, 2023

adonovan commented Apr 8, 2024

timothy-king commented Apr 9, 2024

timothy-king commented Apr 9, 2024

adonovan commented Apr 9, 2024 • edited Loading

rsc commented Apr 10, 2024

rsc commented Apr 10, 2024

rsc commented Apr 24, 2024

dominikh commented Apr 24, 2024

adonovan commented Apr 24, 2024

rsc commented May 8, 2024

rsc commented May 8, 2024

rsc commented May 15, 2024

dmitshur commented Nov 26, 2024

gopherbot commented Nov 26, 2024

adonovan commented May 31, 2023 •

edited

Loading

adonovan commented May 31, 2023 •

edited

Loading

robpike commented May 31, 2023 •

edited

Loading

findleyr commented May 31, 2023 •

edited

Loading

adonovan commented Apr 9, 2024 •

edited

Loading