reflect.Value.Kind (method)

445 uses

	reflect (current package)
		deepequal.go#L37: 		switch v1.Kind() {
		deepequal.go#L61: 			switch v.Kind() {
		deepequal.go#L87: 	switch v1.Kind() {
		swapper.go#L18: 	if v.Kind() != Slice {
		swapper.go#L19: 		panic(&ValueError{Method: "Swapper", Kind: v.Kind()})
		value.go#L400: 		if x.Kind() == Invalid {
		value.go#L887: 			if v.Kind() == Ptr && v.typ.Elem().Kind() == Struct {
		value.go#L1134: 		panic(&ValueError{"reflect.Value.IsZero", v.Kind()})
		value.go#L1140: func (v Value) Kind() Kind {
		value.go#L2343: 	if v.Kind() != Ptr {
		value.go#L2435: 		if v.Kind() == Interface && v.IsNil() {

	database/sql
		convert.go#L353: 		switch sv.Kind() {
		convert.go#L389: 	if dpv.Kind() != reflect.Ptr {
		convert.go#L411: 	if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
		convert.go#L421: 	switch dv.Kind() {
		convert.go#L431: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L437: 			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
		convert.go#L443: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L449: 			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
		convert.go#L455: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L461: 			return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
		convert.go#L467: 			return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
		convert.go#L506: 	switch rv.Kind() {
		convert.go#L522: 	switch rv.Kind() {
		convert.go#L554: 	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&

	database/sql/driver
		types.go#L82: 	switch sv.Kind() {
		types.go#L110: 	switch rv.Kind() {
		types.go#L228: 	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&
		types.go#L258: 	switch rv.Kind() {
		types.go#L289: 	return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())

	encoding/asn1
		asn1.go#L889: 	switch val := v; val.Kind() {
		asn1.go#L1013: 	if canHaveDefaultValue(v.Kind()) {
		asn1.go#L1114: 	if v.Kind() != reflect.Ptr || v.IsNil() {
		marshal.go#L479: 	switch v := value; v.Kind() {
		marshal.go#L584: 	if v.Kind() == reflect.Interface && v.Type().NumMethod() == 0 {
		marshal.go#L588: 	if v.Kind() == reflect.Slice && v.Len() == 0 && params.omitEmpty {
		marshal.go#L592: 	if params.optional && params.defaultValue != nil && canHaveDefaultValue(v.Kind()) {

	encoding/binary
		binary.go#L245: 	switch v.Kind() {
		binary.go#L406: 	switch v.Kind() {
		binary.go#L541: 	switch v.Kind() {
		binary.go#L610: 	switch v.Kind() {

	encoding/gob
		decode.go#L231: 	for v.Kind() == reflect.Ptr {
		decode.go#L467: 			if field.Kind() == reflect.Ptr {
		decode.go#L957: 		if value.Kind() != reflect.Ptr && rcvrType.Kind() == reflect.Ptr {
		decoder.go#L199: 		if v.Kind() == reflect.Ptr && !v.IsNil() {
		encode.go#L279: 	switch v.Kind() {
		encode.go#L389: 	if elem.Kind() == reflect.Ptr && elem.IsNil() {
		encode.go#L435: 	switch val.Kind() {
		encoder.go#L219: 	if value.Kind() == reflect.Invalid {
		encoder.go#L222: 	if value.Kind() == reflect.Ptr && value.IsNil() {

	encoding/json
		decode.go#L172: 	if rv.Kind() != reflect.Ptr || rv.IsNil() {
		decode.go#L440: 	if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
		decode.go#L447: 		if v.Kind() == reflect.Interface && !v.IsNil() {
		decode.go#L449: 			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
		decode.go#L456: 		if v.Kind() != reflect.Ptr {
		decode.go#L467: 		if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v {
		decode.go#L513: 	switch v.Kind() {
		decode.go#L540: 		if v.Kind() == reflect.Slice {
		decode.go#L582: 		if v.Kind() == reflect.Array {
		decode.go#L592: 	if i == 0 && v.Kind() == reflect.Slice {
		decode.go#L620: 	if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
		decode.go#L632: 	switch v.Kind() {
		decode.go#L686: 		if v.Kind() == reflect.Map {
		decode.go#L714: 					if subv.Kind() == reflect.Ptr {
		decode.go#L772: 		if v.Kind() == reflect.Map {
		decode.go#L898: 		switch v.Kind() {
		decode.go#L911: 		switch v.Kind() {
		decode.go#L936: 		switch v.Kind() {
		decode.go#L972: 		switch v.Kind() {
		decode.go#L974: 			if v.Kind() == reflect.String && v.Type() == numberType {
		encode.go#L342: 	switch v.Kind() {
		encode.go#L470: 	if v.Kind() == reflect.Ptr && v.IsNil() {
		encode.go#L507: 	if v.Kind() == reflect.Ptr && v.IsNil() {
		encode.go#L741: 			if fv.Kind() == reflect.Ptr {
		encode.go#L1005: 	if w.v.Kind() == reflect.String {
		encode.go#L1010: 		if w.v.Kind() == reflect.Ptr && w.v.IsNil() {
		encode.go#L1017: 	switch w.v.Kind() {

	encoding/xml
		marshal.go#L423: 	for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
		marshal.go#L430: 	kind := val.Kind()
		marshal.go#L515: 		if fv.Kind() == reflect.Interface && fv.IsNil() {
		marshal.go#L529: 	if val.Kind() == reflect.Struct {
		marshal.go#L601: 	switch val.Kind() {
		marshal.go#L610: 	if val.Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
		marshal.go#L755: 	switch val.Kind() {
		marshal.go#L796: 	for vf.Kind() == reflect.Interface || vf.Kind() == reflect.Ptr {
		marshal.go#L854: 			switch vf.Kind() {
		marshal.go#L889: 			k := vf.Kind()
		marshal.go#L945: 				if vf.Kind() != reflect.Ptr && vf.Kind() != reflect.Interface || !vf.IsNil() {
		marshal.go#L1043: 	switch v.Kind() {
		read.go#L148: 	if val.Kind() != reflect.Ptr {
		read.go#L247: 	if val.Kind() == reflect.Ptr {
		read.go#L325: 	if val.Kind() == reflect.Interface && !val.IsNil() {
		read.go#L327: 		if e.Kind() == reflect.Ptr && !e.IsNil() {
		read.go#L332: 	if val.Kind() == reflect.Ptr {
		read.go#L377: 	switch v := val; v.Kind() {
		read.go#L583: 	switch t := saveComment; t.Kind() {
		read.go#L590: 	switch t := saveXML; t.Kind() {
		read.go#L605: 	if dst.Kind() == reflect.Ptr {
		read.go#L613: 	switch dst.Kind() {

	fmt
		print.go#L292: 	if val.Kind() == reflect.Interface && !val.IsNil() {
		print.go#L500: 	switch value.Kind() {
		print.go#L541: 		if v := reflect.ValueOf(arg); v.Kind() == reflect.Ptr && v.IsNil() {
		print.go#L730: 	switch f := value; value.Kind() {
		print.go#L828: 				if f.Kind() == reflect.Slice {
		print.go#L847: 			if f.Kind() == reflect.Slice && f.IsNil() {
		print.go#L873: 			switch a := f.Elem(); a.Kind() {
		print.go#L895: 			switch v := reflect.ValueOf(a[argNum]); v.Kind() {
		scan.go#L1020: 		if ptr.Kind() != reflect.Ptr {
		scan.go#L1024: 		switch v := ptr.Elem(); v.Kind() {

	github.com/aws/aws-sdk-go/aws/awsutil
		copy.go#L42: 	switch src.Kind() {
		copy.go#L45: 			if dst.Kind() == reflect.Ptr && dst.Elem().CanSet() {
		path_value.go#L57: 			if value.Kind() != reflect.Struct {
		path_value.go#L79: 			if nilTerm && value.Kind() == reflect.Ptr && len(components[1:]) == 0 {
		path_value.go#L86: 			if createPath && value.Kind() == reflect.Ptr && value.IsNil() {
		path_value.go#L95: 			if value.Kind() == reflect.Slice || value.Kind() == reflect.Map {
		path_value.go#L111: 				if value.Kind() != reflect.Slice {
		path_value.go#L138: 				if value.Kind() == reflect.Slice || value.Kind() == reflect.Map {
		path_value.go#L165: 	if !v.IsValid() || (v.Kind() == reflect.Ptr && v.IsNil()) {
		path_value.go#L171: 	if v.Kind() == reflect.Map && v.Len() == 0 {
		path_value.go#L174: 	if v.Kind() == reflect.Slice {
		path_value.go#L190: 		if rval.Kind() == reflect.Ptr && rval.IsNil() {
		path_value.go#L198: 	if dstVal.Kind() == reflect.Ptr {
		path_value.go#L210: 	} else if srcVal.Kind() == reflect.Ptr {
		prettify.go#L21: 	for v.Kind() == reflect.Ptr {
		prettify.go#L25: 	switch v.Kind() {
		prettify.go#L45: 			if (f.Kind() == reflect.Ptr || f.Kind() == reflect.Slice || f.Kind() == reflect.Map) && f.IsNil() {
		string_value.go#L18: 	for v.Kind() == reflect.Ptr {
		string_value.go#L22: 	switch v.Kind() {
		string_value.go#L33: 			if (fv.Kind() == reflect.Ptr || fv.Kind() == reflect.Slice) && fv.IsNil() {

	github.com/aws/aws-sdk-go/private/protocol
		idempotency.go#L44: 	if v.Kind() == reflect.Ptr {

	github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
		build.go#L121: 		if (member.Kind() == reflect.Ptr || member.Kind() == reflect.Slice || member.Kind() == reflect.Map) && member.IsNil() {
		build.go#L199: 	switch value := reflect.Indirect(v); value.Kind() {
		build.go#L292: 	for value.Kind() == reflect.Ptr {
		unmarshal.go#L132: 	if value.Kind() == reflect.Ptr {

	github.com/aws/aws-sdk-go/private/protocol/query/queryutil
		queryutil.go#L24: 	for value.Kind() == reflect.Ptr {
		queryutil.go#L44: 		switch value.Kind() {

	github.com/aws/aws-sdk-go/private/protocol/rest
		build.go#L85: 			if kind := m.Kind(); kind == reflect.Ptr {
		payload.go#L23: 			if payload.IsValid() || (payload.Kind() == reflect.Ptr && !payload.IsNil()) {
		unmarshal.go#L200: 		if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		build.go#L39: 	for value.Kind() == reflect.Ptr {
		build.go#L74: 		switch value.Kind() {
		unmarshal.go#L117: 	if r.Kind() == reflect.Ptr {

	github.com/ghodss/yaml
		fields.go#L26: 	if v.Kind() != reflect.Ptr && v.Type().Name() != "" && v.CanAddr() {
		fields.go#L32: 		if v.Kind() == reflect.Interface && !v.IsNil() {
		fields.go#L34: 			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
		fields.go#L40: 		if v.Kind() != reflect.Ptr {
		fields.go#L44: 		if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
		yaml.go#L175: 				if t.Kind() == reflect.Struct {
		yaml.go#L201: 				} else if t.Kind() == reflect.Map {
		yaml.go#L229: 			if t.Kind() == reflect.Slice {
		yaml.go#L249: 		if jsonTarget != nil && (*jsonTarget).Kind() == reflect.String {

	github.com/go-git/gcfg
		set.go#L220: 	if vPCfg.Kind() != reflect.Ptr || vPCfg.Elem().Kind() != reflect.Struct {
		set.go#L229: 	isSubsect := vSect.Kind() == reflect.Map
		set.go#L255: 	} else if vSect.Kind() != reflect.Struct {
		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#L282: 	if isMulti && vVar.Kind() == reflect.Ptr {

	github.com/go-redis/redis/v8/internal/proto
		scan.go#L115: 	if v.Kind() != reflect.Ptr {
		scan.go#L119: 	if v.Kind() != reflect.Slice {

	github.com/golang/protobuf/proto
		extensions.go#L173: 	if isScalarKind(rv.Kind()) {
		extensions.go#L233: 	if rv.Kind() == reflect.Ptr {
		extensions.go#L237: 		if isScalarKind(rv.Elem().Kind()) {

	github.com/google/go-cmp/cmp
		compare.go#L381: 		if v.Kind() == reflect.Interface && v.IsNil() && v.Type() != t {
		export_unsafe.go#L29: 		if ve.Kind() == reflect.Interface && ve.IsNil() {
		report_reflect.go#L298: 		panic(fmt.Sprintf("%v kind not handled", v.Kind()))

	github.com/google/go-cmp/cmp/cmpopts
		equate.go#L30: 		(vx.Kind() == reflect.Slice || vx.Kind() == reflect.Map) &&
		sort.go#L46: 		!(vx.Kind() == reflect.Slice && vx.Type().Elem().AssignableTo(ss.in)) ||
		sort.go#L117: 		(vx.Kind() == reflect.Map && vx.Type().Key().AssignableTo(ms.in)) &&

	github.com/google/go-cmp/cmp/internal/value
		sort.go#L90: 			return vx.Kind() < vy.Kind()
		zero.go#L15: 	switch v.Kind() {

	github.com/google/safehtml/internal/safehtmlutil
		safehtmlutil.go#L159: 	for !v.Type().Implements(fmtStringerType) && !v.Type().Implements(errorType) && v.Kind() == reflect.Ptr && !v.IsNil() {
		safehtmlutil.go#L176: 	for 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#L50: 	switch dst.Kind() {
		map.go#L84: 			dstKind := dstElement.Kind()
		map.go#L85: 			srcKind := srcElement.Kind()
		map.go#L105: 			} else if dstKind == reflect.Interface && dstElement.Kind() == reflect.Interface {
		map.go#L159: 	if vSrc.Kind() == vDst.Kind() {
		map.go#L163: 	switch vSrc.Kind() {
		map.go#L165: 		if vDst.Kind() != reflect.Map {
		map.go#L169: 		if vDst.Kind() != reflect.Struct {
		merge.go#L89: 		err = fmt.Errorf("cannot append two different types (%s, %s)", src.Kind(), dst.Kind())
		merge.go#L93: 	switch dst.Kind() {
		merge.go#L198: 		if dst.Kind() != reflect.Ptr && src.Type().AssignableTo(dst.Type()) {
		merge.go#L211: 		if src.Kind() != reflect.Interface {
		merge.go#L212: 			if dst.IsNil() || (src.Kind() != reflect.Ptr && overwrite) {
		merge.go#L216: 			} else if src.Kind() == reflect.Ptr {
		merge.go#L329: 	k := v.Kind()
		mergo.go#L37: 	switch v.Kind() {
		mergo.go#L67: 	if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map {
		mergo.go#L73: 	if vSrc.Kind() == reflect.Ptr {

	github.com/jackc/pgtype
		aclitem_array.go#L145: 	switch value.Kind() {
		aclitem_array.go#L226: 		if value.Kind() == reflect.Ptr {
		aclitem_array.go#L230: 		switch value.Kind() {
		aclitem_array.go#L237: 			if value.Kind() == reflect.Slice {
		aclitem_array.go#L260: 	switch kind := value.Kind(); kind {
		array.go#L363: 	switch value.Kind() {
		array_type.go#L60: 	if sliceVal.Kind() != reflect.Slice {
		array_type.go#L102: 	if ptrSlice.Kind() != reflect.Ptr {
		bool_array.go#L148: 	switch value.Kind() {
		bool_array.go#L229: 		if value.Kind() == reflect.Ptr {
		bool_array.go#L233: 		switch value.Kind() {
		bool_array.go#L240: 			if value.Kind() == reflect.Slice {
		bool_array.go#L263: 	switch kind := value.Kind(); kind {
		bpchar_array.go#L148: 	switch value.Kind() {
		bpchar_array.go#L229: 		if value.Kind() == reflect.Ptr {
		bpchar_array.go#L233: 		switch value.Kind() {
		bpchar_array.go#L240: 			if value.Kind() == reflect.Slice {
		bpchar_array.go#L263: 	switch kind := value.Kind(); kind {
		bytea_array.go#L129: 	switch value.Kind() {
		bytea_array.go#L201: 		if value.Kind() == reflect.Ptr {
		bytea_array.go#L205: 		switch value.Kind() {
		bytea_array.go#L212: 			if value.Kind() == reflect.Slice {
		bytea_array.go#L235: 	switch kind := value.Kind(); kind {
		cidr_array.go#L168: 	switch value.Kind() {
		cidr_array.go#L258: 		if value.Kind() == reflect.Ptr {
		cidr_array.go#L262: 		switch value.Kind() {
		cidr_array.go#L269: 			if value.Kind() == reflect.Slice {
		cidr_array.go#L292: 	switch kind := value.Kind(); kind {
		composite_type.go#L184: 	if dstValue.Kind() != reflect.Ptr {
		convert.go#L19: 	switch refVal.Kind() {
		convert.go#L74: 	switch refVal.Kind() {
		convert.go#L93: 	switch refVal.Kind() {
		convert.go#L114: 	switch refVal.Kind() {
		convert.go#L133: 	switch refVal.Kind() {
		convert.go#L149: 	switch refVal.Kind() {
		convert.go#L170: 	switch refVal.Kind() {
		convert.go#L191: 	switch refVal.Kind() {
		convert.go#L283: 			if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L285: 				switch el.Kind() {
		convert.go#L316: 	if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L318: 		if el.Kind() == reflect.Ptr {
		convert.go#L335: 			if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L337: 				switch el.Kind() {
		convert.go#L358: 	if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L360: 		if el.Kind() == reflect.Ptr {
		convert.go#L373: 	if dstPtr.Kind() != reflect.Ptr {
		convert.go#L379: 	switch dstVal.Kind() {
		convert.go#L401: 	if dstPtr.Kind() != reflect.Ptr {
		convert.go#L408: 	if dstVal.Kind() == reflect.Ptr {
		convert.go#L414: 	if baseValType, ok := kindTypes[dstVal.Kind()]; ok {
		convert.go#L419: 	if dstVal.Kind() == reflect.Slice {
		convert.go#L427: 	if dstVal.Kind() == reflect.Array {
		date_array.go#L149: 	switch value.Kind() {
		date_array.go#L230: 		if value.Kind() == reflect.Ptr {
		date_array.go#L234: 		switch value.Kind() {
		date_array.go#L241: 			if value.Kind() == reflect.Slice {
		date_array.go#L264: 	switch kind := value.Kind(); kind {
		enum_array.go#L145: 	switch value.Kind() {
		enum_array.go#L226: 		if value.Kind() == reflect.Ptr {
		enum_array.go#L230: 		switch value.Kind() {
		enum_array.go#L237: 			if value.Kind() == reflect.Slice {
		enum_array.go#L260: 	switch kind := value.Kind(); kind {
		float4_array.go#L148: 	switch value.Kind() {
		float4_array.go#L229: 		if value.Kind() == reflect.Ptr {
		float4_array.go#L233: 		switch value.Kind() {
		float4_array.go#L240: 			if value.Kind() == reflect.Slice {
		float4_array.go#L263: 	switch kind := value.Kind(); kind {
		float8_array.go#L148: 	switch value.Kind() {
		float8_array.go#L229: 		if value.Kind() == reflect.Ptr {
		float8_array.go#L233: 		switch value.Kind() {
		float8_array.go#L240: 			if value.Kind() == reflect.Slice {
		float8_array.go#L263: 	switch kind := value.Kind(); kind {
		hstore_array.go#L129: 	switch value.Kind() {
		hstore_array.go#L201: 		if value.Kind() == reflect.Ptr {
		hstore_array.go#L205: 		switch value.Kind() {
		hstore_array.go#L212: 			if value.Kind() == reflect.Slice {
		hstore_array.go#L235: 	switch kind := value.Kind(); kind {
		inet_array.go#L168: 	switch value.Kind() {
		inet_array.go#L258: 		if value.Kind() == reflect.Ptr {
		inet_array.go#L262: 		switch value.Kind() {
		inet_array.go#L269: 			if value.Kind() == reflect.Slice {
		inet_array.go#L292: 	switch kind := value.Kind(); kind {
		int2_array.go#L414: 	switch value.Kind() {
		int2_array.go#L621: 		if value.Kind() == reflect.Ptr {
		int2_array.go#L625: 		switch value.Kind() {
		int2_array.go#L632: 			if value.Kind() == reflect.Slice {
		int2_array.go#L655: 	switch kind := value.Kind(); kind {
		int4_array.go#L414: 	switch value.Kind() {
		int4_array.go#L621: 		if value.Kind() == reflect.Ptr {
		int4_array.go#L625: 		switch value.Kind() {
		int4_array.go#L632: 			if value.Kind() == reflect.Slice {
		int4_array.go#L655: 	switch kind := value.Kind(); kind {
		int8_array.go#L414: 	switch value.Kind() {
		int8_array.go#L621: 		if value.Kind() == reflect.Ptr {
		int8_array.go#L625: 		switch value.Kind() {
		int8_array.go#L632: 			if value.Kind() == reflect.Slice {
		int8_array.go#L655: 	switch kind := value.Kind(); kind {
		jsonb_array.go#L148: 	switch value.Kind() {
		jsonb_array.go#L229: 		if value.Kind() == reflect.Ptr {
		jsonb_array.go#L233: 		switch value.Kind() {
		jsonb_array.go#L240: 			if value.Kind() == reflect.Slice {
		jsonb_array.go#L263: 	switch kind := value.Kind(); kind {
		macaddr_array.go#L149: 	switch value.Kind() {
		macaddr_array.go#L230: 		if value.Kind() == reflect.Ptr {
		macaddr_array.go#L234: 		switch value.Kind() {
		macaddr_array.go#L241: 			if value.Kind() == reflect.Slice {
		macaddr_array.go#L264: 	switch kind := value.Kind(); kind {
		numeric_array.go#L262: 	switch value.Kind() {
		numeric_array.go#L397: 		if value.Kind() == reflect.Ptr {
		numeric_array.go#L401: 		switch value.Kind() {
		numeric_array.go#L408: 			if value.Kind() == reflect.Slice {
		numeric_array.go#L431: 	switch kind := value.Kind(); kind {
		pgtype.go#L603: 	if refVal.Kind() == reflect.Ptr && refVal.Type().Elem().Kind() == reflect.Ptr {
		text_array.go#L148: 	switch value.Kind() {
		text_array.go#L229: 		if value.Kind() == reflect.Ptr {
		text_array.go#L233: 		switch value.Kind() {
		text_array.go#L240: 			if value.Kind() == reflect.Slice {
		text_array.go#L263: 	switch kind := value.Kind(); kind {
		timestamp_array.go#L149: 	switch value.Kind() {
		timestamp_array.go#L230: 		if value.Kind() == reflect.Ptr {
		timestamp_array.go#L234: 		switch value.Kind() {
		timestamp_array.go#L241: 			if value.Kind() == reflect.Slice {
		timestamp_array.go#L264: 	switch kind := value.Kind(); kind {
		timestamptz_array.go#L149: 	switch value.Kind() {
		timestamptz_array.go#L230: 		if value.Kind() == reflect.Ptr {
		timestamptz_array.go#L234: 		switch value.Kind() {
		timestamptz_array.go#L241: 			if value.Kind() == reflect.Slice {
		timestamptz_array.go#L264: 	switch kind := value.Kind(); kind {
		tsrange_array.go#L110: 	switch value.Kind() {
		tsrange_array.go#L182: 		if value.Kind() == reflect.Ptr {
		tsrange_array.go#L186: 		switch value.Kind() {
		tsrange_array.go#L193: 			if value.Kind() == reflect.Slice {
		tsrange_array.go#L216: 	switch kind := value.Kind(); kind {
		tstzrange_array.go#L110: 	switch value.Kind() {
		tstzrange_array.go#L182: 		if value.Kind() == reflect.Ptr {
		tstzrange_array.go#L186: 		switch value.Kind() {
		tstzrange_array.go#L193: 			if value.Kind() == reflect.Slice {
		tstzrange_array.go#L216: 	switch kind := value.Kind(); kind {
		uuid_array.go#L186: 	switch value.Kind() {
		uuid_array.go#L285: 		if value.Kind() == reflect.Ptr {
		uuid_array.go#L289: 		switch value.Kind() {
		uuid_array.go#L296: 			if value.Kind() == reflect.Slice {
		uuid_array.go#L319: 	switch kind := value.Kind(); kind {
		varchar_array.go#L148: 	switch value.Kind() {
		varchar_array.go#L229: 		if value.Kind() == reflect.Ptr {
		varchar_array.go#L233: 		switch value.Kind() {
		varchar_array.go#L240: 			if value.Kind() == reflect.Slice {
		varchar_array.go#L263: 	switch kind := value.Kind(); kind {

	github.com/jackc/pgx/v4
		extended_query_builder.go#L71: 	argIsPtr := refVal.Kind() == reflect.Ptr
		go_stdlib.go#L55: 	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&
		values.go#L33: 	if refVal.Kind() == reflect.Ptr && refVal.IsNil() {
		values.go#L131: 	if refVal.Kind() == reflect.Ptr {
		values.go#L180: 	if refVal.Kind() == reflect.Ptr {
		values.go#L241: 	switch val.Kind() {

	github.com/jmespath/go-jmespath
		interpreter.go#L160: 		if rv.Kind() == reflect.Slice {
		interpreter.go#L321: 	if rv.Kind() == reflect.Struct {
		interpreter.go#L327: 	} else if rv.Kind() == reflect.Ptr {
		util.go#L28: 	switch rv.Kind() {

	github.com/lann/builder
		builder.go#L210: 				switch field.Kind() {
		reflect.go#L15: 	kind := val.Kind()

	github.com/lib/pq
		array.go#L313: 	case dpv.Kind() != reflect.Ptr:
		array.go#L320: 	switch dv.Kind() {
		array.go#L333: 		if dv.Kind() == reflect.Slice {
		array.go#L383: 	switch dv.Kind() {
		array.go#L403: 	switch rv.Kind() {
		array.go#L580: 	if k := rv.Kind(); k == reflect.Array || k == reflect.Slice {

	github.com/Masterminds/squirrel
		expr.go#L174: 		if r.Kind() == reflect.Ptr {
		expr.go#L418: 	return valVal.Kind() == reflect.Array || valVal.Kind() == reflect.Slice

	go.opentelemetry.io/otel/label
		kv.go#L116: 	switch rv.Kind() {

	go/ast
		print.go#L23: 	switch v.Kind() {
		print.go#L149: 	switch x.Kind() {

	golang.org/x/net/http2
		server.go#L657: 	if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr {

	golang.org/x/pkgsite/internal/database
		reflect.go#L42: 	if v.Kind() == reflect.Ptr {
		reflect.go#L94: 	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Ptr {
		reflect.go#L133: 	if v.Kind() != reflect.Ptr {
		reflect.go#L137: 	if ve.Kind() != reflect.Slice {

	golang.org/x/pkgsite/internal/worker
		server.go#L708: 	switch v.Kind() {

	google.golang.org/api/internal/gensupport
		json.go#L196: 	switch v.Kind() {

	google.golang.org/protobuf/internal/descfmt
		stringer.go#L211: 		if v.Kind() == reflect.Struct && !rv.IsValid() {
		stringer.go#L226: 		switch rv.Kind() {

	google.golang.org/protobuf/internal/impl
		codec_map.go#L289: 		switch keys[i].Kind() {
		codec_map.go#L301: 			panic("invalid kind: " + keys[i].Kind().String())
		message_reflect_field.go#L248: 			switch rv.Kind() {
		message_reflect_field.go#L276: 				if rv.Kind() == reflect.Ptr {
		message_reflect_field.go#L284: 			if nullable && rv.Kind() == reflect.Ptr {

	gopkg.in/yaml.v2
		decode.go#L304: 		if out.Kind() == reflect.Ptr {
		decode.go#L428: 		if out.Kind() == reflect.Map && !out.CanAddr() {
		decode.go#L461: 	switch out.Kind() {
		decode.go#L589: 	switch out.Kind() {
		decode.go#L614: 	if out.Kind() != reflect.Array {
		decode.go#L624: 	switch out.Kind() {
		decode.go#L668: 			kkind := k.Kind()
		decode.go#L670: 				kkind = k.Elem().Kind()
		encode.go#L99: 	if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
		encode.go#L145: 	switch in.Kind() {
		encode.go#L366: 	if in.Kind() == reflect.Float32 {
		sorter.go#L15: 	ak := a.Kind()
		sorter.go#L16: 	bk := b.Kind()
		sorter.go#L19: 		ak = a.Kind()
		sorter.go#L23: 		bk = b.Kind()
		sorter.go#L83: 	switch v.Kind() {
		sorter.go#L102: 	switch a.Kind() {
		yaml.go#L127: 	if out.Kind() == reflect.Ptr && !out.IsNil() {
		yaml.go#L145: 		if v.Kind() == reflect.Ptr && !v.IsNil() {
		yaml.go#L429: 	kind := v.Kind()

	html/template
		content.go#L124: 	for v.Kind() == reflect.Ptr && !v.IsNil() {
		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#L84: 	switch aVal.Kind() {

	net/http
		h2_bundle.go#L4226: 	if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr {

	text/template
		exec.go#L313: 	switch val.Kind() {
		exec.go#L354: 	switch val.Kind() {
		exec.go#L438: 		if value.Kind() == reflect.Interface && value.Type().NumMethod() == 0 {
		exec.go#L595: 	if receiver.Kind() == reflect.Interface && isNil {
		exec.go#L605: 	if ptr.Kind() != reflect.Interface && ptr.Kind() != reflect.Ptr && ptr.CanAddr() {
		exec.go#L613: 	switch receiver.Kind() {
		exec.go#L766: 		if value.Kind() == reflect.Interface && !value.IsNil() {
		exec.go#L778: 		case value.Kind() == reflect.Ptr && value.Type().Elem().AssignableTo(typ):
		exec.go#L935: 	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
		exec.go#L948: 	if v.Kind() != reflect.Interface {
		exec.go#L974: 	if v.Kind() == reflect.Ptr {
		exec.go#L985: 			switch v.Kind() {
		funcs.go#L91: 		if v.Kind() != reflect.Func {
		funcs.go#L165: 	if intLike(value.Kind()) && intLike(argType.Kind()) && value.Type().ConvertibleTo(argType) {
		funcs.go#L185: 	switch index.Kind() {
		funcs.go#L217: 		switch item.Kind() {
		funcs.go#L259: 	switch item.Kind() {
		funcs.go#L301: 	switch item.Kind() {
		funcs.go#L437: 	switch v.Kind() {

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L263: 	switch reflect.ValueOf(out).Elem().Kind() {
		asn1.go#L615: 		switch reflect.ValueOf(out).Elem().Kind() {