type reflect.Type
299 uses
reflect (current package)
badlinkname.go#L43: func badlinkname_rtype_AssignableTo(*rtype, Type) bool
badlinkname.go#L55: func badlinkname_rtype_ConvertibleTo(*rtype, Type) bool
badlinkname.go#L58: func badlinkname_rtype_Elem(*rtype) Type
badlinkname.go#L76: func badlinkname_rtype_Implements(*rtype, Type) bool
badlinkname.go#L79: func badlinkname_rtype_In(*rtype, int) Type
badlinkname.go#L85: func badlinkname_rtype_Key(*rtype) Type
badlinkname.go#L115: func badlinkname_rtype_Out(*rtype, int) Type
deepequal.go#L21: typ Type
iter.go#L13: uintptr, N int64 | uint64](num N, t Type) iter.Seq[Value] {
makefunc.go#L46: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
map_swiss.go#L22: func (t *rtype) Key() Type {
map_swiss.go#L36: func MapOf(key, elem Type) Type {
map_swiss.go#L47: return mt.(Type)
map_swiss.go#L56: return ti.(Type)
map_swiss.go#L95: return ti.(Type)
map_swiss.go#L98: func groupAndSlotOf(ktyp, etyp Type) (Type, Type) {
type.go#L40: type Type interface {
type.go#L107: Implements(u Type) bool
type.go#L110: AssignableTo(u Type) bool
type.go#L116: ConvertibleTo(u Type) bool
type.go#L161: Elem() Type
type.go#L202: In(i int) Type
type.go#L206: Key() Type
type.go#L227: Out(i int) Type
type.go#L449: Type Type // method type
type.go#L627: in := make([]Type, 0, 1+ft.NumIn())
type.go#L632: out := make([]Type, 0, ft.NumOut())
type.go#L736: func (t *rtype) Elem() Type {
type.go#L788: func (t *rtype) In(i int) Type {
type.go#L812: func (t *rtype) Out(i int) Type {
type.go#L1009: Type Type // field type
type.go#L1302: func TypeOf(i any) Type {
type.go#L1321: func PtrTo(t Type) Type { return PointerTo(t) }
type.go#L1325: func PointerTo(t Type) Type {
type.go#L1385: func (t *rtype) Implements(u Type) bool {
type.go#L1395: func (t *rtype) AssignableTo(u Type) bool {
type.go#L1403: func (t *rtype) ConvertibleTo(u Type) bool {
type.go#L1753: func ChanOf(dir ChanDir, t Type) Type {
type.go#L1792: return ti.(Type)
type.go#L1807: return ti.(Type)
type.go#L1810: var funcTypes []Type
type.go#L1813: func initFuncTypes(n int) Type {
type.go#L1817: newFuncTypes := make([]Type, n+1)
type.go#L1845: func FuncOf(in, out []Type, variadic bool) Type {
type.go#L1909: addToCache := func(tt *abi.Type) Type {
type.go#L2060: func SliceOf(t Type) Type {
type.go#L2066: return slice.(Type)
type.go#L2075: return ti.(Type)
type.go#L2090: return ti.(Type)
type.go#L2135: func isRegularMemory(t Type) bool {
type.go#L2171: func isPaddedField(t Type, i int) bool {
type.go#L2185: func StructOf(fields []StructField) Type {
type.go#L2428: for _, st := range ts.([]Type) {
type.go#L2440: for _, st := range ts.([]Type) {
type.go#L2448: addToCache := func(t Type) Type {
type.go#L2449: var ts []Type
type.go#L2451: ts = ti.([]Type)
type.go#L2582: func ArrayOf(length int, elem Type) Type {
type.go#L2592: return array.(Type)
type.go#L2601: return ti.(Type)
type.go#L2689: return ti.(Type)
type.go#L2718: func toType(t *abi.Type) Type {
type.go#L2855: func TypeFor[T any]() Type {
value.go#L2379: func (v Value) Type() Type {
value.go#L2387: func (v Value) typeSlow() Type {
value.go#L2564: func typesMustMatch(what string, t1, t2 Type) {
value.go#L2904: func MakeSlice(typ Type, len, cap int) Value {
value.go#L2926: func SliceAt(typ Type, p unsafe.Pointer, n int) Value {
value.go#L2933: func MakeChan(typ Type, buffer int) Value {
value.go#L2949: func MakeMap(typ Type) Value {
value.go#L2955: func MakeMapWithSize(typ Type, n int) Value {
value.go#L2988: func Zero(typ Type) Value {
value.go#L3011: func New(typ Type) Value {
value.go#L3028: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L3078: func (v Value) Convert(t Type) Value {
value.go#L3091: func (v Value) CanConvert(t Type) bool {
value.go#L3226: func convertOp(dst, src *abi.Type) func(Value, Type) Value {
value.go#L3324: func makeInt(f flag, bits uint64, t Type) Value {
value.go#L3342: func makeFloat(f flag, v float64, t Type) Value {
value.go#L3355: func makeFloat32(f flag, v float32, t Type) Value {
value.go#L3364: func makeComplex(f flag, v complex128, t Type) Value {
value.go#L3376: func makeString(f flag, v string, t Type) Value {
value.go#L3383: func makeBytes(f flag, v []byte, t Type) Value {
value.go#L3390: func makeRunes(f flag, v []rune, t Type) Value {
value.go#L3403: func cvtInt(v Value, t Type) Value {
value.go#L3408: func cvtUint(v Value, t Type) Value {
value.go#L3413: func cvtFloatInt(v Value, t Type) Value {
value.go#L3418: func cvtFloatUint(v Value, t Type) Value {
value.go#L3423: func cvtIntFloat(v Value, t Type) Value {
value.go#L3428: func cvtUintFloat(v Value, t Type) Value {
value.go#L3433: func cvtFloat(v Value, t Type) Value {
value.go#L3444: func cvtComplex(v Value, t Type) Value {
value.go#L3449: func cvtIntString(v Value, t Type) Value {
value.go#L3458: func cvtUintString(v Value, t Type) Value {
value.go#L3467: func cvtBytesString(v Value, t Type) Value {
value.go#L3472: func cvtStringBytes(v Value, t Type) Value {
value.go#L3477: func cvtRunesString(v Value, t Type) Value {
value.go#L3482: func cvtStringRunes(v Value, t Type) Value {
value.go#L3487: func cvtSliceArrayPtr(v Value, t Type) Value {
value.go#L3497: func cvtSliceArray(v Value, t Type) Value {
value.go#L3513: func cvtDirect(v Value, typ Type) Value {
value.go#L3528: func cvtT2I(v Value, typ Type) Value {
value.go#L3540: func cvtI2I(v Value, typ Type) Value {
visiblefields.go#L16: func VisibleFields(t Type) []StructField {
visiblefields.go#L25: visiting: make(map[Type]bool),
visiblefields.go#L51: visiting map[Type]bool
visiblefields.go#L61: func (w *visibleFieldsWalker) walk(t Type) {
encoding/asn1
asn1.go#L600: func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
asn1.go#L1092: Type reflect.Type
common.go#L151: func getUniversalType(t reflect.Type) (matchAny bool, tagNumber int, isCompound, ok bool) {
encoding/binary
binary.go#L733: func sizeof(t reflect.Type) int {
encoding/json
decode.go#L124: Type reflect.Type // type of Go value it could not be assigned to
decode.go#L143: Type reflect.Type
decode.go#L154: Type reflect.Type
decode.go#L203: Struct reflect.Type
encode.go#L209: Type reflect.Type
encode.go#L244: Type reflect.Type
encode.go#L354: func typeEncoder(t reflect.Type) encoderFunc {
encode.go#L390: func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
encode.go#L736: func newStructEncoder(t reflect.Type) encoderFunc {
encode.go#L790: func newMapEncoder(t reflect.Type) encoderFunc {
encode.go#L847: func newSliceEncoder(t reflect.Type) encoderFunc {
encode.go#L875: func newArrayEncoder(t reflect.Type) encoderFunc {
encode.go#L903: func newPtrEncoder(t reflect.Type) encoderFunc {
encode.go#L944: func typeByIndex(t reflect.Type, index []int) reflect.Type {
encode.go#L1061: typ reflect.Type
encode.go#L1089: func typeFields(t reflect.Type) structFields {
encode.go#L1095: var count, nextCount map[reflect.Type]int
encode.go#L1098: visited := map[reflect.Type]bool{}
encode.go#L1108: count, nextCount = nextCount, map[reflect.Type]int{}
encode.go#L1328: func cachedTypeFields(t reflect.Type) structFields {
github.com/google/go-cmp/cmp
compare.go#L147: var t reflect.Type
compare.go#L303: func (s *state) tryOptions(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L312: func (s *state) tryMethod(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L375: func (s *state) compareStruct(t reflect.Type, vx, vy reflect.Value) {
compare.go#L418: func (s *state) compareSlice(t reflect.Type, vx, vy reflect.Value) {
compare.go#L510: func (s *state) compareMap(t reflect.Type, vx, vy reflect.Value) {
compare.go#L552: func (s *state) comparePtr(t reflect.Type, vx, vy reflect.Value) {
compare.go#L569: func (s *state) compareInterface(t reflect.Type, vx, vy reflect.Value) {
options.go#L32: filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption
options.go#L68: func (opts Options) filter(s *state, t reflect.Type, vx, vy reflect.Value) (out applicableOption) {
options.go#L134: func (f pathFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L176: typ reflect.Type // T
options.go#L181: func (f valuesFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L203: func (ignore) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption { return ignore{} }
options.go#L212: func (validator) filter(_ *state, _ reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L235: isProtoMessage := func(t reflect.Type) bool {
options.go#L311: typ reflect.Type // T
options.go#L317: func (tr *transformer) filter(s *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L369: typ reflect.Type // T
options.go#L375: func (cm *comparer) filter(_ *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L416: func Exporter(f func(reflect.Type) bool) Option {
options.go#L420: type exporter func(reflect.Type) bool
options.go#L422: func (exporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L431: m := make(map[reflect.Type]bool)
options.go#L439: return exporter(func(t reflect.Type) bool { return m[t] })
options.go#L528: func (reporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
path.go#L43: Type() reflect.Type
path.go#L161: typ reflect.Type
path.go#L165: func (ps pathStep) Type() reflect.Type { return ps.typ }
path.go#L195: func (sf StructField) Type() reflect.Type { return sf.typ }
path.go#L227: func (si SliceIndex) Type() reflect.Type { return si.typ }
path.go#L271: func (mi MapIndex) Type() reflect.Type { return mi.typ }
path.go#L284: func (in Indirect) Type() reflect.Type { return in.typ }
path.go#L294: func (ta TypeAssertion) Type() reflect.Type { return ta.typ }
path.go#L306: func (tf Transform) Type() reflect.Type { return tf.typ }
report_reflect.go#L51: func (opts formatOptions) FormatType(t reflect.Type, s textNode) textNode {
report_value.go#L15: Type reflect.Type
github.com/google/go-cmp/cmp/internal/function
func.go#L41: func IsType(t reflect.Type, ft funcType) bool {
github.com/google/go-cmp/cmp/internal/value
name.go#L16: func TypeString(t reflect.Type, qualified bool) string {
name.go#L20: func appendTypeName(b []byte, t reflect.Type, qualified, elideFunc bool) []byte {
pointer.go#L15: t reflect.Type
go.uber.org/mock/gomock
call.go#L30: methodType reflect.Type // the type of the method
call.go#L49: func newCall(t TestHelper, receiver any, method string, methodType reflect.Type, args ...any) *Call {
controller.go#L182: func (ctrl *Controller) RecordCallWithMethodType(receiver any, method string, methodType reflect.Type, args ...any) *Call {
matchers.go#L196: targetType reflect.Type
matchers.go#L433: if xt, ok := x.(reflect.Type); ok {
google.golang.org/protobuf/internal/encoding/tag
tag.go#L32: func Unmarshal(tag string, goType reflect.Type, evs protoreflect.EnumValueDescriptors) protoreflect.FieldDescriptor {
google.golang.org/protobuf/internal/filetype
build.go#L216: var goType reflect.Type
build.go#L244: var goTypeForPBKind = map[protoreflect.Kind]reflect.Type{
google.golang.org/protobuf/internal/impl
codec_field.go#L33: oneofFields := make(map[reflect.Type]*coderFieldInfo)
codec_field.go#L121: func makeMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L289: func makeGroupFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L380: func makeMessageSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L468: func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, opts marshalOptions) int {
codec_field.go#L479: func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) {
codec_field.go#L500: func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_field.go#L522: func isInitMessageSlice(p pointer, goType reflect.Type) error {
codec_field.go#L667: func makeGroupSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L698: func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, opts marshalOptions) int {
codec_field.go#L709: func appendGroupSlice(b []byte, p pointer, wiretag uint64, messageType reflect.Type, opts marshalOptions) ([]byte, error) {
codec_field.go#L724: func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_field_opaque.go#L16: func makeOpaqueMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
codec_field_opaque.go#L119: func makeOpaqueRepeatedMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
codec_map.go#L18: goType reflect.Type
codec_map.go#L28: func encoderFuncsForMap(fd protoreflect.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
codec_message.go#L44: ft reflect.Type
codec_message.go#L59: func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
codec_message_opaque.go#L20: func (mi *MessageInfo) makeOpaqueCoderMethods(t reflect.Type, si opaqueStructInfo) {
codec_tables.go#L37: func fieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
convert.go#L53: func NewConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
convert.go#L89: func newSingularConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
convert.go#L146: goType reflect.Type
convert.go#L170: goType reflect.Type
convert.go#L194: goType reflect.Type
convert.go#L218: goType reflect.Type
convert.go#L242: goType reflect.Type
convert.go#L266: goType reflect.Type
convert.go#L290: goType reflect.Type
convert.go#L314: goType reflect.Type
convert.go#L344: goType reflect.Type
convert.go#L371: goType reflect.Type
convert.go#L375: func newEnumConverter(goType reflect.Type, fd protoreflect.FieldDescriptor) Converter {
convert.go#L414: goType reflect.Type
convert.go#L417: func newMessageConverter(goType reflect.Type) Converter {
convert_list.go#L14: func newListConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
convert_list.go#L25: goType reflect.Type // []T
convert_list.go#L67: goType reflect.Type // *[]T
convert_map.go#L15: goType reflect.Type // map[K]V
convert_map.go#L19: func newMapConverter(t reflect.Type, fd protoreflect.FieldDescriptor) *mapConverter {
enum.go#L14: GoReflectType reflect.Type // int32 kind
extension.go#L38: goType reflect.Type
extension.go#L86: func InitExtensionInfo(xi *ExtensionInfo, xd protoreflect.ExtensionDescriptor, goType reflect.Type) {
legacy_enum.go#L45: func legacyLoadEnumType(t reflect.Type) protoreflect.EnumType {
legacy_enum.go#L66: goType reflect.Type
legacy_enum.go#L85: goTyp reflect.Type
legacy_enum.go#L117: func LegacyLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
legacy_enum.go#L160: func aberrantLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
legacy_enum.go#L195: func AberrantDeriveFullName(t reflect.Type) protoreflect.FullName {
legacy_message.go#L36: func legacyLoadMessageType(t reflect.Type, name protoreflect.FullName) protoreflect.MessageType {
legacy_message.go#L48: func legacyLoadMessageInfo(t reflect.Type, name protoreflect.FullName) *MessageInfo {
legacy_message.go#L90: func LegacyLoadMessageDesc(t reflect.Type) protoreflect.MessageDescriptor {
legacy_message.go#L93: func legacyLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
legacy_message.go#L157: aberrantMessageDescCache map[reflect.Type]protoreflect.MessageDescriptor
legacy_message.go#L165: func aberrantLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
legacy_message.go#L169: aberrantMessageDescCache = make(map[reflect.Type]protoreflect.MessageDescriptor)
legacy_message.go#L173: func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
legacy_message.go#L209: var oneofWrappers []reflect.Type
legacy_message.go#L276: func aberrantDeriveMessageName(t reflect.Type, name protoreflect.FullName) protoreflect.FullName {
legacy_message.go#L295: func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, tagVal string) {
legacy_message.go#L467: t reflect.Type
legacy_message.go#L479: func (mt aberrantMessageType) GoType() reflect.Type {
message.go#L27: GoReflectType reflect.Type // pointer to struct
message.go#L54: func getMessageInfo(mt reflect.Type) *MessageInfo {
message.go#L129: sizecacheType reflect.Type
message.go#L131: unknownType reflect.Type
message.go#L133: extensionType reflect.Type
message.go#L140: oneofWrappersByType map[reflect.Type]protoreflect.FieldNumber
message.go#L141: oneofWrappersByNumber map[protoreflect.FieldNumber]reflect.Type
message.go#L144: func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
message.go#L154: oneofWrappersByType: map[reflect.Type]protoreflect.FieldNumber{},
message.go#L155: oneofWrappersByNumber: map[protoreflect.FieldNumber]reflect.Type{},
message_opaque.go#L29: func isOpaque(t reflect.Type) bool {
message_reflect.go#L41: func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
message_reflect.go#L114: func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
message_reflect.go#L164: func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
message_reflect.go#L183: var ft reflect.Type
message_reflect_field.go#L61: func fieldInfoForOneof(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
pointer_unsafe.go#L76: func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
pointer_unsafe.go#L82: func (p pointer) AsIfaceOf(t reflect.Type) any {
validate.go#L113: func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
validate.go#L149: func newValidationInfo(fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
gotest.tools/v3/assert/cmp
compare.go#L315: case reflect.Type:
compare.go#L348: func cmpErrorTypeEqualType(err error, expectedType reflect.Type) Result {
compare.go#L359: func cmpErrorTypeImplementsType(err error, expectedType reflect.Type) Result {
compare.go#L370: func isPtrToInterface(typ reflect.Type) bool {
compare.go#L374: func isPtrToStruct(typ reflect.Type) bool {
testing
fuzz.go#L165: var supportedTypes = map[reflect.Type]bool{
fuzz.go#L235: var types []reflect.Type
testing.go#L1955: func (f matchStringOnly) CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error {
testing.go#L1959: func (f matchStringOnly) ReadCorpus(string, []reflect.Type) ([]corpusEntry, error) {
testing.go#L1962: func (f matchStringOnly) CheckCorpus([]any, []reflect.Type) error { return nil }
testing.go#L2011: CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error
testing.go#L2013: ReadCorpus(string, []reflect.Type) ([]corpusEntry, error)
testing.go#L2014: CheckCorpus([]any, []reflect.Type) error
text/template
exec.go#L881: func canBeNil(typ reflect.Type) bool {
exec.go#L892: func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
exec.go#L934: func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L981: func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L992: func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1003: func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1014: func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1025: func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1036: func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
funcs.go#L112: func goodFunc(name string, typ reflect.Type) error {
funcs.go#L160: func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
funcs.go#L335: var dddType reflect.Type