reflect.Value.Type (method)
650 uses
reflect (current package)
deepequal.go#L28: if v1.Type() != v2.Type() {
deepequal.go#L77: typ := v1.Type()
deepequal.go#L215: if v1.Type() != v2.Type() {
makefunc.go#L106: ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
swapper.go#L33: typ := v.Type().Elem().(*rtype)
value.go#L405: if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) {
value.go#L416: if xt := x.Type(); !xt.AssignableTo(elem) {
value.go#L1880: return "<" + v.Type().String() + " Value>"
value.go#L1905: func (v Value) Type() Type {
value.go#L2040: t := MakeSlice(s.Type(), i1, m)
value.go#L2061: typesMustMatch("reflect.AppendSlice", s.Type().Elem(), t.Type().Elem())
value.go#L2668: 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/gob
decode.go#L233: v.Set(reflect.New(v.Type().Elem()))
decode.go#L374: errorf("bad %s slice length: %d", value.Type(), n)
decode.go#L377: value.Set(reflect.MakeSlice(value.Type(), n, n))
decode.go#L392: errorf("bad %s slice length: %d", value.Type(), n)
decode.go#L521: isPtr := value.Type().Elem().Kind() == reflect.Ptr
decode.go#L615: typ := value.Type()
decode.go#L656: value.Set(reflect.Zero(value.Type()))
decode.go#L1189: ut := userType(value.Type())
decoder.go#L184: if value.Type().Kind() != reflect.Ptr {
encode.go#L390: errorf("gob: cannot encode nil pointer of type %s inside interface", iv.Elem().Type())
encode.go#L400: ut := userType(iv.Elem().Type())
encode.go#L465: panic("unknown type in isZero " + val.Type().String())
encode.go#L700: if ut.externalEnc == 0 && value.Type().Kind() == reflect.Struct {
encoder.go#L223: panic("gob: cannot encode nil pointer of type " + value.Type().String())
encoder.go#L234: ut, err := validUserType(value.Type())
encoding/json
decode.go#L440: if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
decode.go#L472: v.Set(reflect.New(v.Type().Elem()))
decode.go#L474: if v.Type().NumMethod() > 0 && v.CanInterface() {
decode.go#L506: d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
decode.go#L524: d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
decode.go#L547: newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
decode.go#L584: z := reflect.Zero(v.Type().Elem())
decode.go#L593: v.Set(reflect.MakeSlice(v.Type(), 0, 0))
decode.go#L612: d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
decode.go#L617: t := v.Type()
decode.go#L722: d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
decode.go#L729: subv.Set(reflect.New(subv.Type().Elem()))
decode.go#L762: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
decode.go#L854: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.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#L875: d.saveError(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L881: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L895: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L900: v.Set(reflect.Zero(v.Type()))
decode.go#L908: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L914: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L916: d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L924: d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L932: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L938: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L940: if v.Type().Elem().Kind() != reflect.Uint8 {
decode.go#L941: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L952: if v.Type() == numberType && !isValidNumber(string(s)) {
decode.go#L960: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L967: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L974: if v.Kind() == reflect.String && v.Type() == numberType {
decode.go#L981: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L983: d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L991: d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L999: d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1007: d.saveError(&UnmarshalTypeError{Value: "number " + s, Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1013: n, err := strconv.ParseFloat(s, v.Type().Bits())
decode.go#L1015: 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#L802: e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
encode.go#L883: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L939: 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#L554: if val.CanInterface() && val.Type().Implements(marshalerAttrType) {
marshal.go#L567: if pv.CanInterface() && pv.Type().Implements(marshalerAttrType) {
marshal.go#L579: if val.CanInterface() && val.Type().Implements(textMarshalerType) {
marshal.go#L590: if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
marshal.go#L610: if val.Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
marshal.go#L620: if val.Type() == attrType {
marshal.go#L625: s, b, err := p.marshalSimple(val.Type(), val)
marshal.go#L761: return strconv.FormatFloat(val.Float(), 'g', -1, val.Type().Bits()), nil, nil
marshal.go#L828: if vf.CanInterface() && vf.Type().Implements(textMarshalerType) {
marshal.go#L840: if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
marshal.go#L864: if err := emit(p, strconv.AppendFloat(scratch[:0], vf.Float(), 'g', -1, vf.Type().Bits())); err != nil {
marshal.go#L890: if !(k == reflect.String || k == reflect.Slice && vf.Type().Elem().Kind() == reflect.Uint8) {
marshal.go#L891: 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/aws/awsutil
copy.go#L51: e := src.Type().Elem()
copy.go#L68: t := dst.Type()
copy.go#L82: s := reflect.MakeSlice(src.Type(), src.Len(), src.Cap())
copy.go#L92: s := reflect.MakeMap(src.Type())
copy.go#L96: v2 := reflect.New(v.Type()).Elem()
copy.go#L104: if src.Type().AssignableTo(dst.Type()) {
path_value.go#L81: value.Set(reflect.Zero(value.Type()))
path_value.go#L89: value.Set(reflect.New(value.Type().Elem()))
path_value.go#L208: dstVal.Set(reflect.Zero(dstVal.Type()))
path_value.go#L212: srcVal = reflect.Zero(dstVal.Type())
prettify.go#L27: strtype := v.Type().String()
prettify.go#L39: for i := 0; i < v.Type().NumField(); i++ {
prettify.go#L40: name := v.Type().Field(i).Name
prettify.go#L64: strtype := v.Type().String()
string_value.go#L26: for i := 0; i < v.Type().NumField(); i++ {
string_value.go#L27: ft := v.Type().Field(i)
github.com/aws/aws-sdk-go/private/protocol
idempotency.go#L46: v.Set(reflect.New(v.Type().Elem()))
github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
build.go#L19: var timeType = reflect.ValueOf(time.Time{}).Type()
build.go#L20: var byteSliceType = reflect.ValueOf([]byte{}).Type()
build.go#L37: vtype := value.Type()
build.go#L44: if value.Type() != timeType {
build.go#L82: field, _ := value.Type().FieldByName(payload)
build.go#L93: t := value.Type()
build.go#L254: return fmt.Errorf("unsupported JSON value %v (%s)", value.Interface(), value.Type())
unmarshal.go#L81: vtype := value.Type()
unmarshal.go#L131: t := value.Type()
unmarshal.go#L134: s := reflect.New(value.Type().Elem())
unmarshal.go#L191: value.Set(reflect.MakeSlice(value.Type(), l, l))
unmarshal.go#L214: value.Set(reflect.MakeMap(value.Type()))
unmarshal.go#L219: vvalue := reflect.New(value.Type().Elem()).Elem()
unmarshal.go#L262: return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
unmarshal.go#L291: return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
unmarshal.go#L298: return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
github.com/aws/aws-sdk-go/private/protocol/query/queryutil
queryutil.go#L71: t := value.Type()
queryutil.go#L243: return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())
github.com/aws/aws-sdk-go/private/protocol/rest
build.go#L75: if n := v.Type().Field(i).Name; n[0:1] == strings.ToLower(n[0:1]) {
build.go#L80: field := v.Type().Field(i)
build.go#L136: if field, ok := v.Type().FieldByName("_"); ok {
build.go#L138: pfield, _ := v.Type().FieldByName(payloadName)
build.go#L152: fmt.Errorf("unknown payload type %s", payload.Type()))
build.go#L306: err := fmt.Errorf("unsupported value for param %v (%s)", v.Interface(), v.Type())
payload.go#L15: if field, ok := v.Type().FieldByName("_"); ok {
payload.go#L17: field, _ := v.Type().FieldByName(payloadName)
payload.go#L37: if field, ok := v.Type().FieldByName("_"); ok {
payload.go#L39: if member, ok := v.Type().FieldByName(payloadName); ok {
unmarshal.go#L61: if field, ok := v.Type().FieldByName("_"); ok {
unmarshal.go#L63: pfield, _ := v.Type().FieldByName(payloadName)
unmarshal.go#L88: switch payload.Type().String() {
unmarshal.go#L105: fmt.Errorf("unknown payload type %s", payload.Type()))
unmarshal.go#L118: m, field := v.Field(i), v.Type().Field(i)
unmarshal.go#L253: err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())
github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
build.go#L86: if field, ok := value.Type().FieldByName("_"); ok {
build.go#L108: field, _ := value.Type().FieldByName(payload)
build.go#L135: t := value.Type()
build.go#L304: tag.Get("locationName"), value.Interface(), value.Type().Name())
unmarshal.go#L75: rtype := r.Type()
unmarshal.go#L116: t := r.Type()
unmarshal.go#L119: s := reflect.New(r.Type().Elem())
unmarshal.go#L171: t := r.Type()
unmarshal.go#L211: r.Set(reflect.MakeMap(r.Type()))
unmarshal.go#L241: valueR := reflect.New(r.Type().Elem()).Elem()
unmarshal.go#L296: return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())
github.com/ghodss/yaml
fields.go#L26: if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
fields.go#L49: v.Set(reflect.New(v.Type().Elem()))
fields.go#L51: v = reflect.New(v.Type().Elem())
fields.go#L54: if v.Type().NumMethod() > 0 {
yaml.go#L179: fields := cachedTypeFields(t.Type())
yaml.go#L204: jtv := reflect.Zero(t.Type().Elem())
yaml.go#L232: ev := reflect.Indirect(reflect.New(t.Type().Elem()))
github.com/go-git/gcfg
set.go#L41: f, ok := v.Type().FieldByNameFunc(func(fieldName string) bool {
set.go#L45: f, _ := v.Type().FieldByName(fieldName)
set.go#L171: t := reflect.ValueOf(d).Type().Elem()
set.go#L180: k := reflect.ValueOf(d).Type().Elem().Kind()
set.go#L234: vst := vSect.Type()
set.go#L247: vType := vSect.Type().Elem().Elem()
set.go#L280: isMulti := vVar.Type().Name() == "" && vVar.Kind() == reflect.Slice ||
set.go#L281: vVar.Type().Name() == "" && vVar.Kind() == reflect.Ptr && vVar.Type().Elem().Name() == "" && vVar.Type().Elem().Kind() == reflect.Slice
set.go#L284: vVar.Set(reflect.New(vVar.Type().Elem()))
set.go#L289: vVar.Set(reflect.Zero(vVar.Type()))
set.go#L293: vVal = reflect.New(vVar.Type().Elem()).Elem()
set.go#L297: isDeref := vVal.Type().Name() == "" && vVal.Type().Kind() == reflect.Ptr
set.go#L303: vAddr = reflect.New(vVal.Type().Elem())
github.com/go-git/gcfg/types
scan.go#L11: t := reflect.ValueOf(ptr).Elem().Type()
github.com/go-redis/redis/v8/internal/proto
scan.go#L136: elemType := v.Type().Elem()
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#L145: if !vx.IsValid() || !vy.IsValid() || vx.Type() != vy.Type() {
compare.go#L158: t = vx.Type()
compare.go#L322: v = sanitizeValue(v, f.Type().In(0))
compare.go#L346: x = sanitizeValue(x, f.Type().In(0))
compare.go#L347: y = sanitizeValue(y, f.Type().In(1))
compare.go#L381: if v.Kind() == reflect.Interface && v.IsNil() && v.Type() != t {
compare.go#L588: if vx.Type() != vy.Type() {
compare.go#L592: s.compareAny(TypeAssertion{&typeAssertion{pathStep{vx.Type(), vx, vy}}})
compare.go#L635: tf := t.(*transformer).fnc.Type()
compare.go#L679: vc := reflect.New(v.Type()).Elem()
options.go#L159: if !function.IsType(v.Type(), function.ValueFilter) || v.IsNil() {
options.go#L164: if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
options.go#L277: if !function.IsType(v.Type(), function.Transformer) || v.IsNil() {
options.go#L289: if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
options.go#L319: step := Transform{&transform{pathStep{typ: tr.fnc.Type().Out(0)}, tr}}
options.go#L344: if !function.IsType(v.Type(), function.Equal) || v.IsNil() {
options.go#L348: if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
report_reflect.go#L111: t := v.Type()
github.com/google/go-cmp/cmp/cmpopts
equate.go#L29: return (x != nil && y != nil && vx.Type() == vy.Type()) &&
ignore.go#L157: if !function.IsType(vf.Type(), function.ValuePredicate) || vf.IsNil() {
ignore.go#L165: if !si.Type().AssignableTo(vf.Type().In(0)) {
ignore.go#L185: if !function.IsType(vf.Type(), function.KeyValuePredicate) || vf.IsNil() {
ignore.go#L193: if !mi.Key().Type().AssignableTo(vf.Type().In(0)) || !mi.Type().AssignableTo(vf.Type().In(1)) {
sort.go#L31: if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
sort.go#L34: ss := sliceSorter{vf.Type().In(0), vf}
sort.go#L45: if !(x != nil && y != nil && vx.Type() == vy.Type()) ||
sort.go#L46: !(vx.Kind() == reflect.Slice && vx.Type().Elem().AssignableTo(ss.in)) ||
sort.go#L58: dst := reflect.MakeSlice(src.Type(), src.Len(), src.Len())
sort.go#L102: if !function.IsType(vf.Type(), function.Less) || vf.IsNil() {
sort.go#L105: ms := mapSorter{vf.Type().In(0), vf}
sort.go#L116: return (x != nil && y != nil && vx.Type() == vy.Type()) &&
sort.go#L117: (vx.Kind() == reflect.Map && vx.Type().Key().AssignableTo(ms.in)) &&
sort.go#L123: {Name: "K", Type: src.Type().Key()},
sort.go#L124: {Name: "V", Type: src.Type().Elem()},
github.com/google/go-cmp/cmp/internal/value
pointer_unsafe.go#L25: 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/google/safehtml/internal/safehtmlutil
safehtmlutil.go#L159: for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Ptr && !v.IsNil() {
github.com/google/safehtml/template
escape.go#L813: for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Ptr && !v.IsNil() {
github.com/imdario/mergo
map.go#L40: typ := dst.Type()
map.go#L54: srcType := src.Type()
map.go#L67: v := reflect.New(dst.Type().Elem())
merge.go#L19: field := dst.Type().Field(i)
merge.go#L71: typ := dst.Type()
merge.go#L82: if fn := config.Transformers.Transformer(dst.Type()); fn != nil {
merge.go#L88: if dst.IsValid() && src.IsValid() && src.Type() != dst.Type() {
merge.go#L96: dstCp := reflect.New(dst.Type()).Elem()
merge.go#L99: structField := dst.Type().Field(i)
merge.go#L103: rf = reflect.NewAt(rf.Type(), unsafe.Pointer(rf.UnsafeAddr())).Elem() //nolint:gosec
merge.go#L109: dstRF = reflect.NewAt(dstRF.Type(), unsafe.Pointer(dstRF.UnsafeAddr())).Elem() //nolint:gosec
merge.go#L135: dst.Set(reflect.MakeMap(dst.Type()))
merge.go#L177: if typeCheck && src.Type() != dst.Type() {
merge.go#L178: return dst, fmt.Errorf("cannot override two slices with different type (%s, %s)", src.Type(), dst.Type())
merge.go#L182: if typeCheck && src.Type() != dst.Type() {
merge.go#L183: err = fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type())
merge.go#L198: if dst.Kind() != reflect.Ptr && src.Type().AssignableTo(dst.Type()) {
merge.go#L221: } else if dst.Elem().Type() == src.Type() {
merge.go#L320: if vDst.Type() != vSrc.Type() {
mergo.go#L87: typ := dst.Type()
github.com/jackc/pgtype
aclitem_array.go#L238: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
aclitem_array.go#L270: typ := value.Type()
aclitem_array.go#L276: value.Set(reflect.MakeSlice(value.Type(), length, length))
array_type.go#L107: sliceType := sliceVal.Type()
bool_array.go#L241: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
bool_array.go#L273: typ := value.Type()
bool_array.go#L279: value.Set(reflect.MakeSlice(value.Type(), length, length))
bpchar_array.go#L241: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
bpchar_array.go#L273: typ := value.Type()
bpchar_array.go#L279: value.Set(reflect.MakeSlice(value.Type(), length, length))
bytea_array.go#L213: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
bytea_array.go#L245: typ := value.Type()
bytea_array.go#L251: value.Set(reflect.MakeSlice(value.Type(), length, length))
cidr_array.go#L270: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
cidr_array.go#L302: typ := value.Type()
cidr_array.go#L308: value.Set(reflect.MakeSlice(value.Type(), length, length))
composite_type.go#L193: dstElemType := dstElemValue.Type()
convert.go#L28: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L31: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L34: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L37: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L40: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L43: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L46: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L49: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L52: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L55: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L58: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L61: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L64: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L83: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L101: if refVal.Type().Elem().Kind() == reflect.Uint8 {
convert.go#L103: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L123: return convVal, reflect.TypeOf(convVal) != refVal.Type()
convert.go#L159: if refVal.Type().ConvertibleTo(timeType) {
convert.go#L180: if refVal.Type().ConvertibleTo(uuidType) {
convert.go#L199: baseSliceType := reflect.SliceOf(refVal.Type().Elem())
convert.go#L200: if refVal.Type().ConvertibleTo(baseSliceType) {
convert.go#L202: return convVal.Interface(), reflect.TypeOf(convVal.Interface()) != refVal.Type()
convert.go#L290: el.Set(reflect.New(el.Type().Elem()))
convert.go#L319: el.Set(reflect.Zero(el.Type()))
convert.go#L342: el.Set(reflect.New(el.Type().Elem()))
convert.go#L361: el.Set(reflect.Zero(el.Type()))
convert.go#L381: dstVal.Set(reflect.Zero(dstVal.Type()))
convert.go#L409: dstVal.Set(reflect.New(dstVal.Type().Elem()))
convert.go#L416: return nextDst.Interface(), dstPtr.Type() != nextDst.Type()
convert.go#L420: if baseElemType, ok := kindTypes[dstVal.Type().Elem().Kind()]; ok {
convert.go#L423: return nextDst.Interface(), dstPtr.Type() != nextDst.Type()
convert.go#L428: if baseElemType, ok := kindTypes[dstVal.Type().Elem().Kind()]; ok {
convert.go#L431: return nextDst.Interface(), dstPtr.Type() != nextDst.Type()
date_array.go#L242: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
date_array.go#L274: typ := value.Type()
date_array.go#L280: value.Set(reflect.MakeSlice(value.Type(), length, length))
enum_array.go#L238: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
enum_array.go#L270: typ := value.Type()
enum_array.go#L276: value.Set(reflect.MakeSlice(value.Type(), length, length))
float4_array.go#L241: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
float4_array.go#L273: typ := value.Type()
float4_array.go#L279: value.Set(reflect.MakeSlice(value.Type(), length, length))
float8_array.go#L241: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
float8_array.go#L273: typ := value.Type()
float8_array.go#L279: value.Set(reflect.MakeSlice(value.Type(), length, length))
hstore_array.go#L213: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
hstore_array.go#L245: typ := value.Type()
hstore_array.go#L251: value.Set(reflect.MakeSlice(value.Type(), length, length))
inet_array.go#L270: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
inet_array.go#L302: typ := value.Type()
inet_array.go#L308: value.Set(reflect.MakeSlice(value.Type(), length, length))
int2_array.go#L633: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
int2_array.go#L665: typ := value.Type()
int2_array.go#L671: value.Set(reflect.MakeSlice(value.Type(), length, length))
int4_array.go#L633: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
int4_array.go#L665: typ := value.Type()
int4_array.go#L671: value.Set(reflect.MakeSlice(value.Type(), length, length))
int8_array.go#L633: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
int8_array.go#L665: typ := value.Type()
int8_array.go#L671: value.Set(reflect.MakeSlice(value.Type(), length, length))
jsonb_array.go#L241: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
jsonb_array.go#L273: typ := value.Type()
jsonb_array.go#L279: value.Set(reflect.MakeSlice(value.Type(), length, length))
macaddr_array.go#L242: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
macaddr_array.go#L274: typ := value.Type()
macaddr_array.go#L280: value.Set(reflect.MakeSlice(value.Type(), length, length))
numeric_array.go#L409: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
numeric_array.go#L441: typ := value.Type()
numeric_array.go#L447: value.Set(reflect.MakeSlice(value.Type(), length, length))
pgtype.go#L365: value = reflect.New(reflect.ValueOf(t).Elem().Type()).Interface().(Value)
pgtype.go#L433: ci.reflectTypeToDataType[reflect.ValueOf(dt.Value).Type()] = dt
pgtype.go#L603: if refVal.Kind() == reflect.Ptr && refVal.Type().Elem().Kind() == reflect.Ptr {
pgtype.go#L606: nilPtr := reflect.Zero(refVal.Type().Elem())
pgtype.go#L613: elemPtr := reflect.New(refVal.Type().Elem().Elem())
pgtype.go#L863: return reflect.New(reflect.ValueOf(v).Elem().Type()).Interface().(Value)
record.go#L93: binaryDecoder = reflect.New(reflect.ValueOf(binaryDecoder).Elem().Type()).Interface().(BinaryDecoder)
text_array.go#L241: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
text_array.go#L273: typ := value.Type()
text_array.go#L279: value.Set(reflect.MakeSlice(value.Type(), length, length))
timestamp_array.go#L242: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
timestamp_array.go#L274: typ := value.Type()
timestamp_array.go#L280: value.Set(reflect.MakeSlice(value.Type(), length, length))
timestamptz_array.go#L242: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
timestamptz_array.go#L274: typ := value.Type()
timestamptz_array.go#L280: value.Set(reflect.MakeSlice(value.Type(), length, length))
tsrange_array.go#L194: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
tsrange_array.go#L226: typ := value.Type()
tsrange_array.go#L232: value.Set(reflect.MakeSlice(value.Type(), length, length))
tstzrange_array.go#L194: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
tstzrange_array.go#L226: typ := value.Type()
tstzrange_array.go#L232: value.Set(reflect.MakeSlice(value.Type(), length, length))
uuid_array.go#L297: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
uuid_array.go#L329: typ := value.Type()
uuid_array.go#L335: value.Set(reflect.MakeSlice(value.Type(), length, length))
varchar_array.go#L241: value.Set(reflect.MakeSlice(value.Type(), 0, 0))
varchar_array.go#L273: typ := value.Type()
varchar_array.go#L279: value.Set(reflect.MakeSlice(value.Type(), length, length))
github.com/jackc/pgx/v4
go_stdlib.go#L57: rv.Type().Elem().Implements(valuerReflectType) {
values.go#L244: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L247: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L250: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L253: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L256: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L259: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L262: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L265: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L268: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L271: return convVal, reflect.TypeOf(convVal) != val.Type()
values.go#L274: return convVal, reflect.TypeOf(convVal) != val.Type()
github.com/lann/builder
builder.go#L212: value = reflect.Zero(field.Type())
builder.go#L216: value = listToSlice(v, field.Type())
github.com/lib/pq
array.go#L334: dv.Set(reflect.Zero(dv.Type()))
array.go#L339: return fmt.Errorf("pq: cannot convert %T to %s", src, dv.Type())
array.go#L343: dtype, assign, del := a.evaluateDestination(dv.Type().Elem())
array.go#L361: for i, rt := 0, dv.Type(); i < len(dims); i, rt = i+1, rt.Elem() {
array.go#L367: strings.Replace(fmt.Sprint(dims), " ", "][", -1), dv.Type())
array.go#L581: if t := rv.Type(); t != typeByteSlice && !t.Implements(typeDriverValuer) {
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()
golang.org/x/crypto/ssh
messages.go#L376: structType := v.Type()
messages.go#L405: t := field.Type()
messages.go#L504: msgTypes := typeTags(v.Type())
messages.go#L511: switch t := field.Type(); t.Kind() {
messages.go#L538: if v.Type().Field(i).Tag.Get("ssh") != "rest" {
golang.org/x/pkgsite/internal/database
reflect.go#L45: return structScannerForType(v.Type())
reflect.go#L107: ntype := n.ptr.Elem().Type() // T
reflect.go#L141: et := ve.Type().Elem() // slice element type
reflect.go#L147: return fmt.Errorf("slice element type is neither struct nor struct pointer: %s", ve.Type().Elem())
golang.org/x/pkgsite/internal/godoc/dochtml
template.go#L48: vz := reflect.New(v.Type()).Elem()
golang.org/x/pkgsite/internal/postgres
details.go#L174: vptr.Elem().Set(reflect.Zero(vptr.Elem().Type()))
details.go#L182: v := reflect.New(vptr.Elem().Type())
golang.org/x/xerrors
wrap.go#L85: typ := val.Type()
google.golang.org/api/internal/gensupport
json.go#L54: st := s.Type()
google.golang.org/api/iterator
iterator.go#L207: wantSliceType := reflect.PtrTo(reflect.ValueOf(p.pageInfo.takeBuf()).Type())
iterator.go#L212: if vslicep.Type() != wantSliceType {
google.golang.org/protobuf/internal/descfmt
stringer.go#L44: name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
stringer.go#L122: rt := rv.MethodByName("ProtoType").Type().In(0)
stringer.go#L215: panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a))
google.golang.org/protobuf/internal/impl
codec_field.go#L57: if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
codec_field.go#L79: return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]
codec_field.go#L103: 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#L440: if rv.Type() != c.goType {
convert.go#L441: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
convert.go#L454: return rv.Type() == c.goType
convert.go#L458: 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#L38: et := legacyLoadEnumType(v.Type())
legacy_message.go#L27: typ := v.Type()
legacy_message.go#L451: return LegacyLoadMessageDesc(m.v.Type())
legacy_message.go#L454: return aberrantMessageType{m.v.Type()}
legacy_message.go#L457: return aberrantMessage{reflect.Zero(m.v.Type())}
message_reflect_field.go#L58: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L65: if rv.IsNil() || rv.Elem().Type().Elem() != ot {
message_reflect_field.go#L70: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L77: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L85: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L96: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L134: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L187: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L260: panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
message_reflect_field.go#L265: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L395: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L462: return si.oneofWrappersByType[rv.Type().Elem()]
gopkg.in/yaml.v2
decode.go#L265: d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.line+1, shortTag(tag), value, out.Type()))
decode.go#L306: out.Set(reflect.New(out.Type().Elem()))
decode.go#L431: out.Set(reflect.Zero(out.Type()))
decode.go#L435: if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
decode.go#L473: out.Set(reflect.Zero(out.Type()))
decode.go#L508: if out.Type() == durationType {
decode.go#L561: if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
decode.go#L566: if out.Type().Elem() == reflect.TypeOf(resolved) {
decode.go#L568: elem := reflect.New(out.Type().Elem())
decode.go#L580: sv := reflect.New(v.Type()).Elem()
decode.go#L591: out.Set(reflect.MakeSlice(out.Type(), l, l))
decode.go#L604: et := out.Type().Elem()
decode.go#L648: outt := out.Type()
decode.go#L694: outt := out.Type()
decode.go#L725: sinfo, err := getStructInfo(out.Type())
decode.go#L736: inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
decode.go#L737: elemType = inlineMap.Type().Elem()
decode.go#L756: d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.line+1, name.String(), out.Type()))
decode.go#L770: inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
decode.go#L776: d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.line+1, name.String(), out.Type()))
encode.go#L151: if in.Type() == ptrTimeType {
encode.go#L157: if in.Type() == timeType {
encode.go#L163: if in.Type().Elem() == mapItemType {
encode.go#L171: if in.Type() == durationType {
encode.go#L183: panic("cannot marshal type: " + in.Type().String())
encode.go#L209: sinfo, err := getStructInfo(in.Type())
yaml.go#L454: vt := v.Type()
html/template
content.go#L143: for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Ptr && !v.IsNil() {
js.go#L135: for !v.Type().Implements(jsonMarshalType) && v.Kind() == reflect.Ptr && !v.IsNil() {
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#L372: 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()
text/template
exec.go#L376: if val.Type().ChanDir() == reflect.SendDir {
exec.go#L438: if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
exec.go#L593: typ := receiver.Type()
exec.go#L615: tField, ok := receiver.Type().FieldByName(fieldName)
exec.go#L630: if nameVal.Type().AssignableTo(receiver.Type().Key()) {
exec.go#L640: result = reflect.Zero(receiver.Type().Elem())
exec.go#L648: etyp := receiver.Type().Elem()
exec.go#L677: typ := fun.Type()
exec.go#L732: if v.Type() == reflectValueType {
exec.go#L762: if typ == reflectValueType && value.Type() != typ {
exec.go#L765: if typ != nil && !value.Type().AssignableTo(typ) {
exec.go#L768: if value.Type().AssignableTo(typ) {
exec.go#L778: case value.Kind() == reflect.Ptr && value.Type().Elem().AssignableTo(typ):
exec.go#L783: case reflect.PtrTo(value.Type()).AssignableTo(typ) && value.CanAddr():
exec.go#L786: s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
exec.go#L963: s.errorf("can't print %s of type %s", n, v.Type())
exec.go#L981: if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
exec.go#L982: if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) {
funcs.go#L94: if !goodFunc(v.Type()) {
funcs.go#L95: panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut()))
funcs.go#L162: if value.Type().AssignableTo(argType) {
funcs.go#L165: if intLike(value.Kind()) && intLike(argType.Kind()) && value.Type().ConvertibleTo(argType) {
funcs.go#L169: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L193: return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
funcs.go#L225: index, err := prepareArg(index, item.Type().Key())
funcs.go#L232: item = reflect.Zero(item.Type().Elem())
funcs.go#L238: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L268: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L305: return 0, fmt.Errorf("len of type %s", item.Type())
funcs.go#L317: typ := fn.Type()
funcs.go#L458: if t1 := arg1.Type(); !t1.Comparable() {
funcs.go#L498: if t2 := arg.Type(); !t2.Comparable() {
 |
The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |