reflect.Value.Interface (method)

346 uses

	reflect (current package)
		type.go#L2614: 		copy(tt.Elem().Field(2).Slice(0, len(methods)).Interface().([]method), methods)
		value.go#L1015: func (v Value) Interface() (i interface{}) {

	crypto/x509
		verify.go#L538: 		constraint := excludedValue.Index(i).Interface()
		verify.go#L558: 		constraint := permittedValue.Index(i).Interface()

	database/sql
		convert.go#L428: 		return convertAssignRows(dv.Interface(), src, rows)

	database/sql/driver
		types.go#L264: 			return defaultConverter{}.ConvertValue(rv.Elem().Interface())

	encoding/asn1
		asn1.go#L854: 	switch v := v.Addr().Interface().(type) {
		marshal.go#L466: 		t := value.Interface().(time.Time)
		marshal.go#L472: 		return bitStringEncoder(value.Interface().(BitString)), nil
		marshal.go#L474: 		return makeObjectIdentifier(value.Interface().(ObjectIdentifier))
		marshal.go#L476: 		return makeBigInt(value.Interface().(*big.Int))
		marshal.go#L596: 		if reflect.DeepEqual(v.Interface(), defaultValue.Interface()) {
		marshal.go#L605: 		if reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface()) {
		marshal.go#L611: 		rv := v.Interface().(RawValue)
		marshal.go#L656: 		if params.timeType == TagGeneralizedTime || outsideUTCRange(v.Interface().(time.Time)) {

	encoding/gob
		dec_helpers.go#L61: 	slice, ok := v.Interface().([]bool)
		dec_helpers.go#L84: 	slice, ok := v.Interface().([]complex64)
		dec_helpers.go#L109: 	slice, ok := v.Interface().([]complex128)
		dec_helpers.go#L134: 	slice, ok := v.Interface().([]float32)
		dec_helpers.go#L157: 	slice, ok := v.Interface().([]float64)
		dec_helpers.go#L180: 	slice, ok := v.Interface().([]int)
		dec_helpers.go#L208: 	slice, ok := v.Interface().([]int16)
		dec_helpers.go#L235: 	slice, ok := v.Interface().([]int32)
		dec_helpers.go#L262: 	slice, ok := v.Interface().([]int64)
		dec_helpers.go#L285: 	slice, ok := v.Interface().([]int8)
		dec_helpers.go#L312: 	slice, ok := v.Interface().([]string)
		dec_helpers.go#L349: 	slice, ok := v.Interface().([]uint)
		dec_helpers.go#L376: 	slice, ok := v.Interface().([]uint16)
		dec_helpers.go#L403: 	slice, ok := v.Interface().([]uint32)
		dec_helpers.go#L430: 	slice, ok := v.Interface().([]uint64)
		dec_helpers.go#L453: 	slice, ok := v.Interface().([]uintptr)
		decode.go#L734: 		err = value.Interface().(GobDecoder).GobDecode(b)
		decode.go#L736: 		err = value.Interface().(encoding.BinaryUnmarshaler).UnmarshalBinary(b)
		decode.go#L738: 		err = value.Interface().(encoding.TextUnmarshaler).UnmarshalText(b)
		enc_helpers.go#L60: 	slice, ok := v.Interface().([]bool)
		enc_helpers.go#L86: 	slice, ok := v.Interface().([]complex64)
		enc_helpers.go#L111: 	slice, ok := v.Interface().([]complex128)
		enc_helpers.go#L136: 	slice, ok := v.Interface().([]float32)
		enc_helpers.go#L159: 	slice, ok := v.Interface().([]float64)
		enc_helpers.go#L182: 	slice, ok := v.Interface().([]int)
		enc_helpers.go#L204: 	slice, ok := v.Interface().([]int16)
		enc_helpers.go#L226: 	slice, ok := v.Interface().([]int32)
		enc_helpers.go#L248: 	slice, ok := v.Interface().([]int64)
		enc_helpers.go#L270: 	slice, ok := v.Interface().([]int8)
		enc_helpers.go#L292: 	slice, ok := v.Interface().([]string)
		enc_helpers.go#L315: 	slice, ok := v.Interface().([]uint)
		enc_helpers.go#L337: 	slice, ok := v.Interface().([]uint16)
		enc_helpers.go#L359: 	slice, ok := v.Interface().([]uint32)
		enc_helpers.go#L381: 	slice, ok := v.Interface().([]uint64)
		enc_helpers.go#L403: 	slice, ok := v.Interface().([]uintptr)
		encode.go#L478: 		data, err = v.Interface().(GobEncoder).GobEncode()
		encode.go#L480: 		data, err = v.Interface().(encoding.BinaryMarshaler).MarshalBinary()
		encode.go#L482: 		data, err = v.Interface().(encoding.TextMarshaler).MarshalText()

	encoding/json
		decode.go#L475: 			if u, ok := v.Interface().(Unmarshaler); ok {
		decode.go#L479: 				if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
		encode.go#L474: 	m, ok := v.Interface().(Marshaler)
		encode.go#L495: 	m := va.Interface().(Marshaler)
		encode.go#L511: 	m, ok := v.Interface().(encoding.TextMarshaler)
		encode.go#L529: 	m := va.Interface().(encoding.TextMarshaler)
		encode.go#L937: 		ptr := v.Interface()
		encode.go#L1009: 	if tm, ok := w.v.Interface().(encoding.TextMarshaler); ok {

	encoding/xml
		marshal.go#L435: 		return p.marshalInterface(val.Interface().(Marshaler), defaultStart(typ, finfo, startTemplate))
		marshal.go#L440: 			return p.marshalInterface(pv.Interface().(Marshaler), defaultStart(pv.Type(), finfo, startTemplate))
		marshal.go#L446: 		return p.marshalTextInterface(val.Interface().(encoding.TextMarshaler), defaultStart(typ, finfo, startTemplate))
		marshal.go#L451: 			return p.marshalTextInterface(pv.Interface().(encoding.TextMarshaler), defaultStart(pv.Type(), finfo, startTemplate))
		marshal.go#L487: 			if v, ok := fv.Interface().(Name); ok && v.Local != "" {
		marshal.go#L555: 		attr, err := val.Interface().(MarshalerAttr).MarshalXMLAttr(name)
		marshal.go#L568: 			attr, err := pv.Interface().(MarshalerAttr).MarshalXMLAttr(name)
		marshal.go#L580: 		text, err := val.Interface().(encoding.TextMarshaler).MarshalText()
		marshal.go#L591: 			text, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
		marshal.go#L621: 		start.Attr = append(start.Attr, val.Interface().(Attr))
		marshal.go#L829: 				data, err := vf.Interface().(encoding.TextMarshaler).MarshalText()
		marshal.go#L841: 					data, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
		marshal.go#L876: 				if elem, ok := vf.Interface().([]byte); ok {
		marshal.go#L930: 			iface := vf.Interface()
		read.go#L256: 		return val.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
		read.go#L261: 			return pv.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
		read.go#L269: 		return val.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
		read.go#L274: 			return pv.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
		read.go#L342: 		return d.unmarshalInterface(val.Interface().(Unmarshaler), start)
		read.go#L348: 			return d.unmarshalInterface(pv.Interface().(Unmarshaler), start)
		read.go#L353: 		return d.unmarshalTextInterface(val.Interface().(encoding.TextUnmarshaler))
		read.go#L359: 			return d.unmarshalTextInterface(pv.Interface().(encoding.TextUnmarshaler))
		read.go#L439: 			if _, ok := fv.Interface().(Name); ok {
		read.go#L563: 		if err := saveData.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
		read.go#L572: 			if err := pv.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {

	flag
		flag.go#L464: 	return value == z.Interface().(Value).String()

	fmt
		print.go#L701: 			p.arg = f.Interface()
		print.go#L722: 		p.arg = value.Interface()

	github.com/aws/aws-sdk-go/aws/awsutil
		copy.go#L28: 	dst = dsti.Interface()
		copy.go#L44: 		if _, ok := src.Interface().(io.Reader); ok {
		copy.go#L53: 				if _, ok := src.Interface().(*time.Time); !ok {
		equal.go#L26: 	return reflect.DeepEqual(ra.Interface(), rb.Interface())
		path_value.go#L177: 			out[i] = v.Index(i).Interface()
		prettify.go#L29: 			fmt.Fprintf(buf, "%s", v.Interface())
		prettify.go#L105: 		switch v.Interface().(type) {
		prettify.go#L111: 		fmt.Fprintf(buf, format, v.Interface())
		string_value.go#L82: 		switch v.Interface().(type) {
		string_value.go#L86: 		fmt.Fprintf(buf, format, v.Interface())

	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
		idempotency.go#L21: 	switch u := v.Interface().(type) {

	github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
		build.go#L49: 			if _, ok := value.Interface().([]byte); !ok {
		build.go#L54: 			if _, ok := value.Interface().(aws.JSONValue); !ok {
		build.go#L217: 		switch converted := value.Interface().(type) {
		build.go#L254: 			return fmt.Errorf("unsupported JSON value %v (%s)", value.Interface(), value.Type())
		unmarshal.go#L91: 			if _, ok := value.Interface().(*time.Time); !ok {
		unmarshal.go#L96: 			if _, ok := value.Interface().([]byte); !ok {
		unmarshal.go#L101: 			if _, ok := value.Interface().(aws.JSONValue); !ok {
		unmarshal.go#L234: 		switch value.Interface().(type) {
		unmarshal.go#L262: 			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		unmarshal.go#L265: 		switch value.Interface().(type) {
		unmarshal.go#L291: 			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())
		unmarshal.go#L294: 		switch value.Interface().(type) {
		unmarshal.go#L298: 			return fmt.Errorf("unsupported value: %v (%s)", value.Interface(), value.Type())

	github.com/aws/aws-sdk-go/private/protocol/query/queryutil
		queryutil.go#L124: 	if _, ok := value.Interface().([]byte); ok {
		queryutil.go#L217: 	switch value := r.Interface().(type) {
		queryutil.go#L243: 		return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name())

	github.com/aws/aws-sdk-go/private/protocol/rest
		build.go#L141: 				if payload.IsValid() && payload.Interface() != nil {
		build.go#L142: 					switch reader := payload.Interface().(type) {
		build.go#L212: 	switch value := v.Interface().(type) {
		build.go#L273: 	switch value := v.Interface().(type) {
		build.go#L306: 		err := fmt.Errorf("unsupported value for param %v (%s)", v.Interface(), v.Type())
		payload.go#L24: 				return payload.Interface()
		unmarshal.go#L67: 					switch payload.Interface().(type) {
		unmarshal.go#L157: 	switch v.Interface().(type) {
		unmarshal.go#L168: 	switch r.Interface().(type) {
		unmarshal.go#L205: 	switch v.Interface().(type) {
		unmarshal.go#L253: 		err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type())

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		build.go#L278: 	switch converted := value.Interface().(type) {
		build.go#L304: 			tag.Get("locationName"), value.Interface(), value.Type().Name())
		unmarshal.go#L85: 			if _, ok := r.Interface().(*time.Time); !ok {
		unmarshal.go#L90: 			if _, ok := r.Interface().([]byte); !ok {
		unmarshal.go#L256: 	switch r.Interface().(type) {
		unmarshal.go#L296: 		return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())

	github.com/ghodss/yaml
		fields.go#L55: 			if u, ok := v.Interface().(json.Unmarshaler); ok {
		fields.go#L58: 			if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {

	github.com/go-git/gcfg
		set.go#L309: 	vAddrI := vAddr.Interface()

	github.com/go-git/go-git/v5/plumbing/transport/ssh
		common.go#L227: 	*c = vc.Interface().(ssh.ClientConfig)

	github.com/go-redis/redis/v8/internal/proto
		scan.go#L126: 		if err := Scan([]byte(s), elem.Addr().Interface()); err != nil {

	github.com/golang/protobuf/proto
		extensions.go#L176: 		v = rv2.Interface()
		extensions.go#L238: 			v = rv.Elem().Interface()
		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#L32: 		return reflect.ValueOf(ve.Interface()).Convert(f.Type)
		options.go#L233: 			if _, ok := reflect.New(t).Interface().(error); ok {
		report_compare.go#L386: 					ambiguous = prevKey.Interface() != currKey.Interface()
		report_reflect.go#L132: 				switch v := v.Interface().(type) {
		report_slices.go#L274: 						ss = append(ss, fmt.Sprint(v.Index(i).Interface()))
		report_slices.go#L325: 		return diff.BoolResult(vx.Index(ix).Interface() == vy.Index(iy).Interface())

	github.com/google/go-cmp/cmp/cmpopts
		sort.go#L62: 	sort.SliceStable(dst.Interface(), func(i, j int) bool { return ss.less(dst, i, j) })
		sort.go#L64: 	return dst.Interface()
		sort.go#L133: 	sort.Slice(dst.Interface(), func(i, j int) bool { return ms.less(dst, i, j) })
		sort.go#L135: 	return dst.Interface()

	github.com/google/safehtml/internal/safehtmlutil
		safehtmlutil.go#L162: 	return v.Interface()
		safehtmlutil.go#L179: 	return v.Interface()

	github.com/google/safehtml/template
		escape.go#L816: 	return v.Interface()

	github.com/imdario/mergo
		map.go#L52: 		dstMap := dst.Interface().(map[string]interface{})
		map.go#L62: 				dstMap[fieldName] = src.Field(i).Interface()
		map.go#L73: 		srcMap := src.Interface().(map[string]interface{})
		map.go#L88: 				srcKind = reflect.TypeOf(srcElement.Interface()).Kind()
		merge.go#L148: 				k := dstElement.Interface()
		merge.go#L162: 				srcElement = reflect.ValueOf(srcElement.Interface())
		merge.go#L164: 					dstElement = reflect.ValueOf(dstElement.Interface())

	github.com/jackc/pgtype
		aclitem_array.go#L170: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		aclitem_array.go#L299: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		array_type.go#L72: 		err := v.Set(sliceVal.Index(i).Interface())
		array_type.go#L120: 			err := src.elements[i].AssignTo(ptrElem.Interface())
		bool_array.go#L173: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		bool_array.go#L302: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		bpchar_array.go#L173: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		bpchar_array.go#L302: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		bytea_array.go#L154: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		bytea_array.go#L274: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		cidr_array.go#L193: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		cidr_array.go#L331: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		composite_type.go#L212: 		err := assignToOrSet(src.valueTranscoders[i], dstElemValue.Field(exportedFields[i]).Addr().Interface())
		convert.go#L24: 		convVal := refVal.Elem().Interface()
		convert.go#L79: 		convVal := refVal.Elem().Interface()
		convert.go#L98: 		convVal := refVal.Elem().Interface()
		convert.go#L119: 		convVal := refVal.Elem().Interface()
		convert.go#L138: 		convVal := refVal.Elem().Interface()
		convert.go#L154: 		convVal := refVal.Elem().Interface()
		convert.go#L160: 		return refVal.Convert(timeType).Interface(), true
		convert.go#L175: 		convVal := refVal.Elem().Interface()
		convert.go#L181: 		return refVal.Convert(uuidType).Interface(), true
		convert.go#L196: 		convVal := refVal.Elem().Interface()
		convert.go#L202: 			return convVal.Interface(), reflect.TypeOf(convVal.Interface()) != refVal.Type()
		convert.go#L292: 					return int64AssignTo(srcVal, srcStatus, el.Interface())
		convert.go#L344: 					return float64AssignTo(srcVal, srcStatus, el.Interface())
		convert.go#L410: 		return dstVal.Interface(), true
		convert.go#L416: 		return nextDst.Interface(), dstPtr.Type() != nextDst.Type()
		convert.go#L423: 			return nextDst.Interface(), dstPtr.Type() != nextDst.Type()
		convert.go#L431: 			return nextDst.Interface(), dstPtr.Type() != nextDst.Type()
		date_array.go#L174: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		date_array.go#L303: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		enum_array.go#L170: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		enum_array.go#L299: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		float4_array.go#L173: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		float4_array.go#L302: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		float8_array.go#L173: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		float8_array.go#L302: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		hstore_array.go#L154: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		hstore_array.go#L274: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		inet_array.go#L193: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		inet_array.go#L331: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		int2_array.go#L439: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		int2_array.go#L694: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		int4_array.go#L439: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		int4_array.go#L694: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		int8_array.go#L439: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		int8_array.go#L694: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		jsonb_array.go#L173: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		jsonb_array.go#L302: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		macaddr_array.go#L174: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		macaddr_array.go#L303: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		numeric_array.go#L287: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		numeric_array.go#L470: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		pgtype.go#L326: 		ci.RegisterDefaultPgType(reflect.New(valueType).Interface(), name)
		pgtype.go#L329: 		ci.RegisterDefaultPgType(reflect.MakeSlice(sliceType, 0, 0).Interface(), arrayName)
		pgtype.go#L331: 		ci.RegisterDefaultPgType(reflect.New(sliceType).Interface(), arrayName)
		pgtype.go#L365: 			value = reflect.New(reflect.ValueOf(t).Elem().Type()).Interface().(Value)
		pgtype.go#L616: 		plan := ci.PlanScan(oid, formatCode, elemPtr.Interface())
		pgtype.go#L617: 		return plan.Scan(ci, oid, formatCode, src, elemPtr.Interface())
		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#L173: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		text_array.go#L302: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		timestamp_array.go#L174: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		timestamp_array.go#L303: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		timestamptz_array.go#L174: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		timestamptz_array.go#L303: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		tsrange_array.go#L135: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		tsrange_array.go#L255: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		tstzrange_array.go#L135: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		tstzrange_array.go#L255: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		uuid_array.go#L211: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		uuid_array.go#L358: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {
		varchar_array.go#L173: 	if err := dst.Elements[index].Set(value.Interface()); err != nil {
		varchar_array.go#L302: 	if err := src.Elements[index].AssignTo(addr.Interface()); err != nil {

	github.com/jackc/pgx/v4
		extended_query_builder.go#L118: 		arg = refVal.Elem().Interface()
		values.go#L132: 		arg = refVal.Elem().Interface()
		values.go#L184: 		arg = refVal.Elem().Interface()

	github.com/jmespath/go-jmespath
		interpreter.go#L137: 					reflectFlat = append(reflectFlat, v.Index(i).Interface())
		interpreter.go#L167: 				return v.Interface(), nil
		interpreter.go#L326: 		return v.Interface(), nil
		interpreter.go#L337: 		return v.Interface(), nil
		interpreter.go#L346: 		element := v.Index(i).Interface()
		interpreter.go#L354: 					flattened, elementV.Index(j).Interface())
		interpreter.go#L375: 		element := v.Index(i).Interface()
		interpreter.go#L386: 		element := v.Index(i).Interface()
		interpreter.go#L408: 		element := v.Index(i).Interface()
		util.go#L42: 		return isFalse(element.Interface())

	github.com/lann/builder
		builder.go#L133: 		val = listToSlice(list, arrayType).Interface()
		builder.go#L161: 			val = listToSlice(list, arrayType).Interface()
		builder.go#L224: 	return structVal.Interface()
		reflect.go#L9: 		Interface()
		reflect.go#L22: 		f(val.Index(i).Interface())
		registry.go#L38: 	).Interface()

	github.com/lib/pq
		array.go#L284: 				ss := dest.Addr().Interface().(sql.Scanner)
		array.go#L302: 	if ad, ok := reflect.Zero(rt).Interface().(ArrayDelimiter); ok {
		array.go#L592: 	var iv interface{} = rv.Interface()

	github.com/Masterminds/squirrel
		expr.go#L178: 				val = r.Elem().Interface()
		expr.go#L194: 						args = append(args, valVal.Index(i).Interface())

	go.opentelemetry.io/otel/label
		set.go#L113: 		return value.Index(idx).Interface().(KeyValue), true
		set.go#L128: 		return rValue.Index(idx).Interface().(KeyValue).Key >= k
		set.go#L133: 	keyValue := rValue.Index(idx).Interface().(KeyValue)
		set.go#L445: 		*(at.Index(i).Addr().Interface().(*KeyValue)) = keyValue
		set.go#L447: 	return at.Interface()

	go/ast
		print.go#L173: 		ptr := x.Interface()
		print.go#L196: 		if s, ok := x.Interface().([]byte); ok {
		print.go#L238: 		v := x.Interface()

	golang.org/x/crypto/ssh
		messages.go#L520: 				panic(fmt.Sprintf("array of non-uint8 in field %d: %T", i, field.Interface()))
		messages.go#L557: 				panic(fmt.Sprintf("slice of unknown type in field %d: %T", i, field.Interface()))
		messages.go#L575: 				panic(fmt.Sprintf("pointer to unknown type in field %d: %T", i, field.Interface()))

	golang.org/x/pkgsite/internal/database
		reflect.go#L71: 			p := v.Field(info.num).Addr().Interface()
		reflect.go#L122: 	return n.ptr.Elem().Elem().Interface(), nil
		reflect.go#L153: 		if err := rows.Scan(scanner(e.Interface())...); err != nil {

	golang.org/x/pkgsite/internal/godoc/dochtml
		template.go#L49: 		if reflect.DeepEqual(v.Interface(), vz.Interface()) {

	golang.org/x/pkgsite/internal/postgres
		details.go#L183: 	if err := json.Unmarshal(jsonBytes, v.Interface()); err != nil {

	google.golang.org/api/internal/gensupport
		json.go#L86: 			ms, ok := v.Interface().(map[string]string)
		json.go#L116: 			m[tag.apiName] = v.Interface()
		json.go#L128: 	return fmt.Sprintf("%v", v.Interface())

	google.golang.org/api/support/bundler
		bundler.go#L324: 		b.handler(bu.items.Interface())

	google.golang.org/protobuf/internal/descfmt
		stringer.go#L92: 			v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
		stringer.go#L217: 		if _, ok := rv.Interface().(pref.Value); ok {
		stringer.go#L238: 		if n, ok := rv.Interface().(list); ok {
		stringer.go#L247: 		v := rv.Interface()

	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/impl
		codec_field.go#L499: 	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
		codec_field.go#L813: 	m := reflect.New(f.mi.GoReflectType.Elem()).Interface()
		codec_field.go#L824: 	if m, ok := v.Interface().(pref.ProtoMessage); ok {
		convert.go#L426: 	if m, ok := v.Interface().(pref.ProtoMessage); ok {
		convert_list.go#L140: 	return ls.v.Interface()
		convert_map.go#L120: 	return ms.v.Interface()
		enum.go#L19: 	return reflect.ValueOf(n).Convert(t.GoReflectType).Interface().(pref.Enum)
		extension.go#L102: 	return xi.lazyInit().GoValueOf(v).Interface()
		legacy_enum.go#L104: 	return v.Interface()
		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#L32: 	return mt.MessageOf(v.Interface())
		legacy_message.go#L52: 	v := reflect.Zero(t).Interface()
		legacy_message.go#L91: 	mv := reflect.Zero(t).Interface()
		legacy_message.go#L201: 				if vs, ok := v.Interface().([]interface{}); ok {
		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#L501: 	return m.v.Interface()
		message.go#L56: 	m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage)
		message.go#L187: 				if vs, ok := v.Interface().([]interface{}); ok {
		message.go#L210: 	return mi.MessageOf(reflect.New(mi.GoReflectType.Elem()).Interface())
		message.go#L213: 	return mi.MessageOf(reflect.Zero(mi.GoReflectType).Interface())
		message_reflect.go#L106: 			return pref.RawFields(*rv.Interface().(*[]byte))
		message_reflect.go#L113: 			*rv.Interface().(*[]byte) = []byte(b)
		message_reflect.go#L134: 			return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))
		pointer_unsafe.go#L84: 	return p.AsValueOf(t).Interface()

	gopkg.in/yaml.v2
		decode.go#L312: 			if u, ok := out.Addr().Interface().(Unmarshaler); ok {
		decode.go#L443: 		u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)
		decode.go#L673: 				failf("invalid map key: %#v", k.Interface())
		decode.go#L687: 		d.terrors = append(d.terrors, fmt.Sprintf("line %d: key %#v already set in map", n.line+1, k.Interface()))
		encode.go#L103: 	iface := in.Interface()
		encode.go#L200: 		slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
		encode.go#L358: 	t := in.Interface().(time.Time)
		yaml.go#L430: 	if z, ok := v.Interface().(IsZeroer); ok {

	html/template
		content.go#L127: 	return v.Interface()
		content.go#L146: 	return v.Interface()
		js.go#L138: 	return v.Interface()

	net/http
		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#L374: 			if h2i, ok := v.Interface().(h2Transport); ok {

	net/http/httptrace
		trace.go#L199: 		tfCopy := reflect.ValueOf(tf.Interface())

	text/template
		exec.go#L439: 			value = reflect.ValueOf(value.Interface()) // lovely!
		exec.go#L733: 		v = v.Interface().(reflect.Value)
		exec.go#L991: 	return v.Interface(), true
		funcs.go#L367: 		return ret[0], ret[1].Interface().(error)
		funcs.go#L501: 					truth = arg1.Interface() == arg.Interface()