func reflect.ValueOf

394 uses

	reflect (current package)
		deepequal.go#L213: 	v1 := ValueOf(x)
		deepequal.go#L214: 	v2 := ValueOf(y)
		swapper.go#L17: 	v := ValueOf(slice)
		value.go#L2351: func ValueOf(i interface{}) Value {

	cloud.google.com/go/storage
		acl.go#L231: 	vc := reflect.ValueOf(call)
		acl.go#L232: 	vc.MethodByName("Context").Call([]reflect.Value{reflect.ValueOf(ctx)})
		acl.go#L234: 		vc.MethodByName("UserProject").Call([]reflect.Value{reflect.ValueOf(a.userProject)})
		bucket.go#L873: 	cval := reflect.ValueOf(call)
		storage.go#L59: 	errMethodNotValid = fmt.Errorf("storage: HTTP method should be one of %v", reflect.ValueOf(signedURLMethods).MapKeys())
		storage.go#L1444: 	cval := reflect.ValueOf(call)
		storage.go#L1518: 	m.Call([]reflect.Value{reflect.ValueOf(value)})

	crypto/x509
		verify.go#L530: 	excludedValue := reflect.ValueOf(excluded)
		verify.go#L549: 	permittedValue := reflect.ValueOf(permitted)

	database/sql
		convert.go#L352: 		sv = reflect.ValueOf(src)
		convert.go#L362: 		sv = reflect.ValueOf(src)
		convert.go#L368: 		sv = reflect.ValueOf(src)
		convert.go#L388: 	dpv := reflect.ValueOf(dest)
		convert.go#L397: 		sv = reflect.ValueOf(src)
		convert.go#L404: 			dv.Set(reflect.ValueOf(cloneBytes(b)))
		convert.go#L505: 	rv := reflect.ValueOf(src)
		convert.go#L554: 	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&

	database/sql/driver
		types.go#L81: 	sv := reflect.ValueOf(src)
		types.go#L109: 	rv := reflect.ValueOf(v)
		types.go#L228: 	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&
		types.go#L257: 	rv := reflect.ValueOf(v)

	encoding/asn1
		asn1.go#L735: 			v.Set(reflect.ValueOf(result))
		asn1.go#L926: 			val.Field(0).Set(reflect.ValueOf(RawContent(bytes)))
		asn1.go#L948: 			reflect.Copy(val, reflect.ValueOf(innerBytes))
		asn1.go#L1113: 	v := reflect.ValueOf(val)
		marshal.go#L740: 	e, err := makeField(reflect.ValueOf(val), parseFieldParameters(params))

	encoding/binary
		binary.go#L243: 	v := reflect.ValueOf(data)
		binary.go#L380: 	v := reflect.Indirect(reflect.ValueOf(data))
		binary.go#L396: 	return dataSize(reflect.Indirect(reflect.ValueOf(v)))

	encoding/gob
		decoder.go#L67: 	dec.decodeValue(tWireType, reflect.ValueOf(wire))
		decoder.go#L181: 	value := reflect.ValueOf(e)
		encoder.go#L106: 	enc.encode(state.b, reflect.ValueOf(info.wire), wireTypeUserInfo)
		encoder.go#L176: 	return enc.EncodeValue(reflect.ValueOf(e))

	encoding/json
		decode.go#L171: 	rv := reflect.ValueOf(v)
		decode.go#L518: 			v.Set(reflect.ValueOf(ai))
		decode.go#L622: 		v.Set(reflect.ValueOf(oi))
		decode.go#L783: 				kv = reflect.ValueOf(key).Convert(kt)
		decode.go#L793: 					kv = reflect.ValueOf(n).Convert(kt)
		decode.go#L801: 					kv = reflect.ValueOf(n).Convert(kt)
		decode.go#L922: 				v.Set(reflect.ValueOf(value))
		decode.go#L958: 				v.Set(reflect.ValueOf(string(s)))
		decode.go#L994: 			v.Set(reflect.ValueOf(n))
		encode.go#L332: 	e.reflectValue(reflect.ValueOf(v), opts)

	encoding/xml
		marshal.go#L162: 	err := enc.p.marshalValue(reflect.ValueOf(v), nil, nil)
		marshal.go#L177: 	err := enc.p.marshalValue(reflect.ValueOf(v), nil, &start)
		marshal.go#L776: 			reflect.Copy(reflect.ValueOf(bytes), val)
		read.go#L147: 	val := reflect.ValueOf(v)
		read.go#L293: 		val.Set(reflect.ValueOf(attr))
		read.go#L413: 			v.Set(reflect.ValueOf(start.Name))
		read.go#L440: 				fv.Set(reflect.ValueOf(start.Name))
		read.go#L587: 		t.Set(reflect.ValueOf(comment))
		read.go#L595: 			t.Set(reflect.ValueOf(saveXMLData))

	fmt
		print.go#L494: 		p.printValue(reflect.ValueOf(v), verb, 0)
		print.go#L541: 		if v := reflect.ValueOf(arg); v.Kind() == reflect.Ptr && v.IsNil() {
		print.go#L655: 		p.fmtPointer(reflect.ValueOf(arg), 'p')
		print.go#L712: 			p.printValue(reflect.ValueOf(f), verb, 0)
		print.go#L895: 			switch v := reflect.ValueOf(a[argNum]); v.Kind() {
		scan.go#L1018: 		val := reflect.ValueOf(v)

	github.com/aws/aws-sdk-go/aws/awsutil
		copy.go#L16: 	dstval := reflect.ValueOf(dst)
		copy.go#L21: 	rcopy(dstval, reflect.ValueOf(src), true)
		copy.go#L29: 	rcopy(dsti, reflect.ValueOf(src), true)
		equal.go#L14: 	ra := reflect.Indirect(reflect.ValueOf(a))
		equal.go#L15: 	rb := reflect.Indirect(reflect.ValueOf(b))
		path_value.go#L28: 	values := []reflect.Value{reflect.Indirect(reflect.ValueOf(v))}
		path_value.go#L97: 					value = reflect.ValueOf(nil)
		path_value.go#L140: 						value = reflect.ValueOf(nil)
		path_value.go#L164: 	v := reflect.ValueOf(result)
		path_value.go#L201: 	srcVal := reflect.ValueOf(src)
		path_value.go#L214: 			srcVal = reflect.ValueOf(src).Elem()
		prettify.go#L14: 	prettify(reflect.ValueOf(i), 0, &buf)
		string_value.go#L13: 	stringValue(reflect.ValueOf(i), 0, &buf)

	github.com/aws/aws-sdk-go/aws/request
		request.go#L262: 	return r.Params != nil && reflect.ValueOf(r.Params).Elem().IsValid()
		request.go#L269: 	return r.Data != nil && reflect.ValueOf(r.Data).Elem().IsValid()

	github.com/aws/aws-sdk-go/private/protocol
		idempotency.go#L63: 	v.Set(reflect.ValueOf(UUIDVersion4(b)))

	github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
		build.go#L19: var timeType = reflect.ValueOf(time.Time{}).Type()
		build.go#L20: var byteSliceType = reflect.ValueOf([]byte{}).Type()
		build.go#L26: 	err := buildAny(reflect.ValueOf(v), &buf, "")
		build.go#L118: 			member = reflect.ValueOf(&token)
		unmarshal.go#L54: 	return unmarshaler{}.unmarshalAny(reflect.ValueOf(v), out, "")
		unmarshal.go#L73: 	}.unmarshalAny(reflect.ValueOf(v), out, "")
		unmarshal.go#L218: 		kvalue := reflect.ValueOf(k)
		unmarshal.go#L236: 			value.Set(reflect.ValueOf(&d))
		unmarshal.go#L242: 			value.Set(reflect.ValueOf(b))
		unmarshal.go#L253: 			value.Set(reflect.ValueOf(&t))
		unmarshal.go#L260: 			value.Set(reflect.ValueOf(v))
		unmarshal.go#L274: 			value.Set(reflect.ValueOf(&di))
		unmarshal.go#L280: 			value.Set(reflect.ValueOf(&f))
		unmarshal.go#L289: 			value.Set(reflect.ValueOf(&t))
		unmarshal.go#L296: 			value.Set(reflect.ValueOf(&d))

	github.com/aws/aws-sdk-go/private/protocol/query/queryutil
		queryutil.go#L20: 	return q.parseValue(body, reflect.ValueOf(i), "", "")
		queryutil.go#L85: 			elemValue = reflect.ValueOf(token)

	github.com/aws/aws-sdk-go/private/protocol/rest
		build.go#L49: 		v := reflect.ValueOf(r.Params).Elem()
		build.go#L59: 		v := reflect.ValueOf(r.Params).Elem()
		payload.go#L11: 	v := reflect.ValueOf(i).Elem()
		payload.go#L33: 	v := reflect.Indirect(reflect.ValueOf(i))
		unmarshal.go#L31: 		v := reflect.Indirect(reflect.ValueOf(r.Data))
		unmarshal.go#L56: 	v := reflect.Indirect(reflect.ValueOf(data))
		unmarshal.go#L75: 						payload.Set(reflect.ValueOf(b))
		unmarshal.go#L85: 						payload.Set(reflect.ValueOf(&str))
		unmarshal.go#L90: 							payload.Set(reflect.ValueOf(r.HTTPResponse.Body))
		unmarshal.go#L98: 							payload.Set(reflect.ValueOf(ioutil.NopCloser(bytes.NewReader(b))))
		unmarshal.go#L160: 		v.Set(reflect.ValueOf(&s))
		unmarshal.go#L182: 			r.Set(reflect.ValueOf(out))
		unmarshal.go#L207: 		v.Set(reflect.ValueOf(&header))
		unmarshal.go#L213: 		v.Set(reflect.ValueOf(b))
		unmarshal.go#L219: 		v.Set(reflect.ValueOf(&b))
		unmarshal.go#L225: 		v.Set(reflect.ValueOf(&i))
		unmarshal.go#L231: 		v.Set(reflect.ValueOf(&f))
		unmarshal.go#L241: 		v.Set(reflect.ValueOf(&t))
		unmarshal.go#L251: 		v.Set(reflect.ValueOf(m))

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		build.go#L26: 	if err := b.buildValue(reflect.ValueOf(params), root, ""); err != nil {
		build.go#L156: 			member = reflect.ValueOf(token)
		build.go#L247: 		v := value.MapIndex(reflect.ValueOf(k))
		unmarshal.go#L50: 				err = parse(reflect.ValueOf(v), c, "")
		unmarshal.go#L239: 			keyR := reflect.ValueOf(key.Text)
		unmarshal.go#L258: 		r.Set(reflect.ValueOf(&node.Text))
		unmarshal.go#L265: 		r.Set(reflect.ValueOf(b))
		unmarshal.go#L271: 		r.Set(reflect.ValueOf(&v))
		unmarshal.go#L277: 		r.Set(reflect.ValueOf(&v))
		unmarshal.go#L283: 		r.Set(reflect.ValueOf(&v))
		unmarshal.go#L294: 		r.Set(reflect.ValueOf(&t))

	github.com/ghodss/yaml
		yaml.go#L31: 	vo := reflect.ValueOf(o)

	github.com/go-git/gcfg
		set.go#L80: 		reflect.ValueOf(d).Elem().Set(reflect.ValueOf(true))
		set.go#L85: 		reflect.ValueOf(d).Elem().Set(reflect.ValueOf(b))
		set.go#L171: 	t := reflect.ValueOf(d).Type().Elem()
		set.go#L180: 	k := reflect.ValueOf(d).Type().Elem().Kind()
		set.go#L219: 	vPCfg := reflect.ValueOf(cfg)
		set.go#L244: 		k := reflect.ValueOf(sub)

	github.com/go-git/gcfg/types
		scan.go#L11: 	t := reflect.ValueOf(ptr).Elem().Type()

	github.com/go-git/go-git/v5/plumbing/transport/ssh
		common.go#L217: 	vc := reflect.ValueOf(c).Elem()
		common.go#L218: 	vo := reflect.ValueOf(overrides).Elem()

	github.com/go-redis/redis/v8/internal/proto
		scan.go#L111: 	v := reflect.ValueOf(slice)

	github.com/golang/protobuf/proto
		extensions.go#L172: 	rv := reflect.ValueOf(v)
		extensions.go#L229: 	rv := reflect.ValueOf(v)
		properties.go#L278: 				Type: reflect.ValueOf(wrapper).Type(), // *T

	github.com/google/go-cmp/cmp
		compare.go#L139: 	vx := reflect.ValueOf(x)
		compare.go#L140: 	vy := reflect.ValueOf(y)
		export_unsafe.go#L32: 		return reflect.ValueOf(ve.Interface()).Convert(f.Type)
		options.go#L140: 	return fmt.Sprintf("FilterPath(%s, %v)", function.NameOf(reflect.ValueOf(f.fnc)), f.opt)
		options.go#L158: 	v := reflect.ValueOf(f)
		options.go#L276: 	v := reflect.ValueOf(f)
		options.go#L288: 	tr := &transformer{name: name, fnc: reflect.ValueOf(f)}
		options.go#L343: 	v := reflect.ValueOf(f)
		report_slices.go#L128: 			reflect.ValueOf(ssx), reflect.ValueOf(ssy), 1, "line",
		report_slices.go#L217: 			reflect.ValueOf(sx), reflect.ValueOf(sy), 64, "byte",
		report_slices.go#L230: 			reflect.ValueOf(sx), reflect.ValueOf(sy), 16, "byte",
		report_value.go#L59: 		parent.Records = append(parent.Records, reportRecord{Key: reflect.ValueOf(s.Name()), Value: child})

	github.com/google/go-cmp/cmp/cmpopts
		equate.go#L28: 	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
		ignore.go#L156: 	vf := reflect.ValueOf(discardFunc)
		ignore.go#L184: 	vf := reflect.ValueOf(discardFunc)
		sort.go#L30: 	vf := reflect.ValueOf(lessFunc)
		sort.go#L44: 	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
		sort.go#L57: 	src := reflect.ValueOf(x)
		sort.go#L101: 	vf := reflect.ValueOf(lessFunc)
		sort.go#L115: 	vx, vy := reflect.ValueOf(x), reflect.ValueOf(y)
		sort.go#L121: 	src := reflect.ValueOf(x)

	github.com/google/go-cmp/cmp/internal/value
		sort.go#L101: 		return reflect.ValueOf(vx.Type()).Pointer() < reflect.ValueOf(vy.Type()).Pointer()

	github.com/google/safehtml/internal/safehtmlutil
		safehtmlutil.go#L158: 	v := reflect.ValueOf(a)
		safehtmlutil.go#L175: 	v := reflect.ValueOf(a)

	github.com/google/safehtml/template
		escape.go#L812: 	v := reflect.ValueOf(a)

	github.com/imdario/mergo
		map.go#L61: 			if v, ok := dstMap[fieldName]; !ok || (isEmptyValue(reflect.ValueOf(v)) || overwrite) {
		map.go#L83: 			srcElement := reflect.ValueOf(srcValue)
		map.go#L93: 					srcElement = reflect.ValueOf(srcPtr)
		merge.go#L149: 				dstElement = reflect.ValueOf(k)
		merge.go#L162: 				srcElement = reflect.ValueOf(srcElement.Interface())
		merge.go#L164: 					dstElement = reflect.ValueOf(dstElement.Interface())
		mergo.go#L66: 	vDst = reflect.ValueOf(dst).Elem()
		mergo.go#L71: 	vSrc = reflect.ValueOf(src)

	github.com/jackc/pgtype
		aclitem_array.go#L88: 		reflectedValue := reflect.ValueOf(src)
		aclitem_array.go#L225: 		value := reflect.ValueOf(dst)
		array_type.go#L59: 	sliceVal := reflect.ValueOf(src)
		array_type.go#L101: 	ptrSlice := reflect.ValueOf(dst)
		bool_array.go#L91: 		reflectedValue := reflect.ValueOf(src)
		bool_array.go#L228: 		value := reflect.ValueOf(dst)
		bpchar_array.go#L91: 		reflectedValue := reflect.ValueOf(src)
		bpchar_array.go#L228: 		value := reflect.ValueOf(dst)
		bytea_array.go#L72: 		reflectedValue := reflect.ValueOf(src)
		bytea_array.go#L200: 		value := reflect.ValueOf(dst)
		cidr_array.go#L111: 		reflectedValue := reflect.ValueOf(src)
		cidr_array.go#L257: 		value := reflect.ValueOf(dst)
		composite_type.go#L183: 	dstValue := reflect.ValueOf(dst)
		convert.go#L17: 	refVal := reflect.ValueOf(val)
		convert.go#L72: 	refVal := reflect.ValueOf(val)
		convert.go#L91: 	refVal := reflect.ValueOf(val)
		convert.go#L112: 	refVal := reflect.ValueOf(val)
		convert.go#L131: 	refVal := reflect.ValueOf(val)
		convert.go#L147: 	refVal := reflect.ValueOf(val)
		convert.go#L168: 	refVal := reflect.ValueOf(val)
		convert.go#L189: 	refVal := reflect.ValueOf(val)
		convert.go#L283: 			if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L316: 	if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L335: 			if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L358: 	if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
		convert.go#L370: 	dstPtr := reflect.ValueOf(dst)
		convert.go#L398: 	dstPtr := reflect.ValueOf(dst)
		date_array.go#L92: 		reflectedValue := reflect.ValueOf(src)
		date_array.go#L229: 		value := reflect.ValueOf(dst)
		enum_array.go#L88: 		reflectedValue := reflect.ValueOf(src)
		enum_array.go#L225: 		value := reflect.ValueOf(dst)
		float4_array.go#L91: 		reflectedValue := reflect.ValueOf(src)
		float4_array.go#L228: 		value := reflect.ValueOf(dst)
		float8_array.go#L91: 		reflectedValue := reflect.ValueOf(src)
		float8_array.go#L228: 		value := reflect.ValueOf(dst)
		hstore_array.go#L72: 		reflectedValue := reflect.ValueOf(src)
		hstore_array.go#L200: 		value := reflect.ValueOf(dst)
		inet_array.go#L111: 		reflectedValue := reflect.ValueOf(src)
		inet_array.go#L257: 		value := reflect.ValueOf(dst)
		int2_array.go#L357: 		reflectedValue := reflect.ValueOf(src)
		int2_array.go#L620: 		value := reflect.ValueOf(dst)
		int4_array.go#L357: 		reflectedValue := reflect.ValueOf(src)
		int4_array.go#L620: 		value := reflect.ValueOf(dst)
		int8_array.go#L357: 		reflectedValue := reflect.ValueOf(src)
		int8_array.go#L620: 		value := reflect.ValueOf(dst)
		jsonb_array.go#L91: 		reflectedValue := reflect.ValueOf(src)
		jsonb_array.go#L228: 		value := reflect.ValueOf(dst)
		macaddr_array.go#L92: 		reflectedValue := reflect.ValueOf(src)
		macaddr_array.go#L229: 		value := reflect.ValueOf(dst)
		numeric_array.go#L205: 		reflectedValue := reflect.ValueOf(src)
		numeric_array.go#L396: 		value := reflect.ValueOf(dst)
		pgtype.go#L365: 			value = reflect.New(reflect.ValueOf(t).Elem().Type()).Interface().(Value)
		pgtype.go#L433: 			ci.reflectTypeToDataType[reflect.ValueOf(dt.Value).Type()] = dt
		pgtype.go#L602: 	refVal := reflect.ValueOf(dst)
		pgtype.go#L863: 		return reflect.New(reflect.ValueOf(v).Elem().Type()).Interface().(Value)
		record.go#L93: 	binaryDecoder = reflect.New(reflect.ValueOf(binaryDecoder).Elem().Type()).Interface().(BinaryDecoder)
		text_array.go#L91: 		reflectedValue := reflect.ValueOf(src)
		text_array.go#L228: 		value := reflect.ValueOf(dst)
		timestamp_array.go#L92: 		reflectedValue := reflect.ValueOf(src)
		timestamp_array.go#L229: 		value := reflect.ValueOf(dst)
		timestamptz_array.go#L92: 		reflectedValue := reflect.ValueOf(src)
		timestamptz_array.go#L229: 		value := reflect.ValueOf(dst)
		tsrange_array.go#L53: 		reflectedValue := reflect.ValueOf(src)
		tsrange_array.go#L181: 		value := reflect.ValueOf(dst)
		tstzrange_array.go#L53: 		reflectedValue := reflect.ValueOf(src)
		tstzrange_array.go#L181: 		value := reflect.ValueOf(dst)
		uuid_array.go#L129: 		reflectedValue := reflect.ValueOf(src)
		uuid_array.go#L284: 		value := reflect.ValueOf(dst)
		varchar_array.go#L91: 		reflectedValue := reflect.ValueOf(src)
		varchar_array.go#L228: 		value := reflect.ValueOf(dst)

	github.com/jackc/pgx/v4
		extended_query_builder.go#L70: 	refVal := reflect.ValueOf(arg)
		go_stdlib.go#L55: 	if rv := reflect.ValueOf(vr); rv.Kind() == reflect.Ptr &&
		values.go#L32: 	refVal := reflect.ValueOf(arg)
		values.go#L178: 	refVal := reflect.ValueOf(arg)

	github.com/jmespath/go-jmespath
		functions.go#L414: 		v := reflect.ValueOf(arg)
		interpreter.go#L135: 				v := reflect.ValueOf(element)
		interpreter.go#L159: 		rv := reflect.ValueOf(value)
		interpreter.go#L318: 	rv := reflect.ValueOf(value)
		interpreter.go#L343: 	v := reflect.ValueOf(value)
		interpreter.go#L351: 			elementV := reflect.ValueOf(element)
		interpreter.go#L364: 	v := reflect.ValueOf(value)
		interpreter.go#L384: 	v := reflect.ValueOf(value)
		interpreter.go#L406: 	v := reflect.ValueOf(value)
		util.go#L27: 	rv := reflect.ValueOf(value)

	github.com/lann/builder
		builder.go#L24: 	emptyBuilderValue = reflect.ValueOf(EmptyBuilder)
		builder.go#L93: 		val := reflect.ValueOf(list.Head())
		builder.go#L218: 				value = reflect.ValueOf(val)
		reflect.go#L7: 		ValueOf(from).
		reflect.go#L13: 	val := reflect.ValueOf(s)

	github.com/lib/pq
		array.go#L311: 	dpv := reflect.ValueOf(a.A)
		array.go#L401: 	rv := reflect.ValueOf(a.A)

	github.com/Masterminds/squirrel
		expr.go#L173: 		r := reflect.ValueOf(val)
		expr.go#L186: 				valVal := reflect.ValueOf(val)
		expr.go#L417: 	valVal := reflect.ValueOf(val)

	go.opentelemetry.io/otel/label
		kv.go#L114: 	rv := reflect.ValueOf(value)
		set.go#L87: 	return reflect.ValueOf(d.iface)

	go/ast
		print.go#L65: 	p.print(reflect.ValueOf(x))

	golang.org/x/crypto/ssh
		messages.go#L375: 	v := reflect.ValueOf(out).Elem()
		messages.go#L421: 				field.Index(j).Set(reflect.ValueOf(data[j]))
		messages.go#L452: 					field.Set(reflect.ValueOf(data))
		messages.go#L459: 					field.Set(reflect.ValueOf(s))
		messages.go#L466: 				field.Set(reflect.ValueOf(nl))
		messages.go#L476: 				field.Set(reflect.ValueOf(n))
		messages.go#L503: 	v := reflect.Indirect(reflect.ValueOf(msg))
		messages.go#L562: 				nValue := reflect.ValueOf(&n)

	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#L41: 	v := reflect.ValueOf(s)
		reflect.go#L68: 		v := reflect.ValueOf(p).Elem()
		reflect.go#L93: 	v := reflect.ValueOf(p)
		reflect.go#L112: 		p.Elem().Set(reflect.ValueOf(value)) // *p = value
		reflect.go#L132: 	v := reflect.ValueOf(pslice)

	golang.org/x/pkgsite/internal/godoc/dochtml
		template.go#L47: 		v := reflect.ValueOf(q)

	golang.org/x/pkgsite/internal/postgres
		details.go#L171: 	vptr := reflect.ValueOf(s.ptr)

	golang.org/x/pkgsite/internal/worker
		server.go#L707: 	v := reflect.ValueOf(n)

	golang.org/x/xerrors
		wrap.go#L84: 	val := reflect.ValueOf(target)
		wrap.go#L95: 			val.Elem().Set(reflect.ValueOf(err))

	google.golang.org/api/internal/gensupport
		json.go#L53: 	s := reflect.ValueOf(schema)

	google.golang.org/api/iterator
		iterator.go#L207: 	wantSliceType := reflect.PtrTo(reflect.ValueOf(p.pageInfo.takeBuf()).Type())
		iterator.go#L211: 	vslicep := reflect.ValueOf(slicep)
		iterator.go#L225: 	e.Set(reflect.AppendSlice(e, reflect.ValueOf(p.pageInfo.takeBuf())))

	google.golang.org/api/support/bundler
		bundler.go#L128: 	bu.items = reflect.Append(bu.items, reflect.ValueOf(item))

	google.golang.org/protobuf/internal/descfmt
		stringer.go#L44: 			name = reflect.ValueOf(vs).MethodByName("Get").Type().Out(0).Name() + "s"
		stringer.go#L84: 			rs.Append(reflect.ValueOf(vs.Get(i)), "Path", "Package", "IsPublic", "IsWeak")
		stringer.go#L91: 			m := reflect.ValueOf(vs).MethodByName("Get")
		stringer.go#L92: 			v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
		stringer.go#L121: 	rv := reflect.ValueOf(t)

	google.golang.org/protobuf/internal/impl
		api_export.go#L42: 		return legacyWrapEnum(reflect.ValueOf(e))
		api_export.go#L134: 	return legacyWrapMessage(reflect.ValueOf(m)).Interface()
		api_export.go#L146: 	return legacyWrapMessage(reflect.ValueOf(m))
		codec_map.go#L366: 		dstm.SetMapIndex(iter.Key(), reflect.ValueOf(append(emptyBuf[:], iter.Value().Bytes()...)))
		convert.go#L158: 	return reflect.ValueOf(v.Bool()).Convert(c.goType)
		convert.go#L182: 	return reflect.ValueOf(int32(v.Int())).Convert(c.goType)
		convert.go#L206: 	return reflect.ValueOf(int64(v.Int())).Convert(c.goType)
		convert.go#L230: 	return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)
		convert.go#L254: 	return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)
		convert.go#L278: 	return reflect.ValueOf(float32(v.Float())).Convert(c.goType)
		convert.go#L302: 	return reflect.ValueOf(float64(v.Float())).Convert(c.goType)
		convert.go#L332: 	return reflect.ValueOf(s).Convert(c.goType)
		convert.go#L359: 	return reflect.ValueOf(v.Bytes()).Convert(c.goType)
		convert.go#L394: 	return reflect.ValueOf(v.Enum()).Convert(c.goType)
		convert.go#L436: 		rv = reflect.ValueOf(u.protoUnwrap())
		convert.go#L438: 		rv = reflect.ValueOf(m.Interface())
		convert.go#L450: 		rv = reflect.ValueOf(u.protoUnwrap())
		convert.go#L452: 		rv = reflect.ValueOf(m.Interface())
		enum.go#L19: 	return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum)
		extension.go#L99: 	return xi.lazyInit().PBValueOf(reflect.ValueOf(v))
		extension.go#L108: 	return xi.lazyInit().IsValidGo(reflect.ValueOf(v))
		legacy_enum.go#L209: 		suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
		message_reflect_field.go#L218: 	nilBytes   = reflect.ValueOf([]byte(nil))
		message_reflect_field.go#L219: 	emptyBytes = reflect.ValueOf([]byte{})

	gopkg.in/yaml.v2
		decode.go#L272: 		d.unmarshal(n, reflect.ValueOf(v))
		decode.go#L435: 	if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
		decode.go#L480: 			out.Set(reflect.ValueOf(n.value))
		decode.go#L482: 			out.Set(reflect.ValueOf(resolved))
		decode.go#L561: 		if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
		decode.go#L569: 			elem.Elem().Set(reflect.ValueOf(resolved))
		decode.go#L579: 	v := reflect.ValueOf(i)
		decode.go#L711: 		k := reflect.ValueOf(&item.Key).Elem()
		decode.go#L713: 			v := reflect.ValueOf(&item.Value).Elem()
		decode.go#L719: 	out.Set(reflect.ValueOf(slice))
		encode.go#L109: 			in = reflect.ValueOf(integer)
		encode.go#L115: 			in = reflect.ValueOf(float)
		encode.go#L119: 		in = reflect.ValueOf(m.String())
		encode.go#L134: 		in = reflect.ValueOf(v)
		encode.go#L140: 		in = reflect.ValueOf(string(text))
		encode.go#L172: 			e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
		encode.go#L202: 			e.marshal("", reflect.ValueOf(item.Key))
		encode.go#L203: 			e.marshal("", reflect.ValueOf(item.Value))
		encode.go#L224: 			e.marshal("", reflect.ValueOf(info.Key))
		yaml.go#L126: 	out := reflect.ValueOf(v)
		yaml.go#L144: 		v := reflect.ValueOf(out)
		yaml.go#L203: 	e.marshalDoc("", reflect.ValueOf(in))
		yaml.go#L232: 	e.encoder.marshalDoc("", reflect.ValueOf(v))

	html/template
		content.go#L123: 	v := reflect.ValueOf(a)
		content.go#L142: 	v := reflect.ValueOf(a)
		js.go#L134: 	v := reflect.ValueOf(a)

	internal/execabs
		execabs.go#L51: 		lookPathErr := (*error)(unsafe.Pointer(reflect.ValueOf(cmd).Elem().FieldByName("lookPathErr").Addr().Pointer()))

	internal/fmtsort
		sort.go#L174: 		c := compare(reflect.ValueOf(aVal.Elem().Type()), reflect.ValueOf(bVal.Elem().Type()))

	net/http
		h2_bundle.go#L4226: 	if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr {
		transfer.go#L423: 		return reflect.ValueOf(t.Body).Field(0).Interface().(io.Reader)
		transfer.go#L1088: 		return isKnownInMemoryReader(reflect.ValueOf(r).Field(0).Interface().(io.Reader))
		transport.go#L372: 	if rv := reflect.ValueOf(altProto["https"]); rv.IsValid() && rv.Type().Kind() == reflect.Struct && rv.Type().NumField() == 1 {

	net/http/httptrace
		trace.go#L179: 	tv := reflect.ValueOf(t).Elem()
		trace.go#L180: 	ov := reflect.ValueOf(old).Elem()
		trace.go#L199: 		tfCopy := reflect.ValueOf(tf.Interface())

	text/template
		exec.go#L94: var missingVal = reflect.ValueOf(missingValType{})
		exec.go#L210: 		value = reflect.ValueOf(data)
		exec.go#L305: 	return isTrue(reflect.ValueOf(val))
		exec.go#L360: 			oneIteration(reflect.ValueOf(i), val.Index(i))
		exec.go#L386: 			oneIteration(reflect.ValueOf(i), elem)
		exec.go#L439: 			value = reflect.ValueOf(value.Interface()) // lovely!
		exec.go#L479: 		return reflect.ValueOf(word.True)
		exec.go#L487: 		return reflect.ValueOf(word.Text)
		exec.go#L504: 		return reflect.ValueOf(constant.Complex128) // incontrovertible.
		exec.go#L509: 		return reflect.ValueOf(constant.Float64)
		exec.go#L516: 		return reflect.ValueOf(n)
		exec.go#L629: 		nameVal := reflect.ValueOf(fieldName)
		exec.go#L754: 			return reflect.ValueOf(nil)
		exec.go#L763: 		return reflect.ValueOf(value)
		exec.go#L828: 			return reflect.ValueOf(s.evalEmptyInterface(dot, n))
		exec.go#L908: 		return reflect.ValueOf(n.True)
		exec.go#L921: 		return reflect.ValueOf(n.Text)
		funcs.go#L90: 		v := reflect.ValueOf(fn)
		funcs.go#L758: 			a, ok := printableValue(reflect.ValueOf(arg))

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L263: 	switch reflect.ValueOf(out).Elem().Kind() {
		asn1.go#L266: 		if !s.readASN1Int64(&i) || reflect.ValueOf(out).Elem().OverflowInt(i) {
		asn1.go#L269: 		reflect.ValueOf(out).Elem().SetInt(i)
		asn1.go#L273: 		if !s.readASN1Uint64(&u) || reflect.ValueOf(out).Elem().OverflowUint(u) {
		asn1.go#L276: 		reflect.ValueOf(out).Elem().SetUint(u)
		asn1.go#L615: 		switch reflect.ValueOf(out).Elem().Kind() {
		asn1.go#L618: 			reflect.ValueOf(out).Elem().Set(reflect.ValueOf(defaultValue))