func reflect.TypeOf

364 uses

	reflect (current package)
		type.go#L1368: func TypeOf(i interface{}) Type {
		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]))},
		value.go#L934: var uint8Type = TypeOf(uint8(0)).(*rtype)

	cloud.google.com/go/storage
		reader.go#L392: 	return strings.HasSuffix(err.Error(), "INTERNAL_ERROR") && strings.Contains(reflect.TypeOf(err).String(), "http2")

	database/sql
		convert.go#L540: var valuerReflectType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
		sql.go#L3045: 			ci.scanType = reflect.TypeOf(new(interface{})).Elem()

	database/sql/driver
		types.go#L214: var valuerReflectType = reflect.TypeOf((*Valuer)(nil)).Elem()

	encoding/asn1
		asn1.go#L656: 	bitStringType        = reflect.TypeOf(BitString{})
		asn1.go#L657: 	objectIdentifierType = reflect.TypeOf(ObjectIdentifier{})
		asn1.go#L658: 	enumeratedType       = reflect.TypeOf(Enumerated(0))
		asn1.go#L659: 	flagType             = reflect.TypeOf(Flag(false))
		asn1.go#L660: 	timeType             = reflect.TypeOf(time.Time{})
		asn1.go#L661: 	rawValueType         = reflect.TypeOf(RawValue{})
		asn1.go#L662: 	rawContentsType      = reflect.TypeOf(RawContent(nil))
		asn1.go#L663: 	bigIntType           = reflect.TypeOf(new(big.Int))
		asn1.go#L1115: 		return nil, &invalidUnmarshalError{reflect.TypeOf(val)}

	encoding/binary
		binary.go#L253: 		return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
		binary.go#L383: 		return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())

	encoding/gob
		decode.go#L1158: var emptyStructType = reflect.TypeOf(emptyStruct{})
		decode.go#L1228: 	switch reflect.TypeOf(int(0)).Bits() {
		decode.go#L1242: 	switch reflect.TypeOf(uintptr(0)).Bits() {
		type.go#L106: 	gobEncoderInterfaceType        = reflect.TypeOf((*GobEncoder)(nil)).Elem()
		type.go#L107: 	gobDecoderInterfaceType        = reflect.TypeOf((*GobDecoder)(nil)).Elem()
		type.go#L108: 	binaryMarshalerInterfaceType   = reflect.TypeOf((*encoding.BinaryMarshaler)(nil)).Elem()
		type.go#L109: 	binaryUnmarshalerInterfaceType = reflect.TypeOf((*encoding.BinaryUnmarshaler)(nil)).Elem()
		type.go#L110: 	textMarshalerInterfaceType     = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
		type.go#L111: 	textUnmarshalerInterfaceType   = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
		type.go#L259: var tWireType = mustGetTypeInfo(reflect.TypeOf(wireType{})).id
		type.go#L265: 	checkId(17, mustGetTypeInfo(reflect.TypeOf(arrayType{})).id)
		type.go#L266: 	checkId(18, mustGetTypeInfo(reflect.TypeOf(CommonType{})).id)
		type.go#L267: 	checkId(19, mustGetTypeInfo(reflect.TypeOf(sliceType{})).id)
		type.go#L268: 	checkId(20, mustGetTypeInfo(reflect.TypeOf(structType{})).id)
		type.go#L269: 	checkId(21, mustGetTypeInfo(reflect.TypeOf(fieldType{})).id)
		type.go#L270: 	checkId(23, mustGetTypeInfo(reflect.TypeOf(mapType{})).id)
		type.go#L284: 	wireTypeUserInfo = userType(reflect.TypeOf((*wireType)(nil)))
		type.go#L615: 	rt := reflect.TypeOf(e).Elem()
		type.go#L813: 	ut := userType(reflect.TypeOf(value))
		type.go#L819: 	if t, dup := nameToConcreteType.LoadOrStore(name, reflect.TypeOf(value)); dup && t != ut.user {
		type.go#L838: 	rt := reflect.TypeOf(value)

	encoding/json
		decode.go#L173: 		return &InvalidUnmarshalError{reflect.TypeOf(v)}
		decode.go#L599: var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
		decode.go#L838: 		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
		decode.go#L843: var numberType = reflect.TypeOf(Number(""))
		encode.go#L411: 	marshalerType     = reflect.TypeOf((*Marshaler)(nil)).Elem()
		encode.go#L412: 	textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()

	encoding/xml
		marshal.go#L401: 	marshalerType     = reflect.TypeOf((*Marshaler)(nil)).Elem()
		marshal.go#L402: 	marshalerAttrType = reflect.TypeOf((*MarshalerAttr)(nil)).Elem()
		marshal.go#L403: 	textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
		read.go#L192: 	t := reflect.TypeOf(val)
		read.go#L301: 	attrType            = reflect.TypeOf(Attr{})
		read.go#L302: 	unmarshalerType     = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
		read.go#L303: 	unmarshalerAttrType = reflect.TypeOf((*UnmarshalerAttr)(nil)).Elem()
		read.go#L304: 	textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
		typeinfo.go#L49: var nameType = reflect.TypeOf(Name{})

	flag
		flag.go#L457: 	typ := reflect.TypeOf(flag.Value)

	fmt
		print.go#L337: 		p.buf.writeString(reflect.TypeOf(p.arg).String())
		print.go#L652: 		p.fmt.fmtS(reflect.TypeOf(arg).String())
		print.go#L1140: 				p.buf.writeString(reflect.TypeOf(arg).String())
		print.go#L1152: 		isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String

	github.com/aws/aws-sdk-go/aws/awsutil
		copy.go#L27: 	dsti := reflect.New(reflect.TypeOf(src).Elem())
		equal.go#L20: 		return reflect.TypeOf(a) == reflect.TypeOf(b)

	github.com/aws/aws-sdk-go/aws/request
		request_pagination.go#L229: 	data := reflect.New(reflect.TypeOf(r.Data).Elem()).Interface()

	github.com/aws/aws-sdk-go/private/protocol/rest
		build.go#L28: var byteSliceType = reflect.TypeOf([]byte{})

	github.com/census-instrumentation/opencensus-proto/gen-go/agent/common/v1
		common.pb.go#L558: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/census-instrumentation/opencensus-proto/gen-go/metrics/v1
		metrics.pb.go#L1621: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/census-instrumentation/opencensus-proto/gen-go/resource/v1
		resource.pb.go#L179: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/ghodss/yaml
		yaml.go#L165: 					reflect.TypeOf(k), k, v)

	github.com/go-git/gcfg
		set.go#L105: 	reflect.TypeOf(int(0)):    types.Dec | types.Hex,
		set.go#L106: 	reflect.TypeOf(int8(0)):   types.Dec | types.Hex,
		set.go#L107: 	reflect.TypeOf(int16(0)):  types.Dec | types.Hex,
		set.go#L108: 	reflect.TypeOf(int32(0)):  types.Dec | types.Hex,
		set.go#L109: 	reflect.TypeOf(int64(0)):  types.Dec | types.Hex,
		set.go#L110: 	reflect.TypeOf(uint(0)):   types.Dec | types.Hex,
		set.go#L111: 	reflect.TypeOf(uint8(0)):  types.Dec | types.Hex,
		set.go#L112: 	reflect.TypeOf(uint16(0)): types.Dec | types.Hex,
		set.go#L113: 	reflect.TypeOf(uint32(0)): types.Dec | types.Hex,
		set.go#L114: 	reflect.TypeOf(uint64(0)): types.Dec | types.Hex,
		set.go#L116: 	reflect.TypeOf(big.Int{}): types.Dec | types.Hex,
		set.go#L133: 		mode = intModeDefault(reflect.TypeOf(d).Elem())
		set.go#L167: 	reflect.TypeOf(big.Int{}): intSetter,

	github.com/go-git/gcfg/types
		enum.go#L25: 			ep.Type = reflect.TypeOf(v).Name()

	github.com/go-git/go-git/v5/plumbing/transport/ssh
		common.go#L216: 	t := reflect.TypeOf(*c)

	github.com/golang/protobuf/proto
		extensions.go#L230: 	if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) {
		registry.go#L190: 	messageTypeCache.Store(s, reflect.TypeOf(m))
		registry.go#L198: 	t := reflect.TypeOf(m)
		registry.go#L248: 		return reflect.TypeOf(protoreflect.EnumNumber(0))
		registry.go#L253: 		return reflect.TypeOf((*protoreflect.Message)(nil)).Elem()
		registry.go#L255: 		return reflect.TypeOf(fd.Default().Interface())
		registry.go#L260: 	return reflect.TypeOf(et.New(0))
		registry.go#L264: 	return reflect.TypeOf(MessageV1(mt.Zero().Interface()))
		text_decode.go#L134: 				t := reflect.TypeOf(m)

	github.com/golang/protobuf/ptypes/any
		any.pb.go#L48: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/golang/protobuf/ptypes/duration
		duration.pb.go#L49: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/golang/protobuf/ptypes/struct
		struct.pb.go#L64: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/golang/protobuf/ptypes/timestamp
		timestamp.pb.go#L50: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/golang/protobuf/ptypes/wrappers
		wrappers.pb.go#L57: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/google/go-cmp/cmp
		compare.go#L146: 		t = reflect.TypeOf((*interface{})(nil)).Elem()
		options.go#L423: 		t := reflect.TypeOf(typ)
		report_reflect.go#L208: 		if t.Elem() == reflect.TypeOf(byte(0)) {
		report_slices.go#L88: 	case t.Kind() == reflect.Slice && t.Elem() == reflect.TypeOf(byte(0)):
		report_slices.go#L200: 				if t != reflect.TypeOf(string("")) {
		report_slices.go#L296: 		if t != reflect.TypeOf(string("")) {
		report_slices.go#L301: 		if t != reflect.TypeOf([]byte(nil)) {

	github.com/google/go-cmp/cmp/cmpopts
		ignore.go#L40: 		t := reflect.TypeOf(typ)
		ignore.go#L74: 	t := reflect.TypeOf(ifaces)
		ignore.go#L129: 		t := reflect.TypeOf(typ)
		struct_filter.go#L43: 	t := reflect.TypeOf(typ)

	github.com/google/go-cmp/cmp/internal/function
		func.go#L35: var boolType = reflect.TypeOf(true)

	github.com/google/safehtml/internal/safehtmlutil
		safehtmlutil.go#L146: 	errorType       = reflect.TypeOf((*error)(nil)).Elem()
		safehtmlutil.go#L147: 	fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
		safehtmlutil.go#L171: 	if t := reflect.TypeOf(a); t.Kind() != reflect.Ptr {

	github.com/google/safehtml/template
		escape.go#L801: 	errorType       = reflect.TypeOf((*error)(nil)).Elem()
		escape.go#L802: 	fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()

	github.com/hashicorp/errwrap
		errwrap.go#L116: 		search = reflect.TypeOf(v).String()
		errwrap.go#L121: 			needle = reflect.TypeOf(err).String()

	github.com/imdario/mergo
		map.go#L88: 				srcKind = reflect.TypeOf(srcElement.Interface()).Kind()

	github.com/jackc/pgtype
		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#L103: 			return convVal, reflect.TypeOf(convVal) != refVal.Type()
		convert.go#L123: 		return convVal, reflect.TypeOf(convVal) != refVal.Type()
		convert.go#L158: 	timeType := reflect.TypeOf(time.Time{})
		convert.go#L179: 	uuidType := reflect.TypeOf([16]byte{})
		convert.go#L202: 			return convVal.Interface(), reflect.TypeOf(convVal.Interface()) != refVal.Type()
		convert.go#L440: 		reflect.Bool:    reflect.TypeOf(false),
		convert.go#L441: 		reflect.Float32: reflect.TypeOf(float32(0)),
		convert.go#L442: 		reflect.Float64: reflect.TypeOf(float64(0)),
		convert.go#L443: 		reflect.Int:     reflect.TypeOf(int(0)),
		convert.go#L444: 		reflect.Int8:    reflect.TypeOf(int8(0)),
		convert.go#L445: 		reflect.Int16:   reflect.TypeOf(int16(0)),
		convert.go#L446: 		reflect.Int32:   reflect.TypeOf(int32(0)),
		convert.go#L447: 		reflect.Int64:   reflect.TypeOf(int64(0)),
		convert.go#L448: 		reflect.Uint:    reflect.TypeOf(uint(0)),
		convert.go#L449: 		reflect.Uint8:   reflect.TypeOf(uint8(0)),
		convert.go#L450: 		reflect.Uint16:  reflect.TypeOf(uint16(0)),
		convert.go#L451: 		reflect.Uint32:  reflect.TypeOf(uint32(0)),
		convert.go#L452: 		reflect.Uint64:  reflect.TypeOf(uint64(0)),
		convert.go#L453: 		reflect.String:  reflect.TypeOf(""),
		pgtype.go#L324: 		valueType := reflect.TypeOf(value)
		pgtype.go#L414: 	ci.reflectTypeToName[reflect.TypeOf(value)] = name
		pgtype.go#L456: 	dt, ok := ci.reflectTypeToDataType[reflect.TypeOf(v)]

	github.com/jackc/pgx/v4
		go_stdlib.go#L41: var valuerReflectType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
		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/jackc/pgx/v4/stdlib
		sql.go#L499: 		return reflect.TypeOf(float64(0))
		sql.go#L501: 		return reflect.TypeOf(float32(0))
		sql.go#L503: 		return reflect.TypeOf(int64(0))
		sql.go#L505: 		return reflect.TypeOf(int32(0))
		sql.go#L507: 		return reflect.TypeOf(int16(0))
		sql.go#L509: 		return reflect.TypeOf(false)
		sql.go#L511: 		return reflect.TypeOf(float64(0))
		sql.go#L513: 		return reflect.TypeOf(time.Time{})
		sql.go#L515: 		return reflect.TypeOf([]byte(nil))
		sql.go#L517: 		return reflect.TypeOf("")

	github.com/jmespath/go-jmespath
		interpreter.go#L347: 		if reflect.TypeOf(element).Kind() == reflect.Slice {
		util.go#L184: 	return reflect.TypeOf(v).Kind() == reflect.Slice

	github.com/lann/builder
		builder.go#L100: var anyArrayType = reflect.TypeOf([]interface{}{})
		builder.go#L124: 			structType := getBuilderStructType(reflect.TypeOf(builder))
		builder.go#L145: 	structType := getBuilderStructType(reflect.TypeOf(builder))
		builder.go#L181: 	structVal := newBuilderStruct(reflect.TypeOf(builder))
		builder.go#L198: 	structVal := reflect.New(reflect.TypeOf(strct)).Elem()
		reflect.go#L8: 		Convert(reflect.TypeOf(to)).
		registry.go#L36: 		reflect.TypeOf(builderProto),
		registry.go#L37: 		reflect.TypeOf(structProto),

	github.com/lib/pq
		array.go#L14: var typeByteSlice = reflect.TypeOf([]byte{})
		array.go#L15: var typeDriverValuer = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
		array.go#L16: var typeSQLScanner = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
		rows.go#L27: 		return reflect.TypeOf(int64(0))
		rows.go#L29: 		return reflect.TypeOf(int32(0))
		rows.go#L31: 		return reflect.TypeOf(int16(0))
		rows.go#L33: 		return reflect.TypeOf("")
		rows.go#L35: 		return reflect.TypeOf(false)
		rows.go#L37: 		return reflect.TypeOf(time.Time{})
		rows.go#L39: 		return reflect.TypeOf([]byte(nil))
		rows.go#L41: 		return reflect.TypeOf(new(interface{})).Elem()

	go.opentelemetry.io/otel/label
		set.go#L69: 	keyValueType = reflect.TypeOf(KeyValue{})
		value.go#L140: 	switch reflect.TypeOf(array).Kind() {
		value.go#L144: 			typeName := reflect.TypeOf(array).String()

	golang.org/x/crypto/ssh
		messages.go#L773: var bigIntType = reflect.TypeOf((*big.Int)(nil))

	golang.org/x/pkgsite/internal/godoc/codec
		codec.go#L462: 	t := reflect.TypeOf(x)
		codec.go#L555: 	t := reflect.TypeOf(x)
		generate.go#L98: 		g.todo = append(g.todo, reflect.TypeOf(v))
		generate.go#L111: 	g.done[reflect.TypeOf(&iface).Elem()] = true
		generate.go#L387: 		return "String", reflect.TypeOf("")
		generate.go#L389: 		return "Bool", reflect.TypeOf(true)
		generate.go#L391: 		return "Int", reflect.TypeOf(int64(0))
		generate.go#L393: 		return "Uint", reflect.TypeOf(uint64(0))
		generate.go#L395: 		return "Float64", reflect.TypeOf(0.0)
		generate.go#L397: 		if t.Elem() == reflect.TypeOf(byte(0)) {
		generate.go#L398: 			return "Bytes", reflect.TypeOf([]byte(nil))

	golang.org/x/xerrors
		adaptor.go#L62: 			p.buf.WriteString(reflect.TypeOf(f).String())
		wrap.go#L55: 	isComparable := reflect.TypeOf(target).Comparable()
		wrap.go#L94: 		if reflect.TypeOf(err).AssignableTo(targetType) {
		wrap.go#L106: var errorType = reflect.TypeOf((*error)(nil)).Elem()

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

	google.golang.org/genproto/googleapis/api
		launch_stage.pb.go#L193: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/api/annotations
		annotations.pb.go#L109: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		client.pb.go#L204: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		field_behavior.pb.go#L222: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		http.pb.go#L768: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		resource.pb.go#L704: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/api/distribution
		distribution.pb.go#L879: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/api/label
		label.pb.go#L238: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/api/metric
		metric.pb.go#L789: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/api/monitoredres
		monitored_resource.pb.go#L487: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/cloud/secretmanager/v1
		resources.pb.go#L1385: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		service.pb.go#L1553: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/cloud/tasks/v2
		cloudtasks.pb.go#L1674: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		queue.pb.go#L860: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		target.pb.go#L1021: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		task.pb.go#L613: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/container/v1
		cluster_service.pb.go#L11538: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/devtools/clouderrorreporting/v1beta1
		common.pb.go#L822: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		error_group_service.pb.go#L305: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		error_stats_service.pb.go#L1570: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		report_errors_service.pb.go#L437: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/devtools/cloudprofiler/v2
		profiler.pb.go#L768: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/devtools/cloudtrace/v2
		trace.pb.go#L1947: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		tracing.pb.go#L239: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/iam/v1
		iam_policy.pb.go#L461: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		options.pb.go#L171: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		policy.pb.go#L802: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/logging/type
		http_request.pb.go#L347: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		log_severity.pb.go#L200: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/logging/v2
		log_entry.pb.go#L716: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		logging.pb.go#L1221: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		logging_config.pb.go#L3146: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		logging_metrics.pb.go#L1039: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/monitoring/v3
		alert.pb.go#L1199: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		alert_service.pb.go#L754: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		common.pb.go#L1134: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		dropped_labels.pb.go#L186: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		group.pb.go#L255: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		group_service.pb.go#L1029: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		metric.pb.go#L1162: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		metric_service.pb.go#L1982: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		mutation_record.pb.go#L182: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		notification.pb.go#L596: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		notification_service.pb.go#L1456: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		service.pb.go#L2294: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		service_service.pb.go#L1354: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		span_context.pb.go#L177: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		uptime.pb.go#L1611: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
		uptime_service.pb.go#L916: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/rpc/code
		code.pb.go#L326: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/rpc/errdetails
		error_details.pb.go#L1268: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/rpc/status
		status.pb.go#L191: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/type/calendarperiod
		calendar_period.pb.go#L180: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/genproto/googleapis/type/expr
		expr.pb.go#L200: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/grpc
		server.go#L561: 		ht := reflect.TypeOf(sd.HandlerType).Elem()
		server.go#L562: 		st := reflect.TypeOf(ss)

	google.golang.org/protobuf/internal/descfmt
		stringer.go#L107: 	reflect.TypeOf((*pref.FileDescriptor)(nil)).Elem():      {"Path", "Package", "Imports", "Messages", "Enums", "Extensions", "Services"},
		stringer.go#L108: 	reflect.TypeOf((*pref.MessageDescriptor)(nil)).Elem():   {"IsMapEntry", "Fields", "Oneofs", "ReservedNames", "ReservedRanges", "RequiredNumbers", "ExtensionRanges", "Messages", "Enums", "Extensions"},
		stringer.go#L109: 	reflect.TypeOf((*pref.FieldDescriptor)(nil)).Elem():     {"Number", "Cardinality", "Kind", "HasJSONName", "JSONName", "HasPresence", "IsExtension", "IsPacked", "IsWeak", "IsList", "IsMap", "MapKey", "MapValue", "HasDefault", "Default", "ContainingOneof", "ContainingMessage", "Message", "Enum"},
		stringer.go#L110: 	reflect.TypeOf((*pref.OneofDescriptor)(nil)).Elem():     {"Fields"}, // not directly used; must keep in sync with formatDescOpt
		stringer.go#L111: 	reflect.TypeOf((*pref.EnumDescriptor)(nil)).Elem():      {"Values", "ReservedNames", "ReservedRanges"},
		stringer.go#L112: 	reflect.TypeOf((*pref.EnumValueDescriptor)(nil)).Elem(): {"Number"},
		stringer.go#L113: 	reflect.TypeOf((*pref.ServiceDescriptor)(nil)).Elem():   {"Methods"},
		stringer.go#L114: 	reflect.TypeOf((*pref.MethodDescriptor)(nil)).Elem():    {"Input", "Output", "IsStreamingClient", "IsStreamingServer"},

	google.golang.org/protobuf/internal/encoding/tag
		tag.go#L20: var byteType = reflect.TypeOf(byte(0))

	google.golang.org/protobuf/internal/filedesc
		desc_lazy.go#L694: 			opts = reflect.New(reflect.TypeOf(*p).Elem()).Interface().(pref.ProtoMessage)

	google.golang.org/protobuf/internal/filetype
		build.go#L150: 				GoReflectType: reflect.TypeOf(enumGoTypes[i]),
		build.go#L171: 			tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
		build.go#L221: 			goType = reflect.TypeOf(tb.GoTypes[j])
		build.go#L225: 			goType = reflect.TypeOf(tb.GoTypes[j])
		build.go#L246: 	pref.BoolKind:     reflect.TypeOf(bool(false)),
		build.go#L247: 	pref.Int32Kind:    reflect.TypeOf(int32(0)),
		build.go#L248: 	pref.Sint32Kind:   reflect.TypeOf(int32(0)),
		build.go#L249: 	pref.Sfixed32Kind: reflect.TypeOf(int32(0)),
		build.go#L250: 	pref.Int64Kind:    reflect.TypeOf(int64(0)),
		build.go#L251: 	pref.Sint64Kind:   reflect.TypeOf(int64(0)),
		build.go#L252: 	pref.Sfixed64Kind: reflect.TypeOf(int64(0)),
		build.go#L253: 	pref.Uint32Kind:   reflect.TypeOf(uint32(0)),
		build.go#L254: 	pref.Fixed32Kind:  reflect.TypeOf(uint32(0)),
		build.go#L255: 	pref.Uint64Kind:   reflect.TypeOf(uint64(0)),
		build.go#L256: 	pref.Fixed64Kind:  reflect.TypeOf(uint64(0)),
		build.go#L257: 	pref.FloatKind:    reflect.TypeOf(float32(0)),
		build.go#L258: 	pref.DoubleKind:   reflect.TypeOf(float64(0)),
		build.go#L259: 	pref.StringKind:   reflect.TypeOf(string("")),
		build.go#L260: 	pref.BytesKind:    reflect.TypeOf([]byte(nil)),

	google.golang.org/protobuf/internal/impl
		api_export.go#L55: 		return LegacyLoadEnumDesc(reflect.TypeOf(e))
		api_export.go#L68: 		return legacyLoadEnumType(reflect.TypeOf(e))
		api_export.go#L158: 	return LegacyLoadMessageDesc(reflect.TypeOf(m))
		api_export.go#L170: 	return legacyLoadMessageInfo(reflect.TypeOf(m), "")
		convert.go#L66: 	boolType    = reflect.TypeOf(bool(false))
		convert.go#L67: 	int32Type   = reflect.TypeOf(int32(0))
		convert.go#L68: 	int64Type   = reflect.TypeOf(int64(0))
		convert.go#L69: 	uint32Type  = reflect.TypeOf(uint32(0))
		convert.go#L70: 	uint64Type  = reflect.TypeOf(uint64(0))
		convert.go#L71: 	float32Type = reflect.TypeOf(float32(0))
		convert.go#L72: 	float64Type = reflect.TypeOf(float64(0))
		convert.go#L73: 	stringType  = reflect.TypeOf(string(""))
		convert.go#L74: 	bytesType   = reflect.TypeOf([]byte(nil))
		convert.go#L75: 	byteType    = reflect.TypeOf(byte(0))
		legacy_export.go#L33: 	return legacyLoadMessageInfo(reflect.TypeOf(m), name)
		legacy_extension.go#L27: 		t := reflect.TypeOf(mv)
		legacy_extension.go#L29: 			t = reflect.TypeOf(mv.protoUnwrap())
		legacy_extension.go#L90: 	t := reflect.TypeOf(xi.ExtensionType)
		legacy_extension.go#L132: 	tt := reflect.TypeOf(xi.ExtensionType)
		legacy_message.go#L203: 						oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
		message.go#L117: 	sizecacheType       = reflect.TypeOf(SizeCache(0))
		message.go#L118: 	weakFieldsType      = reflect.TypeOf(WeakFields(nil))
		message.go#L119: 	unknownFieldsType   = reflect.TypeOf(UnknownFields(nil))
		message.go#L120: 	extensionFieldsType = reflect.TypeOf(ExtensionFields(nil))
		message.go#L194: 		tf := reflect.TypeOf(v).Elem()
		message_reflect.go#L310: 	if reflect.TypeOf(m) != mi.GoReflectType {

	google.golang.org/protobuf/types/descriptorpb
		descriptor.pb.go#L4024: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/protobuf/types/known/anypb
		any.pb.go#L479: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/protobuf/types/known/durationpb
		duration.pb.go#L364: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/protobuf/types/known/emptypb
		empty.pb.go#L153: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/protobuf/types/known/fieldmaskpb
		field_mask.pb.go#L573: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/protobuf/types/known/structpb
		struct.pb.go#L794: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/protobuf/types/known/timestamppb
		timestamp.pb.go#L366: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	google.golang.org/protobuf/types/known/wrapperspb
		wrappers.pb.go#L744: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	gopkg.in/yaml.v2
		decode.go#L239: 	mapItemType    = reflect.TypeOf(MapItem{})
		decode.go#L240: 	durationType   = reflect.TypeOf(time.Duration(0))
		decode.go#L241: 	defaultMapType = reflect.TypeOf(map[interface{}]interface{}{})
		decode.go#L243: 	timeType       = reflect.TypeOf(time.Time{})
		decode.go#L244: 	ptrTimeType    = reflect.TypeOf(&time.Time{})
		decode.go#L566: 		if out.Type().Elem() == reflect.TypeOf(resolved) {
		encode.go#L200: 		slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
		yaml.go#L362: 				if field.Type.Key() != reflect.TypeOf("") {

	html/template
		content.go#L119: 	if t := reflect.TypeOf(a); t.Kind() != reflect.Ptr {
		content.go#L131: 	errorType       = reflect.TypeOf((*error)(nil)).Elem()
		content.go#L132: 	fmtStringerType = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
		js.go#L121: var jsonMarshalType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()

	net/http
		client.go#L328: 	if reflect.TypeOf(rt).String() == "*http2.Transport" {
		transfer.go#L422: 	if reflect.TypeOf(t.Body) == nopCloserType {
		transfer.go#L1077: var nopCloserType = reflect.TypeOf(io.NopCloser(nil))
		transfer.go#L1087: 	if reflect.TypeOf(r) == nopCloserType {

	text/template
		exec.go#L665: 	errorType        = reflect.TypeOf((*error)(nil)).Elem()
		exec.go#L666: 	fmtStringerType  = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
		exec.go#L667: 	reflectValueType = reflect.TypeOf((*reflect.Value)(nil)).Elem()

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L254: var bigIntType = reflect.TypeOf((*big.Int)(nil)).Elem()
		asn1.go#L260: 	if reflect.TypeOf(out).Kind() != reflect.Ptr {
		asn1.go#L279: 		if reflect.TypeOf(out).Elem() == bigIntType {
		asn1.go#L606: 	if reflect.TypeOf(out).Kind() != reflect.Ptr {
		asn1.go#L620: 			if reflect.TypeOf(out).Elem() != bigIntType {
		asn1.go#L623: 			if reflect.TypeOf(defaultValue).Kind() != reflect.Ptr ||
		asn1.go#L624: 				reflect.TypeOf(defaultValue).Elem() != bigIntType {