type reflect.Type
384 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) {
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#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 {
encoding/xml
marshal.go#L667: func defaultStart(typ reflect.Type, finfo *fieldInfo, startTemplate *StartElement) StartElement {
marshal.go#L783: func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
marshal.go#L1114: 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/aws/smithy-go/document
errors.go#L13: Type reflect.Type
errors.go#L26: Type reflect.Type
errors.go#L50: Type reflect.Type
github.com/go-pg/pg/v10/orm
composite.go#L11: func compositeScanner(typ reflect.Type) types.ScannerFunc {
composite.go#L76: func compositeAppender(typ reflect.Type) types.AppenderFunc {
field.go#L23: Type reflect.Type
model.go#L144: func validMap(typ reflect.Type) error {
model_func.go#L74: func initFuncModelScan(m *funcModel, fnt reflect.Type) {
model_slice.go#L19: func newSliceModel(slice reflect.Value, elemType reflect.Type) *sliceModel {
model_table.go#L34: func newTableModelIndex(typ reflect.Type, root reflect.Value, index []int, rel *Relation) (TableModel, error) {
model_table_slice.go#L21: func newSliceTableModel(slice reflect.Value, elemType reflect.Type) *sliceTableModel {
model_table_slice.go#L35: func (m *sliceTableModel) init(sliceType reflect.Type) {
msgpack.go#L11: func msgpackAppender(_ reflect.Type) types.AppenderFunc {
msgpack.go#L31: func msgpackScanner(_ reflect.Type) types.ScannerFunc {
table.go#L62: Type reflect.Type
table.go#L95: func newTable(typ reflect.Type) *Table {
table.go#L256: func (t *Table) addFields(typ reflect.Type, baseIndex []int) {
table.go#L1154: func (t *Table) inlineFields(strct *Field, path map[reflect.Type]struct{}) {
table.go#L1156: path = map[reflect.Type]struct{}{
table.go#L1197: func isScanner(typ reflect.Type) bool {
table.go#L1232: func sqlType(typ reflect.Type) string {
table.go#L1469: func setSoftDeleteFieldFunc(typ reflect.Type) func(fv reflect.Value) error {
table.go#L1528: func setSoftDeleteFallbackFunc(typ reflect.Type) func(fv reflect.Value) error {
tables.go#L45: func GetTable(typ reflect.Type) *Table {
tables.go#L60: inProgress map[reflect.Type]*tableInProgress
tables.go#L65: inProgress: make(map[reflect.Type]*tableInProgress),
tables.go#L77: func (t *tables) get(typ reflect.Type, allowInProgress bool) *Table {
tables.go#L121: func (t *tables) Get(typ reflect.Type) *Table {
util.go#L20: func indirectType(t reflect.Type) reflect.Type {
util.go#L27: func sliceElemType(v reflect.Value) reflect.Type {
util.go#L35: func typeByIndex(t reflect.Type, index []int) reflect.Type {
github.com/go-pg/pg/v10/types
append_value.go#L68: func registerAppender(typ reflect.Type, fn AppenderFunc) {
append_value.go#L77: func Appender(typ reflect.Type) AppenderFunc {
append_value.go#L86: func appender(typ reflect.Type, pgArray bool) AppenderFunc {
append_value.go#L124: func ptrAppenderFunc(typ reflect.Type) AppenderFunc {
array_append.go#L25: func ArrayAppender(typ reflect.Type) AppenderFunc {
array_append.go#L34: func arrayAppender(typ reflect.Type) AppenderFunc {
array_scan.go#L19: func ArrayScanner(typ reflect.Type) ScannerFunc {
hstore_append.go#L10: func HstoreAppender(typ reflect.Type) AppenderFunc {
hstore_scan.go#L8: func HstoreScanner(typ reflect.Type) ScannerFunc {
scan_value.go#L71: func registerScanner(typ reflect.Type, fn ScannerFunc) {
scan_value.go#L80: func Scanner(typ reflect.Type) ScannerFunc {
scan_value.go#L89: func scanner(typ reflect.Type, pgArray bool) ScannerFunc {
scan_value.go#L134: func ptrScannerFunc(typ reflect.Type) ScannerFunc {
github.com/go-pg/zerochecker
zerochecker.go#L22: func Checker(typ reflect.Type) Func {
github.com/golang/protobuf/proto
properties.go#L91: Type reflect.Type
properties.go#L196: func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
properties.go#L219: func GetProperties(t reflect.Type) *StructProperties {
properties.go#L227: func newProperties(t reflect.Type) *StructProperties {
registry.go#L206: func MessageType(s messageName) reflect.Type {
registry.go#L208: return v.(reflect.Type)
registry.go#L212: var t reflect.Type
registry.go#L231: return v.(reflect.Type)
registry.go#L236: func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type {
registry.go#L253: func enumGoType(et protoreflect.EnumType) reflect.Type {
registry.go#L257: func messageGoType(mt protoreflect.MessageType) reflect.Type {
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#L303: typ reflect.Type // T
options.go#L309: func (tr *transformer) filter(s *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L361: typ reflect.Type // T
options.go#L367: func (cm *comparer) filter(_ *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L408: func Exporter(f func(reflect.Type) bool) Option {
options.go#L412: type exporter func(reflect.Type) bool
options.go#L414: func (exporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L423: m := make(map[reflect.Type]bool)
options.go#L431: return exporter(func(t reflect.Type) bool { return m[t] })
options.go#L520: 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#L38: 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
github.com/vmihailenco/msgpack/v5
decode_value.go#L48: func getDecoder(typ reflect.Type) decoderFunc {
decode_value.go#L57: func _getDecoder(typ reflect.Type) decoderFunc {
decode_value.go#L125: func ptrValueDecoder(typ reflect.Type) decoderFunc {
decode_value.go#L150: func nilAwareDecoder(typ reflect.Type, fn decoderFunc) decoderFunc {
encode_value.go#L42: func getEncoder(typ reflect.Type) encoderFunc {
encode_value.go#L51: func _getEncoder(typ reflect.Type) encoderFunc {
encode_value.go#L123: func ptrEncoderFunc(typ reflect.Type) encoderFunc {
ext.go#L12: Type reflect.Type
ext.go#L64: typ := t.(reflect.Type)
ext.go#L73: typ reflect.Type,
ext.go#L133: typ := t.(reflect.Type)
ext.go#L142: typ reflect.Type,
types.go#L70: typ reflect.Type
types.go#L77: func (m *structCache) Fields(typ reflect.Type, tag string) *fields {
types.go#L124: Type reflect.Type
types.go#L132: func newFields(typ reflect.Type) *fields {
types.go#L171: func getFields(typ reflect.Type, fallbackTag string) *fields {
types.go#L264: func inlineFields(fs *fields, typ reflect.Type, f *field, tag string) {
types.go#L276: func shouldInline(fs *fields, typ reflect.Type, f *field, tag string) bool {
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/descfmt
stringer.go#L108: var descriptorAccessors = map[reflect.Type][]string{
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#L36: oneofFields := make(map[reflect.Type]*coderFieldInfo)
codec_field.go#L193: func makeMessageFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L348: func makeGroupFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L439: func makeMessageSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L523: func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, _ marshalOptions) int {
codec_field.go#L533: func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) {
codec_field.go#L549: func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_field.go#L571: func isInitMessageSlice(p pointer, goType reflect.Type) error {
codec_field.go#L710: func makeGroupSliceFieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L741: func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, _ marshalOptions) int {
codec_field.go#L751: func appendGroupSlice(b []byte, p pointer, wiretag uint64, messageType reflect.Type, opts marshalOptions) ([]byte, error) {
codec_field.go#L766: func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L17: goType reflect.Type
codec_map.go#L27: func encoderFuncsForMap(fd protoreflect.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
codec_message.go#L40: ft reflect.Type
codec_message.go#L50: func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
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#L90: func newSingularConverter(t reflect.Type, fd protoreflect.FieldDescriptor) Converter {
convert.go#L147: goType reflect.Type
convert.go#L171: goType reflect.Type
convert.go#L195: goType reflect.Type
convert.go#L219: goType reflect.Type
convert.go#L243: goType reflect.Type
convert.go#L267: goType reflect.Type
convert.go#L291: goType reflect.Type
convert.go#L315: goType reflect.Type
convert.go#L345: goType reflect.Type
convert.go#L372: goType reflect.Type
convert.go#L376: func newEnumConverter(goType reflect.Type, fd protoreflect.FieldDescriptor) Converter {
convert.go#L415: goType reflect.Type
convert.go#L418: 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#L194: 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#L208: var oneofWrappers []reflect.Type
legacy_message.go#L268: func aberrantDeriveMessageName(t reflect.Type, name protoreflect.FullName) protoreflect.FullName {
legacy_message.go#L287: func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, tagVal string) {
legacy_message.go#L461: t reflect.Type
legacy_message.go#L473: func (mt aberrantMessageType) GoType() reflect.Type {
message.go#L28: GoReflectType reflect.Type // pointer to struct
message.go#L55: func getMessageInfo(mt reflect.Type) *MessageInfo {
message.go#L128: sizecacheType reflect.Type
message.go#L130: weakType reflect.Type
message.go#L132: unknownType reflect.Type
message.go#L134: extensionType reflect.Type
message.go#L138: oneofWrappersByType map[reflect.Type]protoreflect.FieldNumber
message.go#L139: oneofWrappersByNumber map[protoreflect.FieldNumber]reflect.Type
message.go#L142: func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
message.go#L151: oneofWrappersByType: map[reflect.Type]protoreflect.FieldNumber{},
message.go#L152: oneofWrappersByNumber: map[protoreflect.FieldNumber]reflect.Type{},
message_reflect.go#L41: func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
message_reflect.go#L116: func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
message_reflect.go#L166: func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
message_reflect.go#L185: var ft reflect.Type
message_reflect_field.go#L64: func fieldInfoForOneof(fd protoreflect.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
pointer_unsafe.go#L77: func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
pointer_unsafe.go#L83: func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
validate.go#L109: func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd protoreflect.FieldDescriptor, ft reflect.Type) validationInfo {
validate.go#L145: 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