reflect.StructField.Type (field)

107 uses

	reflect (current package)
		type.go#L1098: 	Type      Type      // field type
		type.go#L1191: 	f.Type = toType(p.typ)
		type.go#L1218: 	f.Type = toType(&t.rtype)
		type.go#L1221: 			ft := f.Type
		type.go#L1225: 			f.Type = ft
		type.go#L1227: 		f = f.Type.Field(x)
		type.go#L2393: 		if field.Type == nil {
		type.go#L2606: 			{Name: "S", Type: TypeOf(structType{})},
		type.go#L2607: 			{Name: "U", Type: TypeOf(uncommonType{})},
		type.go#L2608: 			{Name: "M", Type: ArrayOf(len(methods), TypeOf(methods[0]))},
		type.go#L2789: 	resolveReflectType(field.Type.common()) // install in runtime
		type.go#L2792: 		typ:         field.Type.common(),

	encoding/asn1
		asn1.go#L924: 			structType.Field(0).Type == rawContentsType {
		asn1.go#L932: 			if i == 0 && field.Type == rawContentsType {
		marshal.go#L505: 		if t.Field(0).Type == rawContentsType {

	encoding/binary
		binary.go#L438: 			s := sizeof(t.Field(i).Type)

	encoding/gob
		decode.go#L1125: 		if !dec.compatibleType(localField.Type, wireField.Id, make(map[reflect.Type]typeId)) {
		decode.go#L1126: 			errorf("wrong type (%s) for received field %s.%s", localField.Type, wireStruct.Name, wireField.Name)
		decode.go#L1128: 		op := dec.decOpFor(wireField.Id, localField.Type, localField.Name, seen)
		encode.go#L642: 			op, indir := encOpFor(f.Type, seen, building)
		encoder.go#L122: 				enc.sendType(w, state, st.Field(i).Type)
		type.go#L530: 			typ := userType(f.Type).base
		type.go#L533: 				t := userType(f.Type).base
		type.go#L536: 			gt, err := getBaseType(tname, f.Type)
		type.go#L571: 	typ := field.Type

	encoding/json
		encode.go#L994: 		t = t.Field(i).Type
		encode.go#L1244: 					t := sf.Type
		encode.go#L1270: 				ft := sf.Type

	encoding/xml
		typeinfo.go#L69: 				t := f.Type
		typeinfo.go#L190: 		if xmlname := lookupXMLName(f.Type); xmlname != nil {
		typeinfo.go#L218: 		ftyp := f.Type

	github.com/ghodss/yaml
		fields.go#L173: 				ft := sf.Type

	github.com/golang/protobuf/proto
		properties.go#L240: 		p.Init(f.Type, f.Name, tagField, &f)
		properties.go#L289: 				if p.Type.AssignableTo(t.Field(i).Type) {

	github.com/google/go-cmp/cmp
		compare.go#L395: 		step.typ = t.Field(i).Type
		export_unsafe.go#L23: 	ve := reflect.NewAt(f.Type, unsafe.Pointer(uintptr(unsafe.Pointer(v.UnsafeAddr()))+f.Offset)).Elem()
		export_unsafe.go#L30: 			return reflect.Zero(f.Type)
		export_unsafe.go#L32: 		return reflect.ValueOf(ve.Interface()).Convert(f.Type)

	github.com/google/go-cmp/cmp/cmpopts
		ignore.go#L83: 		case fi.Type.Kind() != reflect.Interface:
		ignore.go#L85: 		case fi.Type.NumMethod() == 0:
		ignore.go#L89: 			tf = append(tf, fi.Type)
		sort.go#L123: 		{Name: "K", Type: src.Type().Key()},
		sort.go#L124: 		{Name: "V", Type: src.Type().Elem()},
		struct_filter.go#L185: 	ssPost, err := canonicalName(sf.Type, sel)

	github.com/google/go-cmp/cmp/internal/value
		name.go#L104: 			b = appendTypeName(b, sf.Type, qualified, false)

	github.com/lann/builder
		builder.go#L128: 					arrayType = field.Type
		builder.go#L157: 					arrayType = field.Type

	golang.org/x/pkgsite/internal/database
		reflect.go#L63: 			fieldInfos = append(fieldInfos, fieldInfo{i, t.Field(i).Type.Kind()})

	golang.org/x/pkgsite/internal/godoc/codec
		generate.go#L282: 		if f.Type.Kind() == reflect.Chan || f.Type.Kind() == reflect.Func {
		generate.go#L297: 				Type: f.Type,
		generate.go#L298: 				Zero: zeroValue(f.Type),

	google.golang.org/api/internal/gensupport
		json.go#L85: 		if f.Type.Kind() == reflect.Map && useNullMaps[f.Name] != nil {
		json.go#L102: 		if f.Type.Kind() == reflect.Map && v.IsNil() {
		json.go#L108: 		if f.Type.Kind() == reflect.Slice && v.IsNil() {
		json.go#L114: 			m[tag.apiName] = formatAsString(v, f.Type.Kind())
		json.go#L176: 	if f.Type.Kind() == reflect.Ptr && v.IsNil() {
		json.go#L183: 	if f.Type.Kind() == reflect.Interface && v.IsNil() {

	google.golang.org/protobuf/internal/impl
		codec_field.go#L33: 	ft := fs.Type
		codec_field.go#L48: 		cf.ft = ot.Field(0).Type
		codec_message.go#L65: 		ft := fs.Type
		legacy_message.go#L184: 			switch f.Type.Kind() {
		legacy_message.go#L229: 			aberrantAppendField(md, f.Type, tag, tagKey, tagVal)
		legacy_message.go#L241: 				if t.Implements(f.Type) {
		legacy_message.go#L244: 						aberrantAppendField(md, f.Type, tag, "", "")
		message.go#L152: 			if f.Type == sizecacheType {
		message.go#L156: 			if f.Type == weakFieldsType {
		message.go#L160: 			if f.Type == unknownFieldsType {
		message.go#L164: 			if f.Type == extensionFieldsType {
		message_reflect_field.go#L32: 	ft := fs.Type
		message_reflect_field.go#L42: 	conv := NewConverter(ot.Field(0).Type, fd)
		message_reflect_field.go#L57: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L64: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L76: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L84: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L95: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L115: 	ft := fs.Type
		message_reflect_field.go#L129: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L133: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L140: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L147: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L155: 			v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L157: 				v.Set(reflect.MakeMap(fs.Type))
		message_reflect_field.go#L168: 	ft := fs.Type
		message_reflect_field.go#L182: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L186: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L193: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type)
		message_reflect_field.go#L200: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L208: 			v := p.Apply(fieldOffset).AsValueOf(fs.Type)
		message_reflect_field.go#L223: 	ft := fs.Type
		message_reflect_field.go#L244: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L264: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L271: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L283: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L379: 	ft := fs.Type
		message_reflect_field.go#L390: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L394: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L401: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L405: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L412: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L441: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L454: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		validate.go#L117: 				vi.mi = getMessageInfo(ot.Field(0).Type)
		validate.go#L122: 				vi.mi = getMessageInfo(ot.Field(0).Type)

	gopkg.in/yaml.v2
		yaml.go#L357: 			switch field.Type.Kind() {
		yaml.go#L362: 				if field.Type.Key() != reflect.TypeOf("") {
		yaml.go#L367: 				sinfo, err := getStructInfo(field.Type)