func reflect.Zero

73 uses

	reflect (current package)
		value.go#L510: 				ret[i] = Zero(tv)
		value.go#L2370: func Zero(typ Type) Value {
		value.go#L2750: 		ret := Zero(typ)

	database/sql
		convert.go#L424: 			dv.Set(reflect.Zero(dv.Type()))

	encoding/asn1
		marshal.go#L605: 		if reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface()) {

	encoding/gob
		decode.go#L569: 	keyZ := reflect.Zero(mtyp.Key())
		decode.go#L571: 	elemZ := reflect.Zero(mtyp.Elem())
		decode.go#L656: 		value.Set(reflect.Zero(value.Type()))

	encoding/json
		decode.go#L584: 			z := reflect.Zero(v.Type().Elem())
		decode.go#L691: 				mapElem.Set(reflect.Zero(elemType))
		decode.go#L789: 					if err != nil || reflect.Zero(kt).OverflowInt(n) {
		decode.go#L797: 					if err != nil || reflect.Zero(kt).OverflowUint(n) {
		decode.go#L900: 			v.Set(reflect.Zero(v.Type()))

	encoding/xml
		read.go#L282: 		val.Set(reflect.Append(val, reflect.Zero(val.Type().Elem())))
		read.go#L398: 		v.Set(reflect.Append(val, reflect.Zero(v.Type().Elem())))

	flag
		flag.go#L462: 		z = reflect.Zero(typ)

	github.com/aws/aws-sdk-go/aws/awsutil
		path_value.go#L81: 					value.Set(reflect.Zero(value.Type()))
		path_value.go#L208: 		dstVal.Set(reflect.Zero(dstVal.Type()))
		path_value.go#L212: 			srcVal = reflect.Zero(dstVal.Type())

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		unmarshal.go#L196: 		childR := reflect.Zero(t.Elem())

	github.com/ghodss/yaml
		yaml.go#L204: 					jtv := reflect.Zero(t.Type().Elem())

	github.com/go-git/gcfg
		set.go#L289: 		vVar.Set(reflect.Zero(vVar.Type()))

	github.com/go-redis/redis/v8/internal/proto
		scan.go#L156: 	zero := reflect.Zero(elemType)

	github.com/golang/protobuf/proto
		properties.go#L264: 			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
		properties.go#L267: 			oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
		properties.go#L269: 		if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(protoreflect.ProtoMessage); ok {

	github.com/google/go-cmp/cmp
		export_unsafe.go#L30: 			return reflect.Zero(f.Type)

	github.com/jackc/pgtype
		array_type.go#L131: 		sliceVal.Set(reflect.Zero(sliceType))
		convert.go#L319: 			el.Set(reflect.Zero(el.Type()))
		convert.go#L361: 			el.Set(reflect.Zero(el.Type()))
		convert.go#L381: 		dstVal.Set(reflect.Zero(dstVal.Type()))
		pgtype.go#L606: 			nilPtr := reflect.Zero(refVal.Type().Elem())

	github.com/lann/builder
		builder.go#L212: 					value = reflect.Zero(field.Type())

	github.com/lib/pq
		array.go#L302: 	if ad, ok := reflect.Zero(rt).Interface().(ArrayDelimiter); ok {
		array.go#L334: 			dv.Set(reflect.Zero(dv.Type()))

	golang.org/x/pkgsite/internal/database
		reflect.go#L109: 		n.ptr.Elem().Set(reflect.Zero(ntype)) // *v = nil

	golang.org/x/pkgsite/internal/postgres
		details.go#L174: 		vptr.Elem().Set(reflect.Zero(vptr.Elem().Type()))

	google.golang.org/api/support/bundler
		bundler.go#L152: 		itemSliceZero: reflect.Zero(reflect.SliceOf(reflect.TypeOf(itemExample))),

	google.golang.org/protobuf/internal/impl
		convert.go#L330: 		return reflect.Zero(c.goType) // ensure empty string is []byte(nil)
		convert.go#L466: 	return c.PBValueOf(reflect.Zero(c.goType))
		convert_list.go#L41: 		return reflect.Zero(c.goType)
		convert_list.go#L63: 	return pref.ValueOfList(&listReflect{reflect.Zero(reflect.PtrTo(c.goType)), c.c})
		convert_list.go#L99: 	return c.PBValueOf(reflect.Zero(c.goType))
		convert_map.go#L58: 	return c.PBValueOf(reflect.Zero(c.goType))
		legacy_enum.go#L125: 	ev := reflect.Zero(t).Interface()
		legacy_extension.go#L33: 		mz := reflect.Zero(t).Interface()
		legacy_extension.go#L66: 	xi.ExtensionType = reflect.Zero(extType).Interface()
		legacy_extension.go#L96: 	switch v := reflect.Zero(t).Interface().(type) {
		legacy_message.go#L52: 	v := reflect.Zero(t).Interface()
		legacy_message.go#L91: 	mv := reflect.Zero(t).Interface()
		legacy_message.go#L200: 			for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
		legacy_message.go#L212: 		vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
		legacy_message.go#L263: 		if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok {
		legacy_message.go#L309: 		switch v := reflect.Zero(t).Interface().(type) {
		legacy_message.go#L317: 		switch v := reflect.Zero(t).Interface().(type) {
		legacy_message.go#L425: 	return aberrantMessage{reflect.Zero(mt.t)}
		legacy_message.go#L428: 	return aberrantMessage{reflect.Zero(mt.t)}
		legacy_message.go#L457: 	return aberrantMessage{reflect.Zero(m.v.Type())}
		message.go#L56: 	m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage)
		message.go#L186: 			for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
		message.go#L213: 	return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
		message_reflect_field.go#L70: 			rv.Set(reflect.Zero(rv.Type()))
		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#L265: 			rv.Set(reflect.Zero(rv.Type()))
		message_reflect_field.go#L395: 			rv.Set(reflect.Zero(rv.Type()))

	gopkg.in/yaml.v2
		decode.go#L431: 			out.Set(reflect.Zero(out.Type()))
		decode.go#L473: 			out.Set(reflect.Zero(out.Type()))

	text/template
		exec.go#L640: 					result = reflect.Zero(receiver.Type().Elem())
		exec.go#L758: 			return reflect.Zero(typ)
		exec.go#L799: 			return reflect.Zero(typ)
		funcs.go#L160: 		value = reflect.Zero(argType)
		funcs.go#L232: 				item = reflect.Zero(item.Type().Elem())