cmd/compile: recommend fix when "method has pointer receiver"

[kstenerud]

Go's diagnostic message when passing a non-pointer to a function taking an interface is confusing because it doesn't explain very well what the problem is.

Example (https://play.golang.org/p/MXm6RG5fYPy):

package main

import (
	"fmt"
)

type Widget interface {
	DoStuff()
}

type MyWidget struct{}

func (w *MyWidget) DoStuff() {
	fmt.Println("Doing stuff")
}

func doStuffWithWidget(w Widget) {
	w.DoStuff()
}

func main() {
	w := MyWidget{}
	doStuffWithWidget(w)
}

This produces the diagnostic:

./prog.go:23:19: cannot use w (type MyWidget) as type Widget in argument to doStuffWithWidget:
	MyWidget does not implement Widget (DoStuff method has pointer receiver)

... which is only half the story, and makes it difficult to see what's actually wrong. A better diagnostic would be:

./prog.go:23:19: cannot use w (type MyWidget) as type Widget in argument to doStuffWithWidget:
	MyWidget does not implement Widget (DoStuff method has pointer receiver). Passing &w would work here.

[ALTree]

The

(DoStuff method has pointer receiver)

part explains clearly what the problem is, so the diagnostic is complete. You propose adding a sentence that also suggests a possible solution, which is a different thing.

Not many errors in Go do that, because it makes every error message more verbose. This style of diagnostic is useful in complex languages, where it may not be obvious at all how to fix an issue, but I'm not sure this is the case. In my experience, after you've seen the "has pointer receiver" error once or twice, you quickly learn what it means (and how to fix it).

[jmaister]

What seems confusing to me is that the method doStuffWithWidget is expecting a Widget and not a *Widget.

So, why the parameter must be sent as a pointer with doStuffWithWidget(&w) instead of doStuffWithWidget(w)?

[gazerro]

I think that (DoStuff method has pointer receiver) already suggest a possible solution but it can be unclear.

In addition to this, if the argument is replaced with a pointer value, its type does not necessarily implement the interface. For example if the interface is

type Widget interface {
	DoStuff()
        None()
}

the error message is the same but *MyWidget does not implement Widget either.

If the corresponding pointer type (*MyWidget in this example) does not implement the interface, the error should, possibly, not refer to an interface method that *MyWidget does not implement.

If instead *MyWidget implements the interface, the error should suggest *MyWidget implements Widget, as in

./prog.go:23:19: cannot use w (type MyWidget) as type Widget in argument to doStuffWithWidget:
	MyWidget does not implement Widget (*MyWidget implements Widget)

[bklaubos]

./prog.go:23:19: cannot use w (type MyWidget) as type Widget in argument to doStuffWithWidget:
MyWidget does not implement Widget (DoStuff method has pointer receiver)

I agreed that its confusing to say the least. A better message would be:

./prog.go:23:19: cannot use w (type MyWidget) as type Widget in argument to doStuffWithWidget:
MyWidget does not implement Widget (DoStuff method expects pointer receiver)