Add detailed internal design document about xgo HOT 5 OPEN

Hope for more Information about this technique. Maybe a detailed article?

from xgo.

I will add materials on this issue thread to supplement the design document.

from xgo.

A new gained technique: declare init bodies.

Description: the following code always panics no matter you have deleted __xgo_link_generate_init_regs_body 's body or replaced it with completely new contents.

The only difference with other linking names is that it is called from init.

So the best practice is to not include that panic.

However, in user written code there are also cases where a linked method is called from init, but they are all fine with a panic.

Still needs to dig into this.

func init() {
	__xgo_link_generate_init_regs_body()
}

func __xgo_link_generate_init_regs_body() {
	panic("failed to link __xgo_link_generate_init_regs_body")
}

See d6c2b3d#diff-61c14e77880a87918b0cf686da52025d4e0abdd7b94047196c7baf56eb59ce9fR35

from xgo.

the trap.Inspect(fn) implements a way to retrieve func info.
It has different internal paths for these function types:

• package level function
  • PC lookup
• struct method
  • -fm suffix check
  • struct.method proto existence check
  • dynamic retrieval
• interface method
  • -fm suffix check
  • interface proto existence check
  • dynamic retrieval
• closure
  • closure is registered using IR
  • PC lookup
• generic function
  • fullName parsing to de-generic
  • generic template existence check
  • no dynamic retrieval since no recv, but is legal to do so
• generic struct method
  • -fm suffix check
  • fullName parsing to de-generic
  • generic method template existence check
  • dynamic retrieval just for receiver
• generic interface method
  • to be supported

from xgo.

the trap.Inspect(fn) implements a way to retrieve func info.
It has different internal paths for these function types:

As a result, xgo exposes a single powerful Mock API to users, because it handle these cases smartly. Hiding most complexity from users. All mock can be done in single unified form:

// package level func
mock.Mock(SomeFunc, interceptor)

// per-instance method
// only the bound instance `v` will be mocked
// `v` can be either a struct or an interface
mock.Mock(v.Method, interceptor)

// per-TParam generic function
// only the specified `int` version will be mocked
mock.Mock(GenericFunc[int], interceptor)

// per TParam and instance generic method
v := GenericStruct[int]
mock.Mock(v.Method, interceptor)

// closure can also be mocked
// less used, but also supported
mock.Mock(closure, interceptor)

However, behind the scene, this topic deserves a good description.

from xgo.