How does golang implement reflection?

Using reflection, we can get the type name, storage size and the function of the given type(such as uint64, user-defined struct and so on). Even, we can modify some fields of the given type.
How does golang implement reflections? I guess the following ways:

1. Every type in golang, including user-defined type, itself has the information about type name, fields name and the function name. Golang reflection just reads these information or call the function.

2. Through some mechanism, Golang can get the type name, storage size and so on. And the type itself doesn’t have these information.

I have read the golang reflection code roughly. I guessed that golang used the second way.
Who can describe the concrete implement of reflection? Or recommend me some documents? Reading all code is difficult for me.

This is just an overview and it might be not 100% accurate but hopefully you will find it helpful.

At build time Go linker will embed information about all types used by the application into the executable (https://github.com/golang/go/blob/master/src/runtime/symtab.go#L39)

Each interface value contains a pointer to the data type descriptor (https://github.com/golang/go/blob/master/src/runtime/type.go#L14)

During conversion from a type that is known at compile time to an interface value Go compiler will point type descriptor of this interface value to the concrete type descriptor (it is known at compile time!).

E.g. when you call reflect.TypeOf(uint(87)):

• an interface value is created by the compiler that references uint type descriptor
• this interface value is passed to reflect.TypeOf function as argument
• reflect.TypeOf function uses type descriptor that has been stored by the linker in the executable to get the align (and other) information about uint type.

The description of interfaces is well described here: The Laws of Reflection.

> A variable of interface type stores a pair: the concrete value
> assigned to the variable, and that value's type descriptor.

Basically, type are known statically from your code. More flexible interface types keep the original underlying type for getting back to the original data type.