reflect.Value.Type (method)
321 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#L235: if v1.Type() != v2.Type() {
iter.go#L41: rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
iter.go#L49: return rangeNum[int](v.Int(), v.Type())
iter.go#L51: return rangeNum[int8](v.Int(), v.Type())
iter.go#L53: return rangeNum[int16](v.Int(), v.Type())
iter.go#L55: return rangeNum[int32](v.Int(), v.Type())
iter.go#L57: return rangeNum[int64](v.Int(), v.Type())
iter.go#L59: return rangeNum[uint](v.Uint(), v.Type())
iter.go#L61: return rangeNum[uint8](v.Uint(), v.Type())
iter.go#L63: return rangeNum[uint16](v.Uint(), v.Type())
iter.go#L65: return rangeNum[uint32](v.Uint(), v.Type())
iter.go#L67: return rangeNum[uint64](v.Uint(), v.Type())
iter.go#L69: return rangeNum[uintptr](v.Uint(), v.Type())
iter.go#L116: panic("reflect: " + v.Type().String() + " cannot produce iter.Seq[Value]")
iter.go#L127: rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
iter.go#L172: panic("reflect: " + v.Type().String() + " cannot produce iter.Seq2[Value, Value]")
makefunc.go#L107: ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
swapper.go#L35: typ := v.Type().Elem().common()
value.go#L439: if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(toRType(targ)) {
value.go#L450: if xt := x.Type(); !xt.AssignableTo(elem) {
value.go#L1633: if !v.Field(i).IsZero() && v.Type().Field(i).Name != "_" {
value.go#L2354: return "<" + v.Type().String() + " Value>"
value.go#L2379: func (v Value) Type() Type {
value.go#L2661: typesMustMatch("reflect.AppendSlice", s.Type().Elem(), t.Type().Elem())
value.go#L3092: vt := v.Type()
value.go#L3123: switch v.Type().Elem().Kind() {
value.go#L3125: for i := 0; i < v.Type().Len(); i++ {
value.go#L3132: return v.Type().Comparable()
value.go#L3146: return v.Type().Comparable()
value.go#L3170: if v.Kind() != u.Kind() || v.Type() != u.Type() {
value.go#L3198: if !v.Type().Elem().Comparable() {
value.go#L3221: panic("reflect.Value.Equal: values of type " + v.Type().String() + " are not comparable")
value.go#L3434: if v.Type().Kind() == Float32 && t.Kind() == Float32 {
encoding/asn1
asn1.go#L672: fieldType := v.Type()
asn1.go#L895: if val.Type().Size() == 4 {
asn1.go#L984: err = StructuralError{"unsupported: " + v.Type().String()}
marshal.go#L459: switch value.Type() {
marshal.go#L485: t := v.Type()
marshal.go#L533: sliceType := v.Type()
marshal.go#L581: if v.Kind() == reflect.Interface && v.Type().NumMethod() == 0 {
marshal.go#L590: defaultValue := reflect.New(v.Type()).Elem()
marshal.go#L602: if reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface()) {
marshal.go#L607: if v.Type() == rawValueType {
marshal.go#L621: matchAny, tag, isCompound, ok := getUniversalType(v.Type())
marshal.go#L623: return nil, StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}
encoding/binary
binary.go#L701: t := v.Type().Elem()
binary.go#L715: t := v.Type()
binary.go#L725: return sizeof(v.Type())
binary.go#L854: t := v.Type()
binary.go#L923: t := v.Type()
encoding/json
decode.go#L445: if v.Kind() != reflect.Pointer && v.Type().Name() != "" && v.CanAddr() {
decode.go#L477: v.Set(reflect.New(v.Type().Elem()))
decode.go#L479: if v.Type().NumMethod() > 0 && v.CanInterface() {
decode.go#L511: d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
decode.go#L529: d.saveError(&UnmarshalTypeError{Value: "array", Type: v.Type(), Offset: int64(d.off)})
decode.go#L589: v.Set(reflect.MakeSlice(v.Type(), 0, 0))
decode.go#L608: d.saveError(&UnmarshalTypeError{Value: "object", Type: v.Type(), Offset: int64(d.off)})
decode.go#L613: t := v.Type()
decode.go#L713: d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
decode.go#L720: subv.Set(reflect.New(subv.Type().Elem()))
decode.go#L727: subv.Type().Field(ind).Name,
decode.go#L759: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
decode.go#L855: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L866: 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(&UnmarshalTypeError{Value: val, Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L882: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L896: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L909: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L915: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L917: d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L925: d.saveError(&UnmarshalTypeError{Value: "bool", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L933: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L939: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L941: if v.Type().Elem().Kind() != reflect.Uint8 {
decode.go#L942: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L954: if v.Type() == numberType && !isValidNumber(t) {
decode.go#L962: d.saveError(&UnmarshalTypeError{Value: "string", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L969: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L975: if v.Kind() == reflect.String && v.Type() == numberType {
decode.go#L982: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L984: d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L992: d.saveError(&UnmarshalTypeError{Value: "number", Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1000: d.saveError(&UnmarshalTypeError{Value: "number " + string(item), Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1008: d.saveError(&UnmarshalTypeError{Value: "number " + string(item), Type: v.Type(), Offset: int64(d.readIndex())})
decode.go#L1014: n, err := strconv.ParseFloat(string(item), v.Type().Bits())
decode.go#L1016: d.saveError(&UnmarshalTypeError{Value: "number " + string(item), Type: v.Type(), Offset: int64(d.readIndex())})
encode.go#L351: return typeEncoder(v.Type())
encode.go#L460: e.error(&MarshalerError{v.Type(), err, "MarshalJSON"})
encode.go#L479: e.error(&MarshalerError{v.Type(), err, "MarshalJSON"})
encode.go#L495: e.error(&MarshalerError{v.Type(), err, "MarshalText"})
encode.go#L509: e.error(&MarshalerError{v.Type(), err, "MarshalText"})
encode.go#L580: if v.Type() == numberType {
encode.go#L684: e.error(&UnsupportedTypeError{v.Type()})
encode.go#L755: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L770: e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
encode.go#L838: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L894: e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
encode.go#L1212: v2 := reflect.New(v.Type()).Elem()
flag
flag.go#L310: if defVal.Type() != ptrVal.Type().Elem() {
flag.go#L311: panic(fmt.Sprintf("default type does not match variable type: %v != %v", defVal.Type(), ptrVal.Type().Elem()))
fmt
print.go#L377: p.buf.writeString(v.Type().String())
print.go#L392: p.buf.writeString(p.value.Type().String())
print.go#L563: p.buf.writeString(value.Type().String())
print.go#L807: p.buf.writeString(f.Type().String())
print.go#L836: p.buf.writeString(f.Type().String())
print.go#L848: if name := f.Type().Field(i).Name; name != "" {
print.go#L860: p.buf.writeString(f.Type().String())
print.go#L872: t := f.Type()
print.go#L891: 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/google/go-cmp/cmp
compare.go#L148: if !vx.IsValid() || !vy.IsValid() || vx.Type() != vy.Type() {
compare.go#L161: t = vx.Type()
compare.go#L575: if vx.Type() != vy.Type() {
compare.go#L579: s.compareAny(TypeAssertion{&typeAssertion{pathStep{vx.Type(), vx, vy}}})
compare.go#L622: tf := t.(*transformer).fnc.Type()
compare.go#L668: 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#L290: if !function.IsType(v.Type(), function.Transformer) || v.IsNil() {
options.go#L302: if ti := v.Type().In(0); ti.Kind() != reflect.Interface || ti.NumMethod() > 0 {
options.go#L332: step := Transform{&transform{pathStep{typ: tr.fnc.Type().Out(0)}, tr}}
options.go#L357: if !function.IsType(v.Type(), function.Equal) || v.IsNil() {
options.go#L361: 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.go#L23: 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()))
go.uber.org/mock/gomock
call.go#L120: ft := v.Type()
call.go#L161: ft := v.Type()
controller.go#L172: for i := 0; i < recv.Type().NumMethod(); i++ {
controller.go#L173: if recv.Type().Method(i).Name == method {
controller.go#L174: return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...)
matchers.go#L131: if x1Val.Type().AssignableTo(x2Val.Type()) {
matchers.go#L132: x1ValConverted := x1Val.Convert(x2Val.Type())
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#L122: rt := rv.MethodByName("ProtoType").Type().In(0)
stringer.go#L313: panic(fmt.Sprintf("unknown accessor: %v.%s", v.Type(), a.name))
google.golang.org/protobuf/internal/impl
codec_field.go#L56: 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#L151: if v.Type() != c.goType {
convert.go#L152: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L164: return v.IsValid() && v.Type() == c.goType
convert.go#L175: if v.Type() != c.goType {
convert.go#L176: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L188: return v.IsValid() && v.Type() == c.goType
convert.go#L199: if v.Type() != c.goType {
convert.go#L200: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L212: return v.IsValid() && v.Type() == c.goType
convert.go#L223: if v.Type() != c.goType {
convert.go#L224: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L236: return v.IsValid() && v.Type() == c.goType
convert.go#L247: if v.Type() != c.goType {
convert.go#L248: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L260: return v.IsValid() && v.Type() == c.goType
convert.go#L271: if v.Type() != c.goType {
convert.go#L272: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L284: return v.IsValid() && v.Type() == c.goType
convert.go#L295: if v.Type() != c.goType {
convert.go#L296: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L308: return v.IsValid() && v.Type() == c.goType
convert.go#L319: if v.Type() != c.goType {
convert.go#L320: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L338: return v.IsValid() && v.Type() == c.goType
convert.go#L349: if v.Type() != c.goType {
convert.go#L350: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L365: return v.IsValid() && v.Type() == c.goType
convert.go#L386: if v.Type() != c.goType {
convert.go#L387: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L402: return v.IsValid() && v.Type() == c.goType
convert.go#L422: if v.Type() != c.goType {
convert.go#L423: panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
convert.go#L429: v = reflect.Zero(reflect.PtrTo(v.Type()))
convert.go#L447: if rv.Type() != reflect.PtrTo(c.goType) {
convert.go#L448: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), reflect.PtrTo(c.goType)))
convert.go#L453: rv = reflect.Zero(rv.Type().Elem())
convert.go#L456: if rv.Type() != c.goType {
convert.go#L457: panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), c.goType))
convert.go#L471: return rv.Type() == reflect.PtrTo(c.goType)
convert.go#L473: return rv.Type() == c.goType
convert.go#L477: 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#L502: m.v.Elem().Set(reflect.Zero(m.v.Type().Elem()))
legacy_message.go#L511: return LegacyLoadMessageDesc(m.v.Type())
legacy_message.go#L514: return aberrantMessageType{m.v.Type()}
legacy_message.go#L517: if m.v.Type().Kind() == reflect.Ptr {
legacy_message.go#L518: return aberrantMessage{reflect.New(m.v.Type().Elem())}
legacy_message.go#L520: return aberrantMessage{reflect.Zero(m.v.Type())}
message_opaque.go#L157: rv.Set(reflect.Zero(rv.Type()))
message_opaque.go#L209: rv.Set(reflect.Zero(rv.Type()))
message_opaque.go#L275: rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
message_opaque.go#L357: rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
message_opaque.go#L441: panic(fmt.Sprintf("invalid type: %v", rv.Type())) // should never happen
message_opaque.go#L450: rv.Set(reflect.Zero(rv.Type()))
message_reflect.go#L418: rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
message_reflect_field.go#L88: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L95: if rv.IsNil() || rv.Elem().Type().Elem() != ot {
message_reflect_field.go#L100: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L107: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L115: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L126: if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
message_reflect_field.go#L164: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L217: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L300: panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen
message_reflect_field.go#L305: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L352: rv.Set(reflect.Zero(rv.Type()))
message_reflect_field.go#L419: 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#L142: for !v.Type().Implements(jsonMarshalType) && v.Kind() == reflect.Pointer && !v.IsNil() {
internal/buildcfg
exp.go#L99: rt := rv.Type()
exp.go#L171: rt := rv.Type()
internal/fmtsort
sort.go#L50: if mapValue.Type().Kind() != reflect.Map {
sort.go#L73: aType, bType := aVal.Type(), bVal.Type()
sort.go#L127: c := compare(reflect.ValueOf(aVal.Elem().Type()), reflect.ValueOf(bVal.Elem().Type()))
net/http
h2_error.go#L15: dstType := dst.Type()
h2_error.go#L20: srcType := src.Type()
h2_error.go#L34: df.Set(src.Field(i).Convert(df.Type()))
transport.go#L406: 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#L100: return v.IsValid() && v.Type() == missingValReflectType
exec.go#L435: if val.Type().ChanDir() == reflect.SendDir {
exec.go#L454: if val.Type().CanSeq() {
exec.go#L471: if val.Type().CanSeq2() {
exec.go#L534: if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
exec.go#L689: typ := receiver.Type()
exec.go#L711: tField, ok := receiver.Type().FieldByName(fieldName)
exec.go#L729: if nameVal.Type().AssignableTo(receiver.Type().Key()) {
exec.go#L739: result = reflect.Zero(receiver.Type().Elem())
exec.go#L747: etyp := receiver.Type().Elem()
exec.go#L776: typ := fun.Type()
exec.go#L795: if v.Type() == reflectValueType {
exec.go#L904: if typ == reflectValueType && value.Type() != typ {
exec.go#L907: if typ != nil && !value.Type().AssignableTo(typ) {
exec.go#L910: if value.Type().AssignableTo(typ) {
exec.go#L920: case value.Kind() == reflect.Pointer && value.Type().Elem().AssignableTo(typ):
exec.go#L925: case reflect.PointerTo(value.Type()).AssignableTo(typ) && value.CanAddr():
exec.go#L928: s.errorf("wrong type for value; expected %s; got %s", typ, value.Type())
exec.go#L1105: s.errorf("can't print %s of type %s", n, v.Type())
exec.go#L1123: if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
exec.go#L1124: if v.CanAddr() && (reflect.PointerTo(v.Type()).Implements(errorType) || reflect.PointerTo(v.Type()).Implements(fmtStringerType)) {
funcs.go#L96: if err := goodFunc(name, v.Type()); err != nil {
funcs.go#L167: if value.Type().AssignableTo(argType) {
funcs.go#L170: if intLike(value.Kind()) && intLike(argType.Kind()) && value.Type().ConvertibleTo(argType) {
funcs.go#L174: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L198: return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
funcs.go#L230: index, err := prepareArg(index, item.Type().Key())
funcs.go#L237: item = reflect.Zero(item.Type().Elem())
funcs.go#L243: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L273: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L310: return 0, fmt.Errorf("len of type %s", item.Type())
funcs.go#L326: typ := fn.Type()
funcs.go#L509: return false, fmt.Errorf("non-comparable types %s: %v, %s: %v", arg1, arg1.Type(), arg.Type(), arg)
funcs.go#L514: if !arg.Type().Comparable() {
funcs.go#L515: return false, fmt.Errorf("non-comparable type %s: %v", arg, arg.Type())