As far as I can tell, a big part of the confusion is that -X will blindly succeed, whether such a variable exists or not. If it errored out, diagnosing things might be confusing, but at least you'd know..

Longer term, I feel like we'd be better off with a way of overriding constants not variables (and likely at package build time, not at link time).

@ianlancetaylor

At least at first glance this does look like a compiler optimization. I'm not sure what to do about this. It seems a shame to disable a useful compiler optimization for the extremely rare case of using the linker's -X option.

CC @randall77 @josharian

In the original example the initialization of bar happens at compile time. When you add + "", then the initialization of bar happens at runtime. That is the cause of the effect you are seeing, as -X happens after compiling but before runtime.
The optimization involved isn't very important speed-wise, as it only affects init code. It may be pretty useful code-size-wise, though, there'd be a whole lot more init code if we disabled it.
The only real fix I see is to do this optimization in the linker. That sounds like a big change.

-X is a very weird beast anyway. How about this code:

package main

import "fmt"

func a() string {
	return "A"
}

var foo = a()
var bar = foo

func main() {
	fmt.Println(bar)
}

-X doesn't work on foo, as anything written to foo by -X will get overwritten by the runtime init code.

The reasonable workaround to the OP's problem is to wrap any use of a variable which might be -Xed in an identity function, like this:

package main

import "fmt"

func id(s string) string {
	return s
}

var foo = "A"
var bar = id(foo)

func main() {
	fmt.Println(bar)
}

Here's a version of the issue that is closer to the actual truth:

package main

import "github.com/spf13/cobra"

var version = "dev"

var cmd = &cobra.Command{
	Version: version,
}

func main() {
	cmd.Execute()
}

% go build -ldflags "-X main.version=1.0" test.go && ./test --version 
version dev

The way I worked around the issue now was to move the command initialization into the body of a function. For example this will yield the correct result:

package main

import "github.com/spf13/cobra"

var version = "dev"

func main() {
	var cmd = &cobra.Command{
		Version: version,
	}

	cmd.Execute()
}

% go build -ldflags "-X main.version=1.0" test.go && ./test --version
version 1.0

Perhaps you know of a more suitable way of setting the version other than using -X though?

You could use build tags.
I'd use a command-line flag for this, but it sounds like you want something build time.