Gofmt, gofumpt: inconsistent arithmetic spacing

Technical Discussion
1

Both gofmt and gofumpt producing the following, inconsistent spacing for some arithmetic expressions.

	var butteryPalettedsLen int

	switch o.Stitch {
	case Mirror:
		butteryPalettedsLen = 2*clonePalettedsLen - 1
	case FlipH:
		butteryPalettedsLen = 2 * clonePalettedsLen
	case FlipV:
		butteryPalettedsLen = 2 * clonePalettedsLen
	default:
		butteryPalettedsLen = clonePalettedsLen
	}

The multiplication asterisks (*) should either all exhibit an ASCII space before and after, or else none of them should. I believe the former is easier to read and scale to longer, intricate expressions. Regardless, at least be consistent in the styling.

This bug happens when using the corresponding CLI tools. It also happens when using the same tools via Go’s official VSCode Go plugin. Like plenty of other programming languages, I find the bug triggered by autosave and other common actions, intractable and so elect to disable the plugin entirely. Not that even VSCode basic syntax highlighting is particularly reliable.

2

This is not a bug at all; it is a feature. It seems like you are not familiar with the order of operations. When you added multiplication and subtraction on the same line, the formatter grouped them appropriately so you can visually see the order of operations.

Consider the following comment from rsc:

We worked hard on this. Putting spaces everywhere means that you
can’t see things like operator precedence at a glance. Compare

x + y * z + w
x * y + z * w
x + y*z + w
x*y + z*w

It is absolutely being consistent; and very useful. When I use other languages, I almost always use parens to reduce the mental load of reading functions (even when not needed). Grouping them visually without parens is awesome.

I have also found VSCode syntax highlighting to work reliably (same with the vim plugin). This complaint is incredibly vague. If you have a real problem/bug you can probably get support for it on github. I know a lot of people really love goland; you could give that a try. Also - in the olden times, before VSCode ate everything, a lot of us used LiteIDE.

1 Like
3

I find the nonuniform spacing so distracting that I can no longer concentrate on operator precedence.

An attacker could abuse spacing to imply a difference precedence.

Someone who doesn’t understand basic arithmetic order shouldn’t code.

4

You can’t be sincere. This is becoming a meme of you complaining about the Go toolchain in ways that are increasingly nonsensical. Is this an April Fools joke? If so, you got me.

What?? If an attacker is checking in code to your repository you have larger issues. This makes zero sense. Also - given that most go projects enforce gofmt this argument is even more ridiculous.

  1. Children can (and should!) write code. Don’t be a gatekeeper.
  2. I mean - you’re the one who didn’t immediately see the spacing and think “order of operations”. The first time I ever saw gofmt do this, it was immediately obvious to me that it was due to order of operations.

I think this is the end of my replies to you. I am coming at this from a sincere angle and I just don’t think you are. It seems like you have some ax to grind and you are posting things that are increasingly nonsensical to get some sort of response. Maybe you can try the go discord or subreddit. Good luck!

1 Like
5

You can’t be sincere.

:face_vomiting: