type reflect.Type
306 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#L47: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
map.go#L15: func (t *rtype) Key() Type {
map.go#L29: func MapOf(key, elem Type) Type {
map.go#L40: return mt.(Type)
map.go#L49: return ti.(Type)
map.go#L88: return ti.(Type)
map.go#L91: func groupAndSlotOf(ktyp, etyp Type) (Type, Type) {
type.go#L41: type Type interface {
type.go#L119: Implements(u Type) bool
type.go#L122: AssignableTo(u Type) bool
type.go#L128: ConvertibleTo(u Type) bool
type.go#L173: Elem() Type
type.go#L219: In(i int) Type
type.go#L224: Ins() iter.Seq[Type]
type.go#L228: Key() Type
type.go#L249: Out(i int) Type
type.go#L254: Outs() iter.Seq[Type]
type.go#L481: Type Type // method type
type.go#L659: in := make([]Type, 0, 1+ft.NumIn())
type.go#L664: out := make([]Type, 0, ft.NumOut())
type.go#L768: func (t *rtype) Elem() Type {
type.go#L820: func (t *rtype) In(i int) Type {
type.go#L844: func (t *rtype) Out(i int) Type {
type.go#L983: func (t *rtype) Ins() iter.Seq[Type] {
type.go#L987: return func(yield func(Type) bool) {
type.go#L996: func (t *rtype) Outs() iter.Seq[Type] {
type.go#L1000: return func(yield func(Type) bool) {
type.go#L1090: Type Type // field type
type.go#L1383: func TypeOf(i any) Type {
type.go#L1388: func TypeFor[T any]() Type {
type.go#L1410: func PtrTo(t Type) Type { return PointerTo(t) }
type.go#L1414: func PointerTo(t Type) Type {
type.go#L1474: func (t *rtype) Implements(u Type) bool {
type.go#L1484: func (t *rtype) AssignableTo(u Type) bool {
type.go#L1492: func (t *rtype) ConvertibleTo(u Type) bool {
type.go#L1842: func ChanOf(dir ChanDir, t Type) Type {
type.go#L1881: return ti.(Type)
type.go#L1896: return ti.(Type)
type.go#L1899: var funcTypes []Type
type.go#L1902: func initFuncTypes(n int) Type {
type.go#L1906: newFuncTypes := make([]Type, n+1)
type.go#L1934: func FuncOf(in, out []Type, variadic bool) Type {
type.go#L1998: addToCache := func(tt *abi.Type) Type {
type.go#L2149: func SliceOf(t Type) Type {
type.go#L2155: return slice.(Type)
type.go#L2164: return ti.(Type)
type.go#L2179: return ti.(Type)
type.go#L2224: func isRegularMemory(t Type) bool {
type.go#L2260: func isPaddedField(t Type, i int) bool {
type.go#L2274: func StructOf(fields []StructField) Type {
type.go#L2517: for _, st := range ts.([]Type) {
type.go#L2529: for _, st := range ts.([]Type) {
type.go#L2537: addToCache := func(t Type) Type {
type.go#L2538: var ts []Type
type.go#L2540: ts = ti.([]Type)
type.go#L2670: func ArrayOf(length int, elem Type) Type {
type.go#L2680: return array.(Type)
type.go#L2689: return ti.(Type)
type.go#L2776: return ti.(Type)
type.go#L2805: func toType(t *abi.Type) Type {
value.go#L2480: func (v Value) Type() Type {
value.go#L2488: func (v Value) typeSlow() Type {
value.go#L2707: func typesMustMatch(what string, t1, t2 Type) {
value.go#L3047: func MakeSlice(typ Type, len, cap int) Value {
value.go#L3069: func SliceAt(typ Type, p unsafe.Pointer, n int) Value {
value.go#L3076: func MakeChan(typ Type, buffer int) Value {
value.go#L3092: func MakeMap(typ Type) Value {
value.go#L3098: func MakeMapWithSize(typ Type, n int) Value {
value.go#L3131: func Zero(typ Type) Value {
value.go#L3154: func New(typ Type) Value {
value.go#L3171: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L3221: func (v Value) Convert(t Type) Value {
value.go#L3234: func (v Value) CanConvert(t Type) bool {
value.go#L3369: func convertOp(dst, src *abi.Type) func(Value, Type) Value {
value.go#L3467: func makeInt(f flag, bits uint64, t Type) Value {
value.go#L3485: func makeFloat(f flag, v float64, t Type) Value {
value.go#L3498: func makeFloat32(f flag, v float32, t Type) Value {
value.go#L3507: func makeComplex(f flag, v complex128, t Type) Value {
value.go#L3519: func makeString(f flag, v string, t Type) Value {
value.go#L3526: func makeBytes(f flag, v []byte, t Type) Value {
value.go#L3533: func makeRunes(f flag, v []rune, t Type) Value {
value.go#L3546: func cvtInt(v Value, t Type) Value {
value.go#L3551: func cvtUint(v Value, t Type) Value {
value.go#L3556: func cvtFloatInt(v Value, t Type) Value {
value.go#L3561: func cvtFloatUint(v Value, t Type) Value {
value.go#L3566: func cvtIntFloat(v Value, t Type) Value {
value.go#L3571: func cvtUintFloat(v Value, t Type) Value {
value.go#L3576: func cvtFloat(v Value, t Type) Value {
value.go#L3587: func cvtComplex(v Value, t Type) Value {
value.go#L3592: func cvtIntString(v Value, t Type) Value {
value.go#L3601: func cvtUintString(v Value, t Type) Value {
value.go#L3610: func cvtBytesString(v Value, t Type) Value {
value.go#L3615: func cvtStringBytes(v Value, t Type) Value {
value.go#L3620: func cvtRunesString(v Value, t Type) Value {
value.go#L3625: func cvtStringRunes(v Value, t Type) Value {
value.go#L3630: func cvtSliceArrayPtr(v Value, t Type) Value {
value.go#L3640: func cvtSliceArray(v Value, t Type) Value {
value.go#L3656: func cvtDirect(v Value, typ Type) Value {
value.go#L3671: func cvtT2I(v Value, typ Type) Value {
value.go#L3683: 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) {
database/sql
sql.go#L3228: scanType reflect.Type
sql.go#L3254: func (ci *ColumnType) ScanType() reflect.Type {
database/sql/driver
driver.go#L467: ColumnTypeScanType(index int) reflect.Type
encoding/asn1
asn1.go#L632: func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
asn1.go#L1147: 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#L129: Type reflect.Type // type of Go value it could not be assigned to
decode.go#L148: Type reflect.Type
decode.go#L159: Type reflect.Type
decode.go#L208: Struct reflect.Type
encode.go#L243: Type reflect.Type
encode.go#L278: Type reflect.Type
encode.go#L388: func typeEncoder(t reflect.Type) encoderFunc {
encode.go#L421: func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
encode.go#L756: func newStructEncoder(t reflect.Type) encoderFunc {
encode.go#L810: func newMapEncoder(t reflect.Type) encoderFunc {
encode.go#L867: func newSliceEncoder(t reflect.Type) encoderFunc {
encode.go#L895: func newArrayEncoder(t reflect.Type) encoderFunc {
encode.go#L923: func newPtrEncoder(t reflect.Type) encoderFunc {
encode.go#L964: func typeByIndex(t reflect.Type, index []int) reflect.Type {
encode.go#L1078: typ reflect.Type
encode.go#L1093: func typeFields(t reflect.Type) structFields {
encode.go#L1099: var count, nextCount map[reflect.Type]int
encode.go#L1102: visited := map[reflect.Type]bool{}
encode.go#L1112: count, nextCount = nextCount, map[reflect.Type]int{}
encode.go#L1332: func cachedTypeFields(t reflect.Type) structFields {
encoding/xml
marshal.go#L678: func defaultStart(typ reflect.Type, finfo *fieldInfo, startTemplate *StartElement) StartElement {
marshal.go#L794: func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
marshal.go#L1129: Type reflect.Type
typeinfo.go#L53: func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
typeinfo.go#L113: func structFieldInfo(typ reflect.Type, f *reflect.StructField) (*fieldInfo, error) {
typeinfo.go#L231: func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
typeinfo.go#L261: func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error {
typeinfo.go#L331: Struct reflect.Type
github.com/jackc/pgx/v5
rows.go#L133: scanTypes []reflect.Type
rows.go#L264: rows.scanTypes = make([]reflect.Type, len(values))
rows.go#L602: func lookupStructFields(t reflect.Type) []structRowField {
rows.go#L614: t reflect.Type,
rows.go#L703: t reflect.Type
rows.go#L715: t reflect.Type,
rows.go#L776: t reflect.Type,
github.com/jackc/pgx/v5/pgtype
array_codec.go#L119: var lastElemType reflect.Type
array_codec.go#L197: var lastElemType reflect.Type
builtin_wrappers.go#L887: func (a *anyMultiDimSliceArray) makeMultidimensionalSlice(sliceType reflect.Type, dimensions []ArrayDimension, flatSlice reflect.Value, flatSliceIdx int) reflect.Value {
convert.go#L26: var kindTypes map[reflect.Kind]reflect.Type
convert.go#L28: func toInterface(dst reflect.Value, t reflect.Type) (any, bool) {
convert.go#L92: kindTypes = map[reflect.Kind]reflect.Type{
multirange.go#L99: var lastElemType reflect.Type
multirange.go#L153: var lastElemType reflect.Type
pgtype.go#L202: reflectTypeToName map[reflect.Type]string
pgtype.go#L205: reflectTypeToType map[reflect.Type]*Type
pgtype.go#L207: memoizedEncodePlans map[uint32]map[reflect.Type][2]EncodePlan
pgtype.go#L237: reflectTypeToName: make(map[reflect.Type]string),
pgtype.go#L240: memoizedEncodePlans: make(map[uint32]map[reflect.Type][2]EncodePlan),
pgtype.go#L318: m.reflectTypeToType = make(map[reflect.Type]*Type)
pgtype.go#L493: dstType reflect.Type
pgtype.go#L529: var elemKindToPointerTypes map[reflect.Kind]reflect.Type = map[reflect.Kind]reflect.Type{
pgtype.go#L547: dstType reflect.Type
pgtype.go#L548: nextDstType reflect.Type
pgtype.go#L1211: oidMemo = make(map[reflect.Type][2]EncodePlan)
pgtype.go#L1377: var kindToTypes map[reflect.Kind]reflect.Type = map[reflect.Kind]reflect.Type{
pgtype.go#L1397: nextValueType reflect.Type
pgtype_default.go#L23: reflectTypeToName: make(map[reflect.Type]string),
pgtype_default.go#L26: memoizedEncodePlans: make(map[uint32]map[reflect.Type][2]EncodePlan),
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 {
golang.org/x/tools/go/ast/edge
edge.go#L28: func (k Kind) NodeType() reflect.Type { return fieldInfos[k].nodeType }
edge.go#L34: func (k Kind) FieldType() reflect.Type { return fieldInfos[k].fieldType }
edge.go#L178: nodeType reflect.Type // pointer-to-struct type of ast.Node implementation
edge.go#L181: fieldType reflect.Type
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#L117: func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
validate.go#L153: func newValidationInfo(fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
testing
fuzz.go#L165: var supportedTypes = map[reflect.Type]bool{
fuzz.go#L235: var types []reflect.Type
testing.go#L2250: func (f matchStringOnly) CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error {
testing.go#L2254: func (f matchStringOnly) ReadCorpus(string, []reflect.Type) ([]corpusEntry, error) {
testing.go#L2257: func (f matchStringOnly) CheckCorpus([]any, []reflect.Type) error { return nil }
testing.go#L2307: CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error
testing.go#L2309: ReadCorpus(string, []reflect.Type) ([]corpusEntry, error)
testing.go#L2310: 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#L99: func goodFunc(name string, typ reflect.Type) error {
funcs.go#L147: func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
funcs.go#L326: var dddType reflect.Type