golang源码分析：go-reflect

func TypeOf(i any) Type {
  eface := *(*emptyInterface)(unsafe.Pointer(&i))
  return toType(eface.typ)
}

type emptyInterface struct {
  typ  *rtype
  word unsafe.Pointer
}

type Type interface {
  // Methods applicable to all types.

  // Align returns the alignment in bytes of a value of
  // this type when allocated in memory.
  Align() int

  // FieldAlign returns the alignment in bytes of a value of
  // this type when used as a field in a struct.
  FieldAlign() int

  // Method returns the i'th method in the type's method set.
  // It panics if i is not in the range [0, NumMethod()).
  //
  // For a non-interface type T or *T, the returned Method's Type and Func
  // fields describe a function whose first argument is the receiver,
  // and only exported methods are accessible.
  //
  // For an interface type, the returned Method's Type field gives the
  // method signature, without a receiver, and the Func field is nil.
  //
  // Methods are sorted in lexicographic order.
  Method(int) Method

  // MethodByName returns the method with that name in the type's
  // method set and a boolean indicating if the method was found.
  //
  // For a non-interface type T or *T, the returned Method's Type and Func
  // fields describe a function whose first argument is the receiver.
  //
  // For an interface type, the returned Method's Type field gives the
  // method signature, without a receiver, and the Func field is nil.
  MethodByName(string) (Method, bool)

  // NumMethod returns the number of methods accessible using Method.
  //
  // For a non-interface type, it returns the number of exported methods.
  //
  // For an interface type, it returns the number of exported and unexported methods.
  NumMethod() int

  // Name returns the type's name within its package for a defined type.
  // For other (non-defined) types it returns the empty string.
  Name() string

  // PkgPath returns a defined type's package path, that is, the import path
  // that uniquely identifies the package, such as "encoding/base64".
  // If the type was predeclared (string, error) or not defined (*T, struct{},
  // []int, or A where A is an alias for a non-defined type), the package path
  // will be the empty string.
  PkgPath() string

  // Size returns the number of bytes needed to store
  // a value of the given type; it is analogous to unsafe.Sizeof.
  Size() uintptr

  // String returns a string representation of the type.
  // The string representation may use shortened package names
  // (e.g., base64 instead of "encoding/base64") and is not
  // guaranteed to be unique among types. To test for type identity,
  // compare the Types directly.
  String() string

  // Kind returns the specific kind of this type.
  Kind() Kind

  // Implements reports whether the type implements the interface type u.
  Implements(u Type) bool

  // AssignableTo reports whether a value of the type is assignable to type u.
  AssignableTo(u Type) bool

  // ConvertibleTo reports whether a value of the type is convertible to type u.
  // Even if ConvertibleTo returns true, the conversion may still panic.
  // For example, a slice of type []T is convertible to *[N]T,
  // but the conversion will panic if its length is less than N.
  ConvertibleTo(u Type) bool

  // Comparable reports whether values of this type are comparable.
  // Even if Comparable returns true, the comparison may still panic.
  // For example, values of interface type are comparable,
  // but the comparison will panic if their dynamic type is not comparable.
  Comparable() bool

  // Methods applicable only to some types, depending on Kind.
  // The methods allowed for each kind are:
  //
  //  Int*, Uint*, Float*, Complex*: Bits
  //  Array: Elem, Len
  //  Chan: ChanDir, Elem
  //  Func: In, NumIn, Out, NumOut, IsVariadic.
  //  Map: Key, Elem
  //  Pointer: Elem
  //  Slice: Elem
  //  Struct: Field, FieldByIndex, FieldByName, FieldByNameFunc, NumField

  // Bits returns the size of the type in bits.
  // It panics if the type's Kind is not one of the
  // sized or unsized Int, Uint, Float, or Complex kinds.
  Bits() int

  // ChanDir returns a channel type's direction.
  // It panics if the type's Kind is not Chan.
  ChanDir() ChanDir

  // IsVariadic reports whether a function type's final input parameter
  // is a "..." parameter. If so, t.In(t.NumIn() - 1) returns the parameter's
  // implicit actual type []T.
  //
  // For concreteness, if t represents func(x int, y ... float64), then
  //
  //  t.NumIn() == 2
  //  t.In(0) is the reflect.Type for "int"
  //  t.In(1) is the reflect.Type for "[]float64"
  //  t.IsVariadic() == true
  //
  // IsVariadic panics if the type's Kind is not Func.
  IsVariadic() bool

  // Elem returns a type's element type.
  // It panics if the type's Kind is not Array, Chan, Map, Pointer, or Slice.
  Elem() Type

  // Field returns a struct type's i'th field.
  // It panics if the type's Kind is not Struct.
  // It panics if i is not in the range [0, NumField()).
  Field(i int) StructField

  // FieldByIndex returns the nested field corresponding
  // to the index sequence. It is equivalent to calling Field
  // successively for each index i.
  // It panics if the type's Kind is not Struct.
  FieldByIndex(index []int) StructField

  // FieldByName returns the struct field with the given name
  // and a boolean indicating if the field was found.
  FieldByName(name string) (StructField, bool)

  // FieldByNameFunc returns the struct field with a name
  // that satisfies the match function and a boolean indicating if
  // the field was found.
  //
  // FieldByNameFunc considers the fields in the struct itself
  // and then the fields in any embedded structs, in breadth first order,
  // stopping at the shallowest nesting depth containing one or more
  // fields satisfying the match function. If multiple fields at that depth
  // satisfy the match function, they cancel each other
  // and FieldByNameFunc returns no match.
  // This behavior mirrors Go's handling of name lookup in
  // structs containing embedded fields.
  FieldByNameFunc(match func(string) bool) (StructField, bool)

  // In returns the type of a function type's i'th input parameter.
  // It panics if the type's Kind is not Func.
  // It panics if i is not in the range [0, NumIn()).
  In(i int) Type

  // Key returns a map type's key type.
  // It panics if the type's Kind is not Map.
  Key() Type

  // Len returns an array type's length.
  // It panics if the type's Kind is not Array.
  Len() int

  // NumField returns a struct type's field count.
  // It panics if the type's Kind is not Struct.
  NumField() int

  // NumIn returns a function type's input parameter count.
  // It panics if the type's Kind is not Func.
  NumIn() int

  // NumOut returns a function type's output parameter count.
  // It panics if the type's Kind is not Func.
  NumOut() int

  // Out returns the type of a function type's i'th output parameter.
  // It panics if the type's Kind is not Func.
  // It panics if i is not in the range [0, NumOut()).
  Out(i int) Type

  common() *rtype
  uncommon() *uncommonType
}

