-0 is also useless in an integer context. Is it ever useful?

@randall77 Good point. -0 is just 0 in any numeric context. It's just that with integer values we understand that -0 and 0 are the same, and so there's not the same expectation as for floats.

I suppose one could report it as well.

cc @robpike

How often does this really happen?

@josharian Probably rather rare, but when it happens and it's not caught, it can be annoying. I believe it should be rather trivial to test for: go/types provides the actual machine-type for such constants, and if it's a float32/64, we just look to see if the constant expression has value 0 and starts with a negation (we may want to exclude complex expressions which be designed to also produce non-0 values if constant values change).

Please demonstrate the three criteria listed in cmd/vet/README are satisfied. I believe it's hard to satisfy any of them.

Correctness: An untyped -0 used in floating-point context will always be interpreted as 0 rather than -0, which is probably not what's intended (or otherwise there wouldn't be a minus sign). Missing this detail has caused confusion at best, and bugs at worst. Most recently #19673 exposed the incorrect use of -0 in a test which in turn didn't test all it was supposed to test (and two test cases were incorrect).

Precision: This test can be done precisely and cheaply. We know if an expression is constant, we know its value, and we know its type. A constant expression with 0 value used in float context shouldn't have the form -x.

Frequency: This is the only critera which may perhaps not be satisfied. The main reason for that is that most people don't do floating point. However, in code dealing with floating-point arithmetic primarily, the use of -0 is not that uncommon.

I have trouble believing it's a worthwhile addition, but I've made it a proposal so it can be discussed in that category.

Since the check is cheap, proposal accepted.

CL https://golang.org/cl/38779 mentions this issue.

Now that vet runs by default I'd only want to do this if we think it should be run automatically. Leaving for Go 1.11.

interesting test case (which should not complain): https://play.golang.org/p/uGsLWDfHvqR

package main

import (
	"fmt"
)

const (
	a float64 = -1 * iota
	b
	c
	d
)

func main() {
	fmt.Println(a, b, c, d)
}

dtto simple

const (
        a = -iota
        b
        c
)

must remain valid even when there's an untyped `-0' in it.

@nightlyone @cznic the implementation in CL 38779 should handle both of those cases correctly (i.e. not complain).

I'm marking this as help wanted. CL 38779 is (I think) a good initial implementation. It mainly needs docs and tests. I hope someone interested will use CL 38779 as a base and build from there.

cc @mvdan @dominikh

This seems like a good starter issue for vet, especially given how there's a sample solution by Josh already. I'll give a shout out about it at the next London meetup, as I think there were a few people eager to contribute to Go last time.

Now that vet runs by default I'd only want to do this if we think it should be run automatically.

go help test only says that the criteria is "high-confidence", which I assume to be correctness. I assume that this would depend on the actual implementation, as some potential false positives have been posted here. I imagine it's very possible to write such a high-confidence check though, similar to how Josh's implementation is rather conservative.

Seems like this is a subset of #30951. Further discussion on the -0 float check should continue there.