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() {