reflect.Value.Type (method)
424 uses
reflect (current package)
deepequal.go#L31: if v1.Type() != v2.Type() {
deepequal.go#L80: typ := v1.Type()
deepequal.go#L109: if v1.Type().Elem().Kind() == Uint8 {
deepequal.go#L234: if v1.Type() != v2.Type() {
makefunc.go#L108: ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
swapper.go#L34: typ := v.Type().Elem().(*rtype)
value.go#L410: if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) {
value.go#L421: if xt := x.Type(); !xt.AssignableTo(elem) {
value.go#L2425: return "<" + v.Type().String() + " Value>"
value.go#L2450: func (v Value) Type() Type {
value.go#L2648: t := MakeSlice(s.Type(), i1, m)
value.go#L2669: typesMustMatch("reflect.AppendSlice", s.Type().Elem(), t.Type().Elem())
value.go#L3084: vt := v.Type()
value.go#L3305: if v.Type().Kind() == Float32 && t.Kind() == Float32 {
database/sql
convert.go#L401: if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
convert.go#L411: if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
convert.go#L412: dv.Set(sv.Convert(dv.Type()))
convert.go#L424: dv.Set(reflect.Zero(dv.Type()))
convert.go#L427: dv.Set(reflect.New(dv.Type().Elem()))
convert.go#L434: i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())
convert.go#L446: u64, err := strconv.ParseUint(s, 10, dv.Type().Bits())
convert.go#L458: f64, err := strconv.ParseFloat(s, dv.Type().Bits())
convert.go#L556: rv.Type().Elem().Implements(valuerReflectType) {
database/sql/driver
types.go#L230: rv.Type().Elem().Implements(valuerReflectType) {
types.go#L281: ek := rv.Type().Elem().Kind()
encoding/asn1
asn1.go#L677: fieldType := v.Type()
asn1.go#L898: if val.Type().Size() == 4 {
asn1.go#L987: err = StructuralError{"unsupported: " + v.Type().String()}
marshal.go#L462: switch value.Type() {
marshal.go#L488: t := v.Type()
marshal.go#L536: sliceType := v.Type()
marshal.go#L584: if v.Kind() == reflect.Interface && v.Type().NumMethod() == 0 {
marshal.go#L593: defaultValue := reflect.New(v.Type()).Elem()
marshal.go#L605: if reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface()) {
marshal.go#L610: if v.Type() == rawValueType {
marshal.go#L624: matchAny, tag, isCompound, ok := getUniversalType(v.Type())
marshal.go#L626: return nil, StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}
encoding/binary
binary.go#L408: if s := sizeof(v.Type().Elem()); s >= 0 {
binary.go#L414: t := v.Type()
binary.go#L423: return sizeof(v.Type())
binary.go#L549: t := v.Type()
binary.go#L618: t := v.Type()
binary.go#L639: switch v.Type().Kind() {
binary.go#L651: switch v.Type().Kind() {
binary.go#L663: switch v.Type().Kind() {
binary.go#L671: switch v.Type().Kind() {
encoding/json
decode.go#L443: if v.Kind() != reflect.Pointer && v.Type().Name() != "" && v.CanAddr() {
decode.go#L475: v.Set(reflect.New(v.Type().Elem()))
decode.go#L477: if v.Type().NumMethod() > 0 && v.CanInterface() {
decode.go#L509: d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
decode.go#L527: d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
decode.go#L550: newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
decode.go#L587: z := reflect.Zero(v.Type().Elem())
decode.go#L596: v.Set(reflect.MakeSlice(v.Type(), 0, 0))
decode.go#L615: d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
decode.go#L620: t := v.Type()
decode.go#L728: d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
decode.go#L735: subv.Set(reflect.New(subv.Type().Elem()))
decode.go#L771: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
decode.go#L865: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L876: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L886: d.saveError(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L892: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L906: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L911: v.Set(reflect.Zero(v.Type()))
decode.go#L919: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L925: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L927: d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L935: d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L943: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L949: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L951: if v.Type().Elem().Kind() != reflect.Uint8 {
decode.go#L952: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L963: if v.Type() == numberType && !isValidNumber(string(s)) {
decode.go#L971: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L978: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L985: if v.Kind() == reflect.String && v.Type() == numberType {
decode.go#L992: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L994: d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1002: d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1010: d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1018: d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1024: n, err := strconv.ParseFloat(s, v.Type().Bits())
decode.go#L1026: d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
encode.go#L378: return typeEncoder(v.Type())
encode.go#L485: e.error(&MarshalerError{v.Type(), err, "MarshalJSON"})
encode.go#L502: e.error(&MarshalerError{v.Type(), err, "MarshalJSON"})
encode.go#L518: e.error(&MarshalerError{v.Type(), err, "MarshalText"})
encode.go#L532: e.error(&MarshalerError{v.Type(), err, "MarshalText"})
encode.go#L620: if v.Type() == numberType {
encode.go#L720: e.error(&UnsupportedTypeError{v.Type()})
encode.go#L789: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L803: e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
encode.go#L884: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L940: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encoding/xml
marshal.go#L431: typ := val.Type()
marshal.go#L439: if pv.CanInterface() && pv.Type().Implements(marshalerType) {
marshal.go#L440: return p.marshalInterface(pv.Interface().(Marshaler), defaultStart(pv.Type(), finfo, startTemplate))
marshal.go#L450: if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
marshal.go#L451: return p.marshalTextInterface(pv.Interface().(encoding.TextMarshaler), defaultStart(pv.Type(), finfo, startTemplate))
marshal.go#L558: if val.CanInterface() && val.Type().Implements(marshalerAttrType) {
marshal.go#L571: if pv.CanInterface() && pv.Type().Implements(marshalerAttrType) {
marshal.go#L583: if val.CanInterface() && val.Type().Implements(textMarshalerType) {
marshal.go#L594: if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
marshal.go#L614: if val.Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
marshal.go#L624: if val.Type() == attrType {
marshal.go#L629: s, b, err := p.marshalSimple(val.Type(), val)
marshal.go#L765: return strconv.FormatFloat(val.Float(), 'g', -1, val.Type().Bits()), nil, nil
marshal.go#L832: if vf.CanInterface() && vf.Type().Implements(textMarshalerType) {
marshal.go#L844: if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
marshal.go#L868: if err := emit(p, strconv.AppendFloat(scratch[:0], vf.Float(), 'g', -1, vf.Type().Bits())); err != nil {
marshal.go#L894: if !(k == reflect.String || k == reflect.Slice && vf.Type().Elem().Kind() == reflect.Uint8) {
marshal.go#L895: return fmt.Errorf("xml: bad type for comment field of %s", val.Type())
read.go#L249: val.Set(reflect.New(val.Type().Elem()))
read.go#L253: if val.CanInterface() && val.Type().Implements(unmarshalerAttrType) {
read.go#L260: if pv.CanInterface() && pv.Type().Implements(unmarshalerAttrType) {
read.go#L266: if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
read.go#L273: if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
read.go#L278: if val.Type().Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
read.go#L282: val.Set(reflect.Append(val, reflect.Zero(val.Type().Elem())))
read.go#L292: if val.Type() == attrType {
read.go#L334: val.Set(reflect.New(val.Type().Elem()))
read.go#L339: if val.CanInterface() && val.Type().Implements(unmarshalerType) {
read.go#L347: if pv.CanInterface() && pv.Type().Implements(unmarshalerType) {
read.go#L352: if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
read.go#L358: if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
read.go#L379: return errors.New("unknown type " + v.Type().String())
read.go#L388: typ := v.Type()
read.go#L398: v.Set(reflect.Append(val, reflect.Zero(v.Type().Elem())))
read.go#L411: typ := v.Type()
read.go#L562: if saveData.IsValid() && saveData.CanInterface() && saveData.Type().Implements(textUnmarshalerType) {
read.go#L571: if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
read.go#L594: if t.Type().Elem().Kind() == reflect.Uint8 {
read.go#L607: dst.Set(reflect.New(dst.Type().Elem()))
read.go#L617: return errors.New("cannot unmarshal into " + dst0.Type().String())
read.go#L623: itmp, err := strconv.ParseInt(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
read.go#L633: utmp, err := strconv.ParseUint(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
read.go#L643: ftmp, err := strconv.ParseFloat(strings.TrimSpace(string(src)), dst.Type().Bits())
typeinfo.go#L360: t := v.Type()
typeinfo.go#L366: v.Set(reflect.New(v.Type().Elem()))
fmt
print.go#L326: p.buf.writeString(v.Type().String())
print.go#L341: p.buf.writeString(p.value.Type().String())
print.go#L512: p.buf.writeString(value.Type().String())
print.go#L760: p.buf.writeString(f.Type().String())
print.go#L789: p.buf.writeString(f.Type().String())
print.go#L801: if name := f.Type().Field(i).Name; name != "" {
print.go#L813: p.buf.writeString(f.Type().String())
print.go#L825: t := f.Type()
print.go#L846: p.buf.writeString(f.Type().String())
scan.go#L1021: s.errorString("type not a pointer: " + val.Type().String())
scan.go#L1028: v.SetInt(s.scanInt(verb, v.Type().Bits()))
scan.go#L1030: v.SetUint(s.scanUint(verb, v.Type().Bits()))
scan.go#L1035: typ := v.Type()
scan.go#L1037: s.errorString("can't scan type: " + val.Type().String())
scan.go#L1047: v.SetFloat(s.convertFloat(s.floatToken(), v.Type().Bits()))
scan.go#L1049: v.SetComplex(s.scanComplex(verb, v.Type().Bits()))
scan.go#L1051: s.errorString("can't scan type: " + val.Type().String())
github.com/aws/aws-sdk-go-v2/aws/transport/http
client.go#L201: srcValType := srcVal.Type()
github.com/go-pg/pg/v10/internal
util.go#L31: elemType := v.Type().Elem()
github.com/go-pg/pg/v10/orm
composite.go#L19: v.Set(reflect.Zero(v.Type()))
composite.go#L28: v.Set(reflect.New(v.Type().Elem()))
field.go#L104: panic(fmt.Errorf("pg: AppendValue(unsupported %s)", fv.Type()))
insert.go#L176: err = fmt.Errorf("pg: can't bulk-insert empty slice %s", value.Type())
model.go#L80: typ := v.Type().Elem()
model.go#L93: return nil, fmt.Errorf("pg: Model(non-pointer %s)", v.Type().String())
model.go#L100: if v.Type() != timeType {
model.go#L119: typ := v.Type()
model_func.go#L23: fnt := m.fnv.Type()
model_table_many.go#L69: clone := reflect.New(m.strct.Type()).Elem()
model_table_slice.go#L31: m.init(slice.Type())
model_table_struct.go#L35: table: GetTable(v.Type()),
model_table_struct.go#L132: m.strct.Set(reflect.New(m.strct.Type().Elem()))
table.go#L1427: v.Set(reflect.New(v.Type()).Elem())
table_params.go#L22: table: GetTable(v.Type()),
update.go#L159: err = fmt.Errorf("pg: can't bulk-update empty slice %s", value.Type())
util.go#L28: elemType := v.Type().Elem()
util.go#L30: return indirect(v.Index(0).Elem()).Type()
util.go#L84: v.Set(reflect.New(v.Type().Elem()))
github.com/go-pg/pg/v10/types
append_value.go#L138: appender := Appender(v.Type())
append_value.go#L191: if v.Type() == timeType {
array.go#L29: append: ArrayAppender(v.Type()),
array.go#L30: scan: ArrayScanner(v.Type()),
array.go#L36: panic(fmt.Errorf("pg: Array(unsupported %s)", a.v.Type()))
array.go#L43: return fmt.Errorf("pg: Array(unsupported %s)", a.v.Type())
array.go#L47: return fmt.Errorf("pg: Array(non-pointer %s)", a.v.Type())
array_scan.go#L56: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
array_scan.go#L63: v.Set(reflect.Zero(v.Type()))
array_scan.go#L70: v.Set(reflect.MakeSlice(v.Type(), 0, 0))
array_scan.go#L116: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
array_scan.go#L153: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
array_scan.go#L200: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
array_scan.go#L247: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
hstore.go#L26: typ := v.Type()
hstore.go#L55: return fmt.Errorf("pg: Hstore(non-pointer %s)", h.v.Type())
hstore_append.go#L16: err := fmt.Errorf("pg.Hstore(unsupported %s)", v.Type())
hstore_scan.go#L13: return fmt.Errorf("pg.Hstore(unsupported %s)", v.Type())
scan.go#L60: return fmt.Errorf("pg: Decode(non-pointer %s)", vv.Type().String())
scan_value.go#L138: return fmt.Errorf("pg: Scan(unsupported %s)", v.Type())
scan_value.go#L146: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
scan_value.go#L148: v.Set(reflect.Zero(v.Type()))
scan_value.go#L154: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
scan_value.go#L156: v.Set(reflect.New(v.Type().Elem()))
scan_value.go#L175: scanner := Scanner(v.Type())
scan_value.go#L183: return fmt.Errorf("pg: Scan(unsupported %s)", v.Type())
scan_value.go#L254: v.Set(reflect.New(v.Type()).Elem())
scan_value.go#L373: v.Set(reflect.New(v.Type().Elem()))
scan_value.go#L381: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
scan_value.go#L395: v.Set(reflect.New(v.Type().Elem()))
scan_value.go#L403: return fmt.Errorf("pg: Scan(non-settable %s)", v.Type())
github.com/golang/mock/gomock
call.go#L118: ft := v.Type()
call.go#L152: if c.methodType.NumIn() != v.Type().NumIn() {
call.go#L154: c.receiver, c.method, v.Type().NumIn(), c.methodType.NumIn(), c.origin)
call.go#L158: ft := v.Type()
controller.go#L193: for i := 0; i < recv.Type().NumMethod(); i++ {
controller.go#L194: if recv.Type().Method(i).Name == method {
controller.go#L195: return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...)
matchers.go#L114: if x1Val.Type().AssignableTo(x2Val.Type()) {
matchers.go#L115: x1ValConverted := x1Val.Convert(x2Val.Type())
github.com/golang/protobuf/proto
extensions.go#L174: rv2 := reflect.New(rv.Type())
properties.go#L278: Type: reflect.ValueOf(wrapper).Type(), // *T
github.com/google/go-cmp/cmp
compare.go#L146: if !vx.IsValid() || !vy.IsValid() || vx.Type() != vy.Type() {
compare.go#L159: t = vx.Type()
compare.go#L573: if vx.Type() != vy.Type() {
compare.go#L577: s.compareAny(TypeAssertion{&typeAssertion{pathStep{vx.Type(), vx, vy}}})
compare.go#L620: tf := t.(*transformer).fnc.Type()
compare.go#L666: vc := reflect.New(v.Type()).Elem()
options.go#L161: if !function.IsType(v.Type(), function.ValueFilter) || v.IsNil() {
options.go#L166: if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
options.go#L279: if !function.IsType(v.Type(), function.Transformer) || v.IsNil() {
options.go#L291: if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
options.go#L321: step := Transform{&transform{pathStep{typ: tr.fnc.Type().Out(0)}, tr}}
options.go#L346: if !function.IsType(v.Type(), function.Equal) || v.IsNil() {
options.go#L350: if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
report_reflect.go#L118: t := v.Type()
report_reflect.go#L295: if v.Type().Name() == "" {
report_slices.go#L50: if t.Kind() == reflect.Interface && !vx.IsNil() && !vy.IsNil() && vx.Elem().Type() == vy.Elem().Type() {
report_slices.go#L52: t = vx.Type()
report_slices.go#L95: t = vx.Type()
github.com/google/go-cmp/cmp/internal/value
pointer_unsafe.go#L26: return Pointer{unsafe.Pointer(v.Pointer()), v.Type()}
sort.go#L37: switch x.Type().Kind() {
sort.go#L85: tx, ty := vx.Type(), vy.Type()
sort.go#L101: return reflect.ValueOf(vx.Type()).Pointer() < reflect.ValueOf(vy.Type()).Pointer()
sort.go#L104: panic(fmt.Sprintf("%T is not comparable", x.Type()))
github.com/vmihailenco/msgpack/v5
decode.go#L283: return fmt.Errorf("msgpack: Decode(non-pointer %s)", vv.Type().String())
decode.go#L308: decode := getDecoder(v.Type())
decode.go#L331: v.Set(reflect.Zero(v.Type()))
decode_map.go#L29: typ := v.Type()
decode_map.go#L237: typ := v.Type()
decode_map.go#L292: v.Set(reflect.Zero(v.Type()))
decode_map.go#L296: fields := structs.Fields(v.Type(), d.structTag)
decode_map.go#L312: v.Set(reflect.Zero(v.Type()))
decode_map.go#L316: fields := structs.Fields(v.Type(), d.structTag)
decode_slice.go#L90: v.Set(reflect.Zero(v.Type()))
decode_slice.go#L94: v.Set(reflect.MakeSlice(v.Type(), 0, 0))
decode_slice.go#L122: v = reflect.AppendSlice(v, reflect.MakeSlice(v.Type(), diff, diff))
decode_slice.go#L136: return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n)
decode_string.go#L187: return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n)
decode_value.go#L130: v.Set(reflect.Zero(v.Type()))
decode_value.go#L135: v.Set(reflect.New(v.Type().Elem()))
decode_value.go#L157: v.Set(reflect.New(v.Type().Elem()))
decode_value.go#L194: if v.Type() == errorType {
decode_value.go#L208: return fmt.Errorf("msgpack: Decode(unsupported %s)", v.Type())
encode.go#L238: fn := getEncoder(v.Type())
encode_map.go#L147: structFields := structs.Fields(strct.Type(), e.structTag)
encode_value.go#L190: return fmt.Errorf("msgpack: Encode(unsupported %s)", v.Type())
types.go#L398: elemType := v.Type().Elem()
go/ast
print.go#L154: p.printf("%s (len = %d) {", x.Type(), x.Len())
print.go#L182: p.printf("%s {", x.Type())
print.go#L200: p.printf("%s (len = %d) {", x.Type(), x.Len())
print.go#L214: t := x.Type()
google.golang.org/protobuf/internal/descfmt
stringer.go#L44: name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
stringer.go#L46: name = reflect.ValueOf(vs).Elem().Type().Name()
stringer.go#L124: rt := rv.MethodByName("ProtoType").Type().In(0)
stringer.go#L217: panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
google.golang.org/protobuf/internal/impl
codec_field.go#L59: if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
codec_field.go#L81: return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]
codec_field.go#L105: dst.AsValueOf(ft).Elem().Set(reflect.New(src.AsValueOf(ft).Elem().Elem().Elem().Type()))
convert.go#L152: if v.Type() != c.goType {
convert.go#L153: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L165: return v.IsValid() && v.Type() == c.goType
convert.go#L176: if v.Type() != c.goType {
convert.go#L177: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L189: return v.IsValid() && v.Type() == c.goType
convert.go#L200: if v.Type() != c.goType {
convert.go#L201: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L213: return v.IsValid() && v.Type() == c.goType
convert.go#L224: if v.Type() != c.goType {
convert.go#L225: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L237: return v.IsValid() && v.Type() == c.goType
convert.go#L248: if v.Type() != c.goType {
convert.go#L249: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L261: return v.IsValid() && v.Type() == c.goType
convert.go#L272: if v.Type() != c.goType {
convert.go#L273: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L285: return v.IsValid() && v.Type() == c.goType
convert.go#L296: if v.Type() != c.goType {
convert.go#L297: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L309: return v.IsValid() && v.Type() == c.goType
convert.go#L320: if v.Type() != c.goType {
convert.go#L321: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L339: return v.IsValid() && v.Type() == c.goType
convert.go#L350: if v.Type() != c.goType {
convert.go#L351: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L366: return v.IsValid() && v.Type() == c.goType
convert.go#L387: if v.Type() != c.goType {
convert.go#L388: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L403: return v.IsValid() && v.Type() == c.goType
convert.go#L423: if v.Type() != c.goType {
convert.go#L424: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L430: v = reflect.Zero(reflect.PtrTo(v.Type()))
convert.go#L448: if rv.Type() != reflect.PtrTo(c.goType) {
convert.go#L449: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), reflect.PtrTo(c.goType)))
convert.go#L454: rv = reflect.Zero(rv.Type().Elem())
convert.go#L457: if rv.Type() != c.goType {
convert.go#L458: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
convert.go#L472: return rv.Type() == reflect.PtrTo(c.goType)
convert.go#L474: return rv.Type() == c.goType
convert.go#L478: return v.IsValid() && v.Type() == c.goType
convert_list.go#L30: if v.Type() != c.goType {
convert_list.go#L31: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert_list.go#L51: return list.v.Type().Elem() == c.goType
convert_list.go#L55: return v.IsValid() && v.Type() == c.goType
convert_list.go#L72: if v.Type() != c.goType {
convert_list.go#L73: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert_list.go#L87: return list.v.Type() == c.goType
convert_list.go#L91: return v.IsValid() && v.Type() == c.goType
convert_map.go#L31: if v.Type() != c.goType {
convert_map.go#L32: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert_map.go#L46: return mapv.v.Type() == c.goType
convert_map.go#L50: return v.IsValid() && v.Type() == c.goType
legacy_enum.go#L37: et := legacyLoadEnumType(v.Type())
legacy_message.go#L25: t := v.Type()
legacy_message.go#L496: m.v.Elem().Set(reflect.Zero(m.v.Type().Elem()))
legacy_message.go#L505: return LegacyLoadMessageDesc(m.v.Type())
legacy_message.go#L508: return aberrantMessageType{m.v.Type()}
legacy_message.go#L511: if m.v.Type().Kind() == reflect.Ptr {
legacy_message.go#L512: return aberrantMessage{reflect.New(m.v.Type().Elem())}
legacy_message.go#L514: return aberrantMessage{reflect.Zero(m.v.Type())}
message_reflect.go#L419: rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
message_reflect_field.go#L91: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L98: if rv.IsNil() || rv.Elem().Type().Elem() != ot {
message_reflect_field.go#L103: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L110: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L118: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L129: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L167: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L220: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L296: panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
message_reflect_field.go#L301: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L434: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L501: return si.oneofWrappersByType[rv.Type().Elem()]
gotest.tools/v3/assert/cmp
compare.go#L175: switch colValue.Type().Kind() {
compare.go#L177: if itemValue.Type().Kind() != reflect.String {
compare.go#L185: if itemValue.Type() != colValue.Type().Key() {
compare.go#L187: "%v can not contain a %v key", colValue.Type(), itemValue.Type()))
compare.go#L266: return fmt.Sprintf("%v (type %s) is not nil", reflect.Indirect(value), value.Type())
compare.go#L277: kind := value.Type().Kind()
compare.go#L285: return ResultFailure(fmt.Sprintf("%v (type %s) can not be nil", value, value.Type()))
compare.go#L353: if errValue.Type() == expectedType {
compare.go#L364: if errValue.Type().Implements(expectedType) {
html/template
content.go#L143: for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Pointer && !v.IsNil() {
js.go#L135: for !v.Type().Implements(jsonMarshalType) && v.Kind() == reflect.Pointer && !v.IsNil() {
internal/buildcfg
exp.go#L72: rt := rv.Type()
exp.go#L142: rt := rv.Type()
internal/fmtsort
sort.go#L53: if mapValue.Type().Kind() != reflect.Map {
sort.go#L80: aType, bType := aVal.Type(), bVal.Type()
sort.go#L174: c := compare(reflect.ValueOf(aVal.Elem().Type()), reflect.ValueOf(bVal.Elem().Type()))
net/http
transport.go#L373: if rv := reflect.ValueOf(altProto["https"]); rv.IsValid() && rv.Type().Kind() == reflect.Struct && rv.Type().NumField() == 1 {
net/http/httptrace
trace.go#L181: structType := tv.Type()
trace.go#L184: hookType := tf.Type()
testing
fuzz.go#L223: fnType := fn.Type()
text/template
exec.go#L397: if val.Type().ChanDir() == reflect.SendDir {
exec.go#L459: if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
exec.go#L614: typ := receiver.Type()
exec.go#L636: tField, ok := receiver.Type().FieldByName(fieldName)
exec.go#L654: if nameVal.Type().AssignableTo(receiver.Type().Key()) {
exec.go#L664: result = reflect.Zero(receiver.Type().Elem())
exec.go#L672: etyp := receiver.Type().Elem()
exec.go#L701: typ := fun.Type()
exec.go#L721: if v.Type() == reflectValueType {
exec.go#L815: if typ == reflectValueType && value.Type() != typ {
exec.go#L818: if typ != nil && !value.Type().AssignableTo(typ) {
exec.go#L821: if value.Type().AssignableTo(typ) {
exec.go#L831: case value.Kind() == reflect.Pointer && value.Type().Elem().AssignableTo(typ):
exec.go#L836: case reflect.PointerTo(value.Type()).AssignableTo(typ) && value.CanAddr():
exec.go#L839: s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
exec.go#L1016: s.errorf("can't print %s of type %s", n, v.Type())
exec.go#L1034: if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
exec.go#L1035: if v.CanAddr() && (reflect.PointerTo(v.Type()).Implements(errorType) || reflect.PointerTo(v.Type()).Implements(fmtStringerType)) {
funcs.go#L97: if !goodFunc(v.Type()) {
funcs.go#L98: panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut()))
funcs.go#L165: if value.Type().AssignableTo(argType) {
funcs.go#L168: if intLike(value.Kind()) && intLike(argType.Kind()) && value.Type().ConvertibleTo(argType) {
funcs.go#L172: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L196: return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
funcs.go#L228: index, err := prepareArg(index, item.Type().Key())
funcs.go#L235: item = reflect.Zero(item.Type().Elem())
funcs.go#L241: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L271: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L308: return 0, fmt.Errorf("len of type %s", item.Type())
funcs.go#L320: typ := fn.Type()
funcs.go#L443: if t1 := arg1.Type(); !t1.Comparable() {
funcs.go#L485: if t2 := arg.Type(); !t2.Comparable() {