SA4000 when comparing outputs of the same function with the same arguments

[sfllaw]

It seems like staticcheck is assuming that functions are always idempotent:

sfllaw@h2co3:~/src/staticcheck$ staticcheck main.go
main.go:14:39: identical expressions on the left and right side of the '==' operator (SA4000)

given this main.go:

package main

import (
	"fmt"
	"math/rand/v2"
)

func f(n int) int {
	return rand.IntN(n)
}

func main() {
	fmt.Println("Function outputs:", f(10), f(10))
	fmt.Println("are not always equal ", f(10) == f(10))
}

Context

sfllaw@h2co3:~/src/staticcheck$ staticcheck -version
staticcheck 2025.1.1 (0.6.1)
sfllaw@h2co3:~/src/staticcheck$ staticcheck -debug.version
staticcheck 2025.1.1 (0.6.1)

Compiled with Go version: go1.23.2
Main module:
        honnef.co/go/tools@v0.6.1 (sum: h1:R094WgE8K4JirYjBaOpz/AvTyUu/3wbmAoskKN/pxTI=)
Dependencies:
        github.com/BurntSushi/toml@v1.4.1-0.20240526193622-a339e1f7089c (sum: h1:pxW6RcqyfI9/kWtOwnv/G+AzdKuy2ZrqINhenH4HyNs=)
        golang.org/x/exp/typeparams@v0.0.0-20231108232855-2478ac86f678 (sum: h1:1P7xPZEwZMoBoz0Yze5Nx2/4pxj6nw9ZqHWXqP0iRgQ=)
        golang.org/x/mod@v0.23.0 (sum: h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM=)
        golang.org/x/sync@v0.11.0 (sum: h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=)
        golang.org/x/tools@v0.30.0 (sum: h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY=)
sfllaw@h2co3:~/src/staticcheck$ go version
go version go1.23.2 linux/amd64

[dominikh]

SA4000 does indeed assume that functions don't have side-effects, because this case virtually never shows up in correct code (this is the second report in 8 years, the other one being #1087), but does show up in buggy code.

However, SA4000 operates on the AST and ignores value flow, which means that while it will flag f(10) == f(10), it will not flag

a := f(10)
b := f(10)
_ = a == b

thus providing a very easy workaround, which IMO makes for clearer code, too, and provides a convenient place for adding a comment explaining why you're doing what you're doing.

[sfllaw]

@dominikh: Interesting. I am fine if you close this as a duplicate, if it really is that rare.

The only minor suggestion that I’d make is to pull the above example into https://staticcheck.dev/docs/checks#SA4000. If you take contributions, I can prepare a PR in the style of:

go-tools/staticcheck/sa4008/sa4008.go

Lines 20 to 39 in ba737e5

	Doc: &lint.RawDocumentation{
	Title: `The variable in the loop condition never changes, are you incrementing the wrong variable?`,
	Text: `For example:
	for i := 0; i < 10; j++ { ... }
	This may also occur when a loop can only execute once because of unconditional
	control flow that terminates the loop. For example, when a loop body contains an
	unconditional break, return, or panic:
	func f() {
	panic("oops")
	}
	func g() {
	for i := 0; i < 10; i++ {
	// f unconditionally calls panic, which means "i" is
	// never incremented.
	f()
	}
	}`,

[dominikh]

/cc @catzkorn who is currently working on docs

[sfllaw]

I see in your CONTRIBUTING.md that you don’t take pull requests. I will not submit one, to avoid polluting your repo, but I do have a branch with a possible explanation: https://github.com/dominikh/go-tools/compare/master...sfllaw:go-tools:sfllaw/sa4000-explain-text?expand=1

sfllaw@h2co3:~/src/go-tools$ go run ./cmd/staticcheck  --explain SA4000
Binary operator has identical expressions on both sides

For example:

    b := a - a

This assumes that functions do not have side-effects and will flag 'fn() == fn()':

    if fn() == fn() {
        /* ... */
    }

Sometimes, this is a false positive, but this often catches bugs in real code.
To explicitly allow this comparison, use temporary variables like so:

    a := fn()
    b := fn()
    if a == b {
        /* ... */
    }

Available since
    2017.1

Online documentation
    https://staticcheck.dev/docs/checks#SA4000

Feel free to adopt as you see fit.