func toRT(t Type) reflect.Type {
  return type_toType(t)
}

func toT(t reflect.Type) Type {
  return (Type)(((*Value)(unsafe.Pointer(&t))).ptr)
}

func toRV(v Value) reflect.Value {
  return *(*reflect.Value)(unsafe.Pointer(&v))
}

func toV(v reflect.Value) Value {
  return *(*Value)(unsafe.Pointer(&v))
}

func toRSF(v StructField) reflect.StructField {
  return reflect.StructField{
    Name:      v.Name,
    PkgPath:   v.PkgPath,
    Type:      ToReflectType(v.Type),
    Tag:       v.Tag,
    Offset:    v.Offset,
    Index:     v.Index,
    Anonymous: v.Anonymous,
  }
}

func toSF(v reflect.StructField) StructField {
  return StructField{
    Name:      v.Name,
    PkgPath:   v.PkgPath,
    Type:      ToType(v.Type),
    Tag:       v.Tag,
    Offset:    v.Offset,
    Index:     v.Index,
    Anonymous: v.Anonymous,
  }
}

func toM(v reflect.Method) Method {
  return Method{
    Name:    v.Name,
    PkgPath: v.PkgPath,
    Type:    ToType(v.Type),
    Func:    toV(v.Func),
    Index:   v.Index,
  }
}

func toRSC(v SelectCase) reflect.SelectCase {
  return reflect.SelectCase{
    Dir:  v.Dir,
    Chan: toRV(v.Chan),
    Send: toRV(v.Send),
  }
}

