addressable in Golang

Let's take a look at the following sample program, the bottom test function, three lines are correct and one line is wrong, do you know why that line is wrong?

package jsimport ("fmt""testing")type Tester struct{}func (t Tester) Operation1() {fmt.Println("first")}func (t *Tester) Operation2() {fmt.Println("second")}func TestNewTester(t *testing.T) {Tester{}.Operation1() //correctTester{}.Operation2() //Errornew(Tester).Operation2() //correctnew(Tester).Operation1() //correct}

There are several phenomena:

1) Functions defined on objects, such as this:

func (t Tester) Operation1() {fmt.Println("first")}

It can be called directly in the following way

Tester{}.Operation1() //correct

But functions defined on pointers, such as:

func (t *Tester) Operation2() {fmt.Println("second")}

It cannot be called in the following way

Tester{}.Operation2() //Error

But if the pointer defined by new(Tester) can be called

new(Tester).Operation2() //correctnew(Tester).Operation1() //correct

If I haven't tested it, I have always had the illusion that directly initialized objects cannot call functions, but from the above we can see that there are still many subtleties in the middle.

Then why?

It should be the object defined by Tester{} because there is no formal pointer reference, it is related to a state called addressable mentioned by the reflect library.This should not be addressable, so the pointer function cannot be called directly.

The official document is this

The Go Programming Language Specification - The Go Programming Language​go.dev/ref/spec#Address_operators

It mentions:

For an operandxof typeT, the address operation&xgenerates a pointer of type*Ttox. The operand must beaddressable, that is,either a variable, pointer indirection, or slice indexing operation; or a field selector of an addressable struct operand; or an array indexing operation of an addressable array. As an exception to the addressability requirement,xmay also be a (possibly parenthesized)composite literal. If the evaluationofxwould cause arun-time panic, then the evaluation of&xdoes too.

The bold part is added by me, which means that only variables, indirect pointers (such as a variable of an instance object directly calling the pointer function, actually the compiler turns the pointer first) or the index operation of the slice are calledis addressable.