Question

像访问匿名类型成员那样调用其方法，由编译器负责查找。

type data struct {
	sync.Mutex
	buf [1024]byte
}

func main() {
	d := data{}
	d.Lock()            // sync.(*Mutex).Lock()
	defer d.Unlock()
}

同名遮蔽。利用这种特性，实现类似覆盖（override）操作。

和匿名字段访问类似，按最小深度优先原则。

如两个同名方法深度相同，那么编译器无法作出选择（ambiguous selector），需显式指定。

type E struct{}

type T struct {
	E
}

func   (E) toString() string { return "E" }
func (t T) toString() string { return "T." + t.E.toString() }

// ----------------------------------

func main() {
	var t T
	println(t.toString())    // T.E
	println(t.E.toString())  // E
}

同名，但签名不同的方法。

type E struct{}

type T struct {
	E
}

func (E) toString() string { return "E" }
func (T) toString(s string) string { return "T: " + s }

// ------------------------------------------

func main() {
	var t T

	// println(t.toString())
	//           ~~~~~~~~ not enough arguments in call to t.toString
    //                        have ()
    //                        want (string)

    // 选择深度最小的方法。
	println(t.toString("abc"))   // T: abc

	// 明确目标。
	println(t.E.toString())      // E
}

匿名类型的方法只能访问自己的字段，对外层一无所知。

package main

type E struct {
	x int
}

type T struct {
	x string	
	E
}

func (e *E) do() {
	e.x = 100
	println(e.x)
}

func (t *T) do() {
	t.x = "abc"
	println(t.x)
}

// ------------------------------------------

func main() {
	var t T

	t.do()     // abc
	t.E.do()   // 100
}

/*

可以看出 t.E.do 的 receiver 仅限于自己那段内存。
即便把 E 作第一字断，各自方法内的寻址偏移也指向自己的内存区域。

$ go build -gcflags "-l"
$ go tool objdump -S -s "main\.main" ./test

func main() {
        var t T                                t: T
  0x455314    MOVQ $0x0, 0x8(SP)        0x8 +---------+
  0x45531d    MOVUPS X15, 0x10(SP)          | T.x.ptr |
                                       0x10 +---------+
        t.do()     // abc                   | T.x.len |
  0x455323    LEAQ 0x8(SP), AX         0x18 +---------+
  0x455328    CALL main.(*T).do(SB)         | T.E.x   |
                                            +---------+
        t.E.do()   // 100
  0x45532d    LEAQ 0x18(SP), AX
  0x455332    CALL main.(*E).do(SB)
}

*/