func validateTypeOf() error {
  if TypeOf(true).Kind() != Bool {
    return fmt.Errorf(errTypeOf, "bool")
  }
  if TypeOf(int(1)).Kind() != Int {
    return fmt.Errorf(errTypeOf, "int")
  }

func validateValueOf() error {
  if v := ValueOf(true); v.Type().Kind() != Bool || v.Bool() != true {
    return fmt.Errorf(errValueOf, "bool")
  }
  if v := ValueOf(int(1)); v.Type().Kind() != Int || v.Int() != 1 {
    return fmt.Errorf(errValueOf, "int")
  }

func validate() error {
  if err := validateTypeOf(); err != nil {
    return err
  }
  if err := validateValueOf(); err != nil {
    return err
  }
  return nil
}

func init() {
  if err := validate(); err != nil {
  reflect.go
    type Value struct {
  typ Type
  ptr unsafe.Pointer
  flag
}

type Type = *rtype
 type rtype struct{}

func (t *rtype) Align() int {
  return type_Align(t)
}

func (t *rtype) FieldAlign() int {
  return type_FieldAlign(t)
}

  type flag uintptr

const (
  flagKindWidth        = 5 // there are 27 kinds
  flagKindMask    flag = 1<<flagKindWidth - 1
  flagStickyRO    flag = 1 << 5
  flagEmbedRO     flag = 1 << 6
  flagIndir       flag = 1 << 7
  flagAddr        flag = 1 << 8
  flagMethod      flag = 1 << 9
  flagMethodShift      = 10
  flagRO          flag = flagStickyRO | flagEmbedRO
)

type Kind = reflect.Kind

const (
  Invalid Kind = iota
  Bool
  Int
  Int8
  Int16
  Int32
  Int64
  Uint
  Uint8
  Uint16
  Uint32
  Uint64
  Uintptr
  Float32
  Float64
  Complex64
  Complex128
  Array
  Chan
  Func
  Interface
  Map
  Ptr
  Slice
  String
  Struct
  UnsafePointer
)

const (
  _             SelectDir = iota
  SelectSend              // case Chan <- Send
  SelectRecv              // case <-Chan:
  SelectDefault           // default
)

type StructTag = reflect.StructTag
type ChanDir = reflect.ChanDir
const (
  RecvDir ChanDir             = 1 << iota // <-chan
  SendDir                                 // chan<-
  BothDir = RecvDir | SendDir             // chan
)

type MapIter = reflect.MapIter
type SliceHeader = reflect.SliceHeader
type StringHeader = reflect.StringHeader

type SelectCase struct {
  Dir  SelectDir // direction of case
  Chan Value     // channel to use (for send or receive)
  Send Value     // value to send (for send)
}

type StructField struct {

type Method struct {

func (v Value) IsZero() bool {
  return toRV(v).IsZero()
}

//go:linkname type_toType reflect.toType
//go:noescape
func type_toType(t Type) reflect.Type

//go:linkname ifaceIndir reflect.ifaceIndir
//go:noescape
func ifaceIndir(Type) bool

var dummy struct {
  b bool
  x interface{}
}

func escape(x interface{}) {
  if dummy.b {
    dummy.x = x
  }
}

type Value struct {
  // typ holds the type of the value represented by a Value.
  typ *rtype

  // Pointer-valued data or, if flagIndir is set, pointer to data.
  // Valid when either flagIndir is set or typ.pointers() is true.
  ptr unsafe.Pointer

  // flag holds metadata about the value.
  // The lowest bits are flag bits:
  //  - flagStickyRO: obtained via unexported not embedded field, so read-only
  //  - flagEmbedRO: obtained via unexported embedded field, so read-only
  //  - flagIndir: val holds a pointer to the data
  //  - flagAddr: v.CanAddr is true (implies flagIndir)
  //  - flagMethod: v is a method value.
  // The next five bits give the Kind of the value.
  // This repeats typ.Kind() except for method values.
  // The remaining 23+ bits give a method number for method values.
  // If flag.kind() != Func, code can assume that flagMethod is unset.
  // If ifaceIndir(typ), code can assume that flagIndir is set.
  flag

  // A method value represents a curried method invocation
  // like r.Read for some receiver r. The typ+val+flag bits describe
  // the receiver r, but the flag's Kind bits say Func (methods are
  // functions), and the top bits of the flag give the method number
  // in r's type's method table.
}

type Value struct {
  typ Type
  ptr unsafe.Pointer
  flag
}

func value_Copy(dst Value, src Value) int {
  return reflect.Copy(toRV(dst), toRV(src))
}

func value_UnsafeAddr(v Value) uintptr {
  return toRV(v).UnsafeAddr()
  }