func reflect.TypeOf

254 uses

	reflect (current package)
		type.go#L1424: func TypeOf(i any) Type {
		type.go#L2669: 			{Name: "S", Type: TypeOf(structType{})},
		type.go#L2670: 			{Name: "U", Type: TypeOf(uncommonType{})},
		type.go#L2671: 			{Name: "M", Type: ArrayOf(len(methods), TypeOf(methods[0]))},
		value.go#L1338: var uint8Type = TypeOf(uint8(0)).(*rtype)
		value.go#L1586: var stringType = TypeOf("").(*rtype)

	database/sql
		convert.go#L540: var valuerReflectType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
		sql.go#L3188: 			ci.scanType = reflect.TypeOf(new(any)).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/json
		decode.go#L173: 		return &InvalidUnmarshalError{reflect.TypeOf(v)}
		decode.go#L602: var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
		decode.go#L849: 		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
		decode.go#L854: 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-v2/aws
		credentials.go#L159: 	targetType := reflect.TypeOf(target)
		credentials.go#L164: 	providerType := reflect.TypeOf(provider)

	github.com/aws/smithy-go/middleware
		stack_values.go#L47: 	if !reflect.TypeOf(key).Comparable() {
		stack_values.go#L71: 			reflect.TypeOf(c.key).String() +

	github.com/go-pg/pg/v10/orm
		hook.go#L106: var beforeScanHookType = reflect.TypeOf((*BeforeScanHook)(nil)).Elem()
		hook.go#L118: var afterScanHookType = reflect.TypeOf((*AfterScanHook)(nil)).Elem()
		hook.go#L130: var afterSelectHookType = reflect.TypeOf((*AfterSelectHook)(nil)).Elem()
		hook.go#L148: var beforeInsertHookType = reflect.TypeOf((*BeforeInsertHook)(nil)).Elem()
		hook.go#L166: var afterInsertHookType = reflect.TypeOf((*AfterInsertHook)(nil)).Elem()
		hook.go#L184: var beforeUpdateHookType = reflect.TypeOf((*BeforeUpdateHook)(nil)).Elem()
		hook.go#L202: var afterUpdateHookType = reflect.TypeOf((*AfterUpdateHook)(nil)).Elem()
		hook.go#L220: var beforeDeleteHookType = reflect.TypeOf((*BeforeDeleteHook)(nil)).Elem()
		hook.go#L238: var afterDeleteHookType = reflect.TypeOf((*AfterDeleteHook)(nil)).Elem()
		model_func.go#L8: var errorType = reflect.TypeOf((*error)(nil)).Elem()
		table.go#L39: 	timeType           = reflect.TypeOf((*time.Time)(nil)).Elem()
		table.go#L40: 	nullTimeType       = reflect.TypeOf((*types.NullTime)(nil)).Elem()
		table.go#L41: 	sqlNullTimeType    = reflect.TypeOf((*sql.NullTime)(nil)).Elem()
		table.go#L42: 	ipType             = reflect.TypeOf((*net.IP)(nil)).Elem()
		table.go#L43: 	ipNetType          = reflect.TypeOf((*net.IPNet)(nil)).Elem()
		table.go#L44: 	scannerType        = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
		table.go#L45: 	nullBoolType       = reflect.TypeOf((*sql.NullBool)(nil)).Elem()
		table.go#L46: 	nullFloatType      = reflect.TypeOf((*sql.NullFloat64)(nil)).Elem()
		table.go#L47: 	nullIntType        = reflect.TypeOf((*sql.NullInt64)(nil)).Elem()
		table.go#L48: 	nullStringType     = reflect.TypeOf((*sql.NullString)(nil)).Elem()
		table.go#L49: 	jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
		tables.go#L70: 	typ := reflect.TypeOf(strct)

	github.com/go-pg/pg/v10/types
		append_value.go#L19: 	driverValuerType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
		append_value.go#L20: 	appenderType     = reflect.TypeOf((*ValueAppender)(nil)).Elem()
		append_value.go#L65: 	registerAppender(reflect.TypeOf(value), fn)
		array_append.go#L10: 	stringType      = reflect.TypeOf((*string)(nil)).Elem()
		array_append.go#L11: 	sliceStringType = reflect.TypeOf([]string(nil))
		array_append.go#L13: 	intType      = reflect.TypeOf((*int)(nil)).Elem()
		array_append.go#L14: 	sliceIntType = reflect.TypeOf([]int(nil))
		array_append.go#L16: 	int64Type      = reflect.TypeOf((*int64)(nil)).Elem()
		array_append.go#L17: 	sliceInt64Type = reflect.TypeOf([]int64(nil))
		array_append.go#L19: 	float64Type      = reflect.TypeOf((*float64)(nil)).Elem()
		array_append.go#L20: 	sliceFloat64Type = reflect.TypeOf([]float64(nil))
		array_scan.go#L11: var arrayValueScannerType = reflect.TypeOf((*ArrayValueScanner)(nil)).Elem()
		hstore_append.go#L8: var mapStringStringType = reflect.TypeOf(map[string]string(nil))
		scan_value.go#L18: 	valueScannerType   = reflect.TypeOf((*ValueScanner)(nil)).Elem()
		scan_value.go#L19: 	sqlScannerType     = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
		scan_value.go#L20: 	timeType           = reflect.TypeOf((*time.Time)(nil)).Elem()
		scan_value.go#L21: 	ipType             = reflect.TypeOf((*net.IP)(nil)).Elem()
		scan_value.go#L22: 	ipNetType          = reflect.TypeOf((*net.IPNet)(nil)).Elem()
		scan_value.go#L23: 	jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
		scan_value.go#L68: 	registerScanner(reflect.TypeOf(value), fn)

	github.com/go-pg/zerochecker
		zerochecker.go#L8: var driverValuerType = reflect.TypeOf((*driver.Valuer)(nil)).Elem()
		zerochecker.go#L9: var appenderType = reflect.TypeOf((*valueAppender)(nil)).Elem()
		zerochecker.go#L10: var isZeroerType = reflect.TypeOf((*isZeroer)(nil)).Elem()

	github.com/golang/mock/gomock
		call.go#L183: 		if got, want := reflect.TypeOf(ret), mt.Out(i); got == want {
		call.go#L238: 		if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) {
		call.go#L253: 		switch reflect.TypeOf(args[n]).Kind() {
		matchers.go#L164: 	return reflect.TypeOf(x).AssignableTo(m.targetType)
		matchers.go#L331: 	return assignableToTypeOfMatcher{reflect.TypeOf(x)}

	github.com/golang/protobuf/proto
		extensions.go#L230: 	if reflect.TypeOf(v) != reflect.TypeOf(xt.ExtensionType) {
		registry.go#L184: 	messageTypeCache.Store(s, reflect.TypeOf(m))
		registry.go#L192: 	t := reflect.TypeOf(m)
		registry.go#L242: 		return reflect.TypeOf(protoreflect.EnumNumber(0))
		registry.go#L247: 		return reflect.TypeOf((*protoreflect.Message)(nil)).Elem()
		registry.go#L249: 		return reflect.TypeOf(fd.Default().Interface())
		registry.go#L254: 	return reflect.TypeOf(et.New(0))
		registry.go#L258: 	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/timestamp
		timestamp.pb.go#L50: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	github.com/google/go-cmp/cmp
		options.go#L425: 		t := reflect.TypeOf(typ)
		report_reflect.go#L20: 	anyType    = reflect.TypeOf((*interface{})(nil)).Elem()
		report_reflect.go#L21: 	stringType = reflect.TypeOf((*string)(nil)).Elem()
		report_reflect.go#L22: 	bytesType  = reflect.TypeOf((*[]byte)(nil)).Elem()
		report_reflect.go#L23: 	byteType   = reflect.TypeOf((*byte)(nil)).Elem()

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

	github.com/google/go-cmp/cmp/internal/value
		name.go#L12: var anyType = reflect.TypeOf((*interface{})(nil)).Elem()

	github.com/vmihailenco/msgpack/v5
		decode_map.go#L14: 	mapStringStringPtrType = reflect.TypeOf((*map[string]string)(nil))
		decode_map.go#L19: 	mapStringInterfacePtrType = reflect.TypeOf((*map[string]interface{})(nil))
		decode_map.go#L217: 	keyType := reflect.TypeOf(key)
		decode_map.go#L218: 	valueType := reflect.TypeOf(value)
		decode_slice.go#L10: var sliceStringPtrType = reflect.TypeOf((*[]string)(nil))
		decode_value.go#L11: 	interfaceType = reflect.TypeOf((*interface{})(nil)).Elem()
		decode_value.go#L12: 	stringType    = reflect.TypeOf((*string)(nil)).Elem()
		encode_slice.go#L10: var stringSliceType = reflect.TypeOf(([]string)(nil))
		ext.go#L49: 	typ := reflect.TypeOf(value)
		ext.go#L112: 	typ := reflect.TypeOf(value)
		types.go#L13: var errorType = reflect.TypeOf((*error)(nil)).Elem()
		types.go#L16: 	customEncoderType = reflect.TypeOf((*CustomEncoder)(nil)).Elem()
		types.go#L17: 	customDecoderType = reflect.TypeOf((*CustomDecoder)(nil)).Elem()
		types.go#L21: 	marshalerType   = reflect.TypeOf((*Marshaler)(nil)).Elem()
		types.go#L22: 	unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
		types.go#L26: 	binaryMarshalerType   = reflect.TypeOf((*encoding.BinaryMarshaler)(nil)).Elem()
		types.go#L27: 	binaryUnmarshalerType = reflect.TypeOf((*encoding.BinaryUnmarshaler)(nil)).Elem()
		types.go#L31: 	textMarshalerType   = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
		types.go#L32: 	textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
		types.go#L49: 	typ := reflect.TypeOf(value)

	go.pact.im/x/clock/mockclock
		mockclock.go#L48: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Now", reflect.TypeOf((*MockClock)(nil).Now))
		mockclock.go#L62: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Schedule", reflect.TypeOf((*MockClock)(nil).Schedule), d, f)
		mockclock.go#L76: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ticker", reflect.TypeOf((*MockClock)(nil).Ticker), d)
		mockclock.go#L90: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Timer", reflect.TypeOf((*MockClock)(nil).Timer), d)
		mockclock.go#L102: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "private", reflect.TypeOf((*MockClock)(nil).private))
		ticker.go#L47: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "C", reflect.TypeOf((*MockTicker)(nil).C))
		ticker.go#L59: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTicker)(nil).Reset), arg0)
		ticker.go#L71: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockTicker)(nil).Stop))
		timer.go#L47: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "C", reflect.TypeOf((*MockTimer)(nil).C))
		timer.go#L59: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockTimer)(nil).Reset), arg0)
		timer.go#L73: 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockTimer)(nil).Stop))

	golang.org/x/exp/apidiff
		compatibility.go#L266: 	if reflect.TypeOf(old.Underlying()) != reflect.TypeOf(new.Underlying()) {

	golang.org/x/tools/internal/gcimporter
		iexport.go#L826: 		panic(internalErrorf("unexpected type: %v, %v", t, reflect.TypeOf(t)))

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

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

	google.golang.org/grpc/binarylog/grpc_binarylog_v1
		binarylog.pb.go#L1167: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

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

	google.golang.org/protobuf/internal/filetype
		build.go#L149: 				GoReflectType: reflect.TypeOf(enumGoTypes[i]),
		build.go#L170: 			tb.MessageInfos[i].GoReflectType = reflect.TypeOf(messageGoTypes[i])
		build.go#L220: 			goType = reflect.TypeOf(tb.GoTypes[j])
		build.go#L224: 			goType = reflect.TypeOf(tb.GoTypes[j])
		build.go#L245: 	protoreflect.BoolKind:     reflect.TypeOf(bool(false)),
		build.go#L246: 	protoreflect.Int32Kind:    reflect.TypeOf(int32(0)),
		build.go#L247: 	protoreflect.Sint32Kind:   reflect.TypeOf(int32(0)),
		build.go#L248: 	protoreflect.Sfixed32Kind: reflect.TypeOf(int32(0)),
		build.go#L249: 	protoreflect.Int64Kind:    reflect.TypeOf(int64(0)),
		build.go#L250: 	protoreflect.Sint64Kind:   reflect.TypeOf(int64(0)),
		build.go#L251: 	protoreflect.Sfixed64Kind: reflect.TypeOf(int64(0)),
		build.go#L252: 	protoreflect.Uint32Kind:   reflect.TypeOf(uint32(0)),
		build.go#L253: 	protoreflect.Fixed32Kind:  reflect.TypeOf(uint32(0)),
		build.go#L254: 	protoreflect.Uint64Kind:   reflect.TypeOf(uint64(0)),
		build.go#L255: 	protoreflect.Fixed64Kind:  reflect.TypeOf(uint64(0)),
		build.go#L256: 	protoreflect.FloatKind:    reflect.TypeOf(float32(0)),
		build.go#L257: 	protoreflect.DoubleKind:   reflect.TypeOf(float64(0)),
		build.go#L258: 	protoreflect.StringKind:   reflect.TypeOf(string("")),
		build.go#L259: 	protoreflect.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 legacyLoadMessageType(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 legacyLoadMessageType(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#L214: 						oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
		message.go#L119: 	sizecacheType       = reflect.TypeOf(SizeCache(0))
		message.go#L120: 	weakFieldsType      = reflect.TypeOf(WeakFields(nil))
		message.go#L121: 	unknownFieldsAType  = reflect.TypeOf(unknownFieldsA(nil))
		message.go#L122: 	unknownFieldsBType  = reflect.TypeOf(unknownFieldsB(nil))
		message.go#L123: 	extensionFieldsType = reflect.TypeOf(ExtensionFields(nil))
		message.go#L205: 		tf := reflect.TypeOf(v).Elem()
		message_reflect.go#L398: 	if reflect.TypeOf(m) != mi.GoReflectType {

	google.golang.org/protobuf/proto
		equal.go#L36: 	if reflect.TypeOf(x).Kind() == reflect.Ptr && x == y {

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

	google.golang.org/protobuf/types/known/anypb
		any.pb.go#L483: 			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/timestamppb
		timestamp.pb.go#L375: 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),

	gotest.tools/v3/assert/cmp
		compare.go#L324: 		expectedType := reflect.TypeOf(expected)
		compare.go#L379: 	stdlibErrorNewType = reflect.TypeOf(errors.New(""))
		compare.go#L380: 	stdlibFmtErrorType = reflect.TypeOf(fmt.Errorf("%w", fmt.Errorf("")))
		result.go#L96: 			r := reflect.TypeOf(typ)

	html/template
		content.go#L119: 	if t := reflect.TypeOf(a); t.Kind() != reflect.Pointer {
		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#L329: 	if reflect.TypeOf(rt).String() == "*http2.Transport" {
		transfer.go#L424: 	if reflect.TypeOf(t.Body) == nopCloserType {
		transfer.go#L1082: var nopCloserType = reflect.TypeOf(io.NopCloser(nil))
		transfer.go#L1092: 	if reflect.TypeOf(r) == nopCloserType {

	testing
		fuzz.go#L156: 		if t := reflect.TypeOf(args[i]); !supportedTypes[t] {
		fuzz.go#L166: 	reflect.TypeOf(([]byte)("")):  true,
		fuzz.go#L167: 	reflect.TypeOf((string)("")):  true,
		fuzz.go#L168: 	reflect.TypeOf((bool)(false)): true,
		fuzz.go#L169: 	reflect.TypeOf((byte)(0)):     true,
		fuzz.go#L170: 	reflect.TypeOf((rune)(0)):     true,
		fuzz.go#L171: 	reflect.TypeOf((float32)(0)):  true,
		fuzz.go#L172: 	reflect.TypeOf((float64)(0)):  true,
		fuzz.go#L173: 	reflect.TypeOf((int)(0)):      true,
		fuzz.go#L174: 	reflect.TypeOf((int8)(0)):     true,
		fuzz.go#L175: 	reflect.TypeOf((int16)(0)):    true,
		fuzz.go#L176: 	reflect.TypeOf((int32)(0)):    true,
		fuzz.go#L177: 	reflect.TypeOf((int64)(0)):    true,
		fuzz.go#L178: 	reflect.TypeOf((uint)(0)):     true,
		fuzz.go#L179: 	reflect.TypeOf((uint8)(0)):    true,
		fuzz.go#L180: 	reflect.TypeOf((uint16)(0)):   true,
		fuzz.go#L181: 	reflect.TypeOf((uint32)(0)):   true,
		fuzz.go#L182: 	reflect.TypeOf((uint64)(0)):   true,
		fuzz.go#L227: 	if fnType.NumIn() < 2 || fnType.In(0) != reflect.TypeOf((*T)(nil)) {

	text/template
		exec.go#L689: 	errorType        = reflect.TypeOf((*error)(nil)).Elem()
		exec.go#L690: 	fmtStringerType  = reflect.TypeOf((*fmt.Stringer)(nil)).Elem()
		exec.go#L691: 	reflectValueType = reflect.TypeOf((*reflect.Value)(nil)).Elem()

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L267: var bigIntType = reflect.TypeOf((*big.Int)(nil)).Elem()
		asn1.go#L273: 	if reflect.TypeOf(out).Kind() != reflect.Ptr {
		asn1.go#L292: 		if reflect.TypeOf(out).Elem() == bigIntType {
		asn1.go#L663: 	if reflect.TypeOf(out).Kind() != reflect.Ptr {
		asn1.go#L677: 			if reflect.TypeOf(out).Elem() != bigIntType {
		asn1.go#L680: 			if reflect.TypeOf(defaultValue).Kind() != reflect.Ptr ||
		asn1.go#L681: 				reflect.TypeOf(defaultValue).Elem() != bigIntType {

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)