type reflect.Type
365 uses
reflect (current package)
deepequal.go#L21: typ Type
makefunc.go#L47: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
type.go#L39: type Type interface {
type.go#L104: Implements(u Type) bool
type.go#L107: AssignableTo(u Type) bool
type.go#L113: ConvertibleTo(u Type) bool
type.go#L158: Elem() Type
type.go#L192: In(i int) Type
type.go#L196: Key() Type
type.go#L217: Out(i int) Type
type.go#L617: Type Type // method type
type.go#L860: in := make([]Type, 0, 1+len(ft.in()))
type.go#L865: out := make([]Type, 0, len(ft.out()))
type.go#L947: func (t *rtype) Elem() Type {
type.go#L1000: func (t *rtype) In(i int) Type {
type.go#L1008: func (t *rtype) Key() Type {
type.go#L1048: func (t *rtype) Out(i int) Type {
type.go#L1149: Type Type // field type
type.go#L1424: func TypeOf(i any) Type {
type.go#L1437: func PtrTo(t Type) Type { return PointerTo(t) }
type.go#L1441: func PointerTo(t Type) Type {
type.go#L1496: func (t *rtype) Implements(u Type) bool {
type.go#L1506: func (t *rtype) AssignableTo(u Type) bool {
type.go#L1514: func (t *rtype) ConvertibleTo(u Type) bool {
type.go#L1648: func haveIdenticalType(T, V Type, cmpTags bool) 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#L1905: func MapOf(key, elem Type) Type {
type.go#L1916: return mt.(Type)
type.go#L1925: return ti.(Type)
type.go#L1969: return ti.(Type)
type.go#L2006: func FuncOf(in, out []Type, variadic bool) Type {
type.go#L2095: addToCache := func(tt *rtype) Type {
type.go#L2350: func SliceOf(t Type) Type {
type.go#L2356: return slice.(Type)
type.go#L2365: return ti.(Type)
type.go#L2380: return ti.(Type)
type.go#L2431: func StructOf(fields []StructField) Type {
type.go#L2708: for _, st := range ts.([]Type) {
type.go#L2720: for _, st := range ts.([]Type) {
type.go#L2728: addToCache := func(t Type) Type {
type.go#L2729: var ts []Type
type.go#L2731: ts = ti.([]Type)
type.go#L2894: func ArrayOf(length int, elem Type) Type {
type.go#L2904: return array.(Type)
type.go#L2913: return ti.(Type)
type.go#L3023: return ti.(Type)
type.go#L3039: func toType(t *rtype) Type {
value.go#L2450: func (v Value) Type() Type {
value.go#L2607: func typesMustMatch(what string, t1, t2 Type) {
value.go#L2897: func MakeSlice(typ Type, len, cap int) Value {
value.go#L2916: func MakeChan(typ Type, buffer int) Value {
value.go#L2932: func MakeMap(typ Type) Value {
value.go#L2938: func MakeMapWithSize(typ Type, n int) Value {
value.go#L2978: func Zero(typ Type) Value {
value.go#L3004: func New(typ Type) Value {
value.go#L3021: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L3070: func (v Value) Convert(t Type) Value {
value.go#L3083: func (v Value) CanConvert(t Type) bool {
value.go#L3102: func convertOp(dst, src *rtype) func(Value, Type) Value {
value.go#L3195: func makeInt(f flag, bits uint64, t Type) Value {
value.go#L3213: func makeFloat(f flag, v float64, t Type) Value {
value.go#L3226: func makeFloat32(f flag, v float32, t Type) Value {
value.go#L3235: func makeComplex(f flag, v complex128, t Type) Value {
value.go#L3247: func makeString(f flag, v string, t Type) Value {
value.go#L3254: func makeBytes(f flag, v []byte, t Type) Value {
value.go#L3261: func makeRunes(f flag, v []rune, t Type) Value {
value.go#L3274: func cvtInt(v Value, t Type) Value {
value.go#L3279: func cvtUint(v Value, t Type) Value {
value.go#L3284: func cvtFloatInt(v Value, t Type) Value {
value.go#L3289: func cvtFloatUint(v Value, t Type) Value {
value.go#L3294: func cvtIntFloat(v Value, t Type) Value {
value.go#L3299: func cvtUintFloat(v Value, t Type) Value {
value.go#L3304: func cvtFloat(v Value, t Type) Value {
value.go#L3315: func cvtComplex(v Value, t Type) Value {
value.go#L3320: func cvtIntString(v Value, t Type) Value {
value.go#L3329: func cvtUintString(v Value, t Type) Value {
value.go#L3338: func cvtBytesString(v Value, t Type) Value {
value.go#L3343: func cvtStringBytes(v Value, t Type) Value {
value.go#L3348: func cvtRunesString(v Value, t Type) Value {
value.go#L3353: func cvtStringRunes(v Value, t Type) Value {
value.go#L3358: func cvtSliceArrayPtr(v Value, t Type) Value {
value.go#L3368: func cvtDirect(v Value, typ Type) Value {
value.go#L3383: func cvtT2I(v Value, typ Type) Value {
value.go#L3395: 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#L3129: scanType reflect.Type
sql.go#L3155: func (ci *ColumnType) ScanType() reflect.Type {
database/sql/driver
driver.go#L466: ColumnTypeScanType(index int) reflect.Type
encoding/asn1
asn1.go#L605: func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
asn1.go#L1096: Type reflect.Type
common.go#L151: func getUniversalType(t reflect.Type) (matchAny bool, tagNumber int, isCompound, ok bool) {
encoding/binary
binary.go#L428: func sizeof(t reflect.Type) int {
encoding/json
decode.go#L126: Type reflect.Type // type of Go value it could not be assigned to
decode.go#L145: Type reflect.Type
decode.go#L156: Type reflect.Type
decode.go#L205: Struct reflect.Type
encode.go#L232: Type reflect.Type
encode.go#L266: Type reflect.Type
encode.go#L381: func typeEncoder(t reflect.Type) encoderFunc {
encode.go#L417: func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
encode.go#L770: func newStructEncoder(t reflect.Type) encoderFunc {
encode.go#L820: func newMapEncoder(t reflect.Type) encoderFunc {
encode.go#L893: func newSliceEncoder(t reflect.Type) encoderFunc {
encode.go#L921: func newArrayEncoder(t reflect.Type) encoderFunc {
encode.go#L949: func newPtrEncoder(t reflect.Type) encoderFunc {
encode.go#L990: func typeByIndex(t reflect.Type, index []int) reflect.Type {
encode.go#L1185: typ reflect.Type
encode.go#L1214: func typeFields(t reflect.Type) structFields {
encode.go#L1220: var count, nextCount map[reflect.Type]int
encode.go#L1223: visited := map[reflect.Type]bool{}
encode.go#L1233: count, nextCount = nextCount, map[reflect.Type]int{}
encode.go#L1413: func cachedTypeFields(t reflect.Type) structFields {
encoding/xml
marshal.go#L642: func defaultStart(typ reflect.Type, finfo *fieldInfo, startTemplate *StartElement) StartElement {
marshal.go#L758: func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
marshal.go#L1039: 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#L268: func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error {
typeinfo.go#L338: 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/mock/gomock
call.go#L30: methodType reflect.Type // the type of the method
call.go#L49: func newCall(t TestHelper, receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call {
controller.go#L203: func (ctrl *Controller) RecordCallWithMethodType(receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call {
matchers.go#L160: targetType reflect.Type
matchers.go#L328: if xt, ok := x.(reflect.Type); ok {
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#L145: var t reflect.Type
compare.go#L301: func (s *state) tryOptions(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L310: func (s *state) tryMethod(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L373: func (s *state) compareStruct(t reflect.Type, vx, vy reflect.Value) {
compare.go#L416: func (s *state) compareSlice(t reflect.Type, vx, vy reflect.Value) {
compare.go#L508: func (s *state) compareMap(t reflect.Type, vx, vy reflect.Value) {
compare.go#L550: func (s *state) comparePtr(t reflect.Type, vx, vy reflect.Value) {
compare.go#L567: 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#L300: typ reflect.Type // T
options.go#L306: func (tr *transformer) filter(s *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L358: typ reflect.Type // T
options.go#L364: func (cm *comparer) filter(_ *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L405: 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#L38: Type() reflect.Type
path.go#L154: typ reflect.Type
path.go#L158: func (ps pathStep) Type() reflect.Type { return ps.typ }
path.go#L187: func (sf StructField) Type() reflect.Type { return sf.typ }
path.go#L218: func (si SliceIndex) Type() reflect.Type { return si.typ }
path.go#L262: func (mi MapIndex) Type() reflect.Type { return mi.typ }
path.go#L275: func (in Indirect) Type() reflect.Type { return in.typ }
path.go#L285: func (ta TypeAssertion) Type() reflect.Type { return ta.typ }
path.go#L296: 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_unsafe.go#L18: 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 {
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#L1579: func (f matchStringOnly) CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error {
testing.go#L1583: func (f matchStringOnly) ReadCorpus(string, []reflect.Type) ([]corpusEntry, error) {
testing.go#L1586: func (f matchStringOnly) CheckCorpus([]any, []reflect.Type) error { return nil }
testing.go#L1631: CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error
testing.go#L1633: ReadCorpus(string, []reflect.Type) ([]corpusEntry, error)
testing.go#L1634: CheckCorpus([]any, []reflect.Type) error
text/template
exec.go#L792: func canBeNil(typ reflect.Type) bool {
exec.go#L803: func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
exec.go#L845: func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L892: func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L903: func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L914: func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L925: func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L936: func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L947: func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
funcs.go#L113: func goodFunc(typ reflect.Type) bool {
funcs.go#L158: func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
funcs.go#L328: var dddType reflect.Type