type reflect.Value
650 uses
reflect (current package)
badlinkname.go#L130: func badlinkname_Value_pointer(Value) unsafe.Pointer
deepequal.go#L27: func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool {
deepequal.go#L39: hard := func(v1, v2 Value) bool {
deepequal.go#L63: ptrval := func(v Value) unsafe.Pointer {
iter.go#L13: uintptr, N int64 | uint64](num N, t Type) iter.Seq[Value] {
iter.go#L14: return func(yield func(v Value) bool) {
iter.go#L38: func (v Value) Seq() iter.Seq[Value] {
iter.go#L40: return func(yield func(Value) bool) {
iter.go#L41: rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
iter.go#L42: return []Value{ValueOf(yield(in[0]))}
iter.go#L44: v.Call([]Value{rf})
iter.go#L74: return func(yield func(Value) bool) {
iter.go#L83: return func(yield func(Value) bool) {
iter.go#L91: return func(yield func(Value) bool) {
iter.go#L99: return func(yield func(Value) bool) {
iter.go#L108: return func(yield func(Value) bool) {
iter.go#L124: func (v Value) Seq2() iter.Seq2[Value, Value] {
iter.go#L126: return func(yield func(Value, Value) bool) {
iter.go#L127: rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
iter.go#L128: return []Value{ValueOf(yield(in[0], in[1]))}
iter.go#L130: v.Call([]Value{rf})
iter.go#L138: return func(yield func(Value, Value) bool) {
iter.go#L147: return func(yield func(Value, Value) bool) {
iter.go#L155: return func(yield func(Value, Value) bool) {
iter.go#L163: return func(yield func(Value, Value) bool) {
makefunc.go#L23: fn func([]Value) []Value
makefunc.go#L47: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
makefunc.go#L71: return Value{t, unsafe.Pointer(impl), flag(Func)}
makefunc.go#L87: rcvr Value
makefunc.go#L97: func makeMethodValue(op string, v Value) Value {
makefunc.go#L105: rcvr := Value{v.typ(), v.ptr, fl}
makefunc.go#L130: return Value{ftyp.Common(), unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
map.go#L139: func (v Value) MapIndex(key Value) Value {
map.go#L166: return Value{}
map.go#L203: func (v Value) MapKeys() []Value {
map.go#L221: a := make([]Value, mlen)
map.go#L240: m Value
map.go#L245: func (iter *MapIter) Key() Value {
map.go#L264: func (v Value) SetIterKey(iter *MapIter) {
map.go#L283: key := Value{ktype, iterkey, iter.m.flag | flag(ktype.Kind()) | flagIndir}
map.go#L289: func (iter *MapIter) Value() Value {
map.go#L308: func (v Value) SetIterValue(iter *MapIter) {
map.go#L327: elem := Value{vtype, iterelem, iter.m.flag | flag(vtype.Kind()) | flagIndir}
map.go#L356: func (iter *MapIter) Reset(v Value) {
map.go#L379: func (v Value) MapRange() *MapIter {
map.go#L396: func (v Value) SetMapIndex(key, elem Value) {
type.go#L482: Func Value // func with receiver as first argument
type.go#L672: m.Func = Value{&mt.(*rtype).t, fn, fl}
value.go#L40: type Value struct {
value.go#L100: func (v Value) typ() *abi.Type {
value.go#L112: func (v Value) pointer() unsafe.Pointer {
value.go#L123: func packEface(v Value) any {
value.go#L132: func packEfaceData(v Value) unsafe.Pointer {
value.go#L158: func unpackEface(i any) Value {
value.go#L162: return Value{}
value.go#L168: return Value{t, e.Data, f}
value.go#L269: func (v Value) Addr() Value {
value.go#L276: return Value{ptrTo(v.typ()), v.ptr, fl | flag(Pointer)}
value.go#L281: func (v Value) Bool() bool {
value.go#L289: func (v Value) panicNotBool() {
value.go#L298: func (v Value) Bytes() []byte {
value.go#L306: func (v Value) bytesSlow() []byte {
value.go#L330: func (v Value) runes() []rune {
value.go#L344: func (v Value) CanAddr() bool {
value.go#L353: func (v Value) CanSet() bool {
value.go#L366: func (v Value) Call(in []Value) []Value {
value.go#L380: func (v Value) CallSlice(in []Value) []Value {
value.go#L390: func (v Value) call(op string, in []Value) []Value {
value.go#L395: rcvr Value
value.go#L458: in = make([]Value, n+1)
value.go#L593: var ret []Value
value.go#L608: ret = make([]Value, nout)
value.go#L623: ret[i] = Value{tv, add(stackArgs, st.stkOff, "tv.Size() != 0"), fl}
value.go#L639: ret[i] = Value{tv, regArgs.Ptrs[steps[0].ireg], flag(tv.Kind())}
value.go#L670: ret[i] = Value{tv, s, flagIndir | flag(tv.Kind())}
value.go#L713: in := make([]Value, 0, int(ftyp.InCount))
value.go#L719: v := Value{typ, nil, flag(typ.Kind())}
value.go#L877: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *abi.Type, t *funcType, fn unsafe.Pointer) {
value.go#L916: func storeRcvr(v Value, p unsafe.Pointer) {
value.go#L1144: func funcName(f func([]Value) []Value) string {
value.go#L1155: func (v Value) Cap() int {
value.go#L1163: func (v Value) capNonSlice() int {
value.go#L1182: func (v Value) Close() {
value.go#L1194: func (v Value) CanComplex() bool {
value.go#L1205: func (v Value) Complex() complex128 {
value.go#L1220: func (v Value) Elem() Value {
value.go#L1251: return Value{}
value.go#L1257: return Value{typ, ptr, fl}
value.go#L1264: func (v Value) Field(i int) Value {
value.go#L1294: return Value{typ, unsafe.Pointer(&zeroVal[0]), fl | flagIndir}
value.go#L1303: return Value{typ, ptr, fl}
value.go#L1309: func (v Value) FieldByIndex(index []int) Value {
value.go#L1332: func (v Value) FieldByIndexErr(index []int) (Value, error) {
value.go#L1341: return Value{}, errors.New("reflect: indirection through nil pointer to embedded struct field " + nameFor(v.typ().Elem()))
value.go#L1354: func (v Value) FieldByName(name string) Value {
value.go#L1359: return Value{}
value.go#L1366: func (v Value) FieldByNameFunc(match func(string) bool) Value {
value.go#L1370: return Value{}
value.go#L1374: func (v Value) CanFloat() bool {
value.go#L1385: func (v Value) Float() float64 {
value.go#L1400: func (v Value) Index(i int) Value {
value.go#L1417: return Value{typ, val, fl}
value.go#L1430: return Value{typ, val, fl}
value.go#L1439: return Value{uint8Type, p, fl}
value.go#L1445: func (v Value) CanInt() bool {
value.go#L1456: func (v Value) Int() int64 {
value.go#L1475: func (v Value) CanInterface() bool {
value.go#L1489: func (v Value) Interface() (i any) {
value.go#L1493: func valueInterface(v Value, safe bool) any {
value.go#L1518: func TypeAssert[T any](v Value) (T, bool) {
value.go#L1593: func packIfaceValueIntoEmptyIface(v Value) any {
value.go#L1613: func (v Value) InterfaceData() [2]uintptr {
value.go#L1632: func (v Value) IsNil() bool {
value.go#L1657: func (v Value) IsValid() bool {
value.go#L1663: func (v Value) IsZero() bool {
value.go#L1790: func (v Value) SetZero() {
value.go#L1844: func (v Value) Kind() Kind {
value.go#L1850: func (v Value) Len() int {
value.go#L1858: func (v Value) lenNonSlice() int {
value.go#L1881: func copyVal(typ *abi.Type, fl flag, ptr unsafe.Pointer) Value {
value.go#L1887: return Value{typ, c, fl | flagIndir}
value.go#L1889: return Value{typ, *(*unsafe.Pointer)(ptr), fl}
value.go#L1899: func (v Value) Method(i int) Value {
value.go#L1912: return Value{v.typ(), v.ptr, fl}
value.go#L1920: func (v Value) NumMethod() int {
value.go#L1939: func (v Value) MethodByName(name string) Value {
value.go#L1944: return Value{}
value.go#L1948: return Value{}
value.go#L1955: func (v Value) NumField() int {
value.go#L1963: func (v Value) OverflowComplex(x complex128) bool {
value.go#L1976: func (v Value) OverflowFloat(x float64) bool {
value.go#L1996: func (v Value) OverflowInt(x int64) bool {
value.go#L2009: func (v Value) OverflowUint(x uint64) bool {
value.go#L2041: func (v Value) Pointer() uintptr {
value.go#L2090: func (v Value) Recv() (x Value, ok bool) {
value.go#L2098: func (v Value) recv(nb bool) (val Value, ok bool) {
value.go#L2104: val = Value{t, nil, flag(t.Kind())}
value.go#L2115: val = Value{}
value.go#L2123: func (v Value) Send(x Value) {
value.go#L2131: func (v Value) send(x Value, nb bool) (selected bool) {
value.go#L2151: func (v Value) Set(x Value) {
value.go#L2172: func (v Value) SetBool(x bool) {
value.go#L2181: func (v Value) SetBytes(x []byte) {
value.go#L2193: func (v Value) setRunes(x []rune) {
value.go#L2205: func (v Value) SetComplex(x complex128) {
value.go#L2220: func (v Value) SetFloat(x float64) {
value.go#L2235: func (v Value) SetInt(x int64) {
value.go#L2257: func (v Value) SetLen(n int) {
value.go#L2271: func (v Value) SetCap(n int) {
value.go#L2284: func (v Value) SetUint(x uint64) {
value.go#L2307: func (v Value) SetPointer(x unsafe.Pointer) {
value.go#L2315: func (v Value) SetString(x string) {
value.go#L2324: func (v Value) Slice(i, j int) Value {
value.go#L2358: return Value{v.typ(), unsafe.Pointer(&t), v.flag}
value.go#L2380: return Value{typ.Common(), unsafe.Pointer(&x), fl}
value.go#L2386: func (v Value) Slice3(i, j, k int) Value {
value.go#L2432: return Value{typ.Common(), unsafe.Pointer(&x), fl}
value.go#L2441: func (v Value) String() string {
value.go#L2449: func (v Value) stringNonString() string {
value.go#L2463: func (v Value) TryRecv() (x Value, ok bool) {
value.go#L2473: func (v Value) TrySend(x Value) bool {
value.go#L2480: func (v Value) Type() Type {
value.go#L2488: func (v Value) typeSlow() Type {
value.go#L2492: func (v Value) abiType() *abi.Type {
value.go#L2499: func (v Value) abiTypeSlow() *abi.Type {
value.go#L2531: func (v Value) CanUint() bool {
value.go#L2542: func (v Value) Uint() uint64 {
value.go#L2571: func (v Value) UnsafeAddr() uintptr {
value.go#L2597: func (v Value) UnsafePointer() unsafe.Pointer {
value.go#L2644: func (v Value) Fields() iter.Seq2[StructField, Value] {
value.go#L2649: return func(yield func(StructField, Value) bool) {
value.go#L2669: func (v Value) Methods() iter.Seq2[Method, Value] {
value.go#L2670: return func(yield func(Method, Value) bool) {
value.go#L2730: func (v Value) Grow(n int) {
value.go#L2737: func (v Value) grow(n int) {
value.go#L2756: func (v Value) extendSlice(n int) Value {
value.go#L2774: func (v Value) Clear() {
value.go#L2789: func Append(s Value, x ...Value) Value {
value.go#L2801: func AppendSlice(s, t Value) Value {
value.go#L2820: func Copy(dst, src Value) int {
value.go#L2922: Chan Value // channel to use (for send or receive)
value.go#L2923: Send Value // value to send (for send)
value.go#L2934: func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) {
value.go#L3025: recv = Value{t, p, fl | flagIndir}
value.go#L3027: recv = Value{t, *(*unsafe.Pointer)(p), fl}
value.go#L3047: func MakeSlice(typ Type, len, cap int) Value {
value.go#L3062: return Value{&typ.(*rtype).t, unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L3069: func SliceAt(typ Type, p unsafe.Pointer, n int) Value {
value.go#L3072: return Value{SliceOf(typ).common(), unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L3076: func MakeChan(typ Type, buffer int) Value {
value.go#L3088: return Value{t, ch, flag(Chan)}
value.go#L3092: func MakeMap(typ Type) Value {
value.go#L3098: func MakeMapWithSize(typ Type, n int) Value {
value.go#L3104: return Value{t, m, flag(Map)}
value.go#L3110: func Indirect(v Value) Value {
value.go#L3119: func ValueOf(i any) Value {
value.go#L3121: return Value{}
value.go#L3131: func Zero(typ Type) Value {
value.go#L3144: return Value{t, p, fl | flagIndir}
value.go#L3146: return Value{t, nil, fl}
value.go#L3154: func New(typ Type) Value {
value.go#L3166: return Value{pt, ptr, fl}
value.go#L3171: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L3174: return Value{t.ptrTo(), p, fl}
value.go#L3182: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
value.go#L3193: return Value{dst, v.ptr, fl}
value.go#L3200: return Value{dst, nil, flag(Interface)}
value.go#L3211: return Value{dst, target, flagIndir | flag(Interface)}
value.go#L3221: func (v Value) Convert(t Type) Value {
value.go#L3234: func (v Value) CanConvert(t Type) bool {
value.go#L3259: func (v Value) Comparable() bool {
value.go#L3301: func (v Value) Equal(u Value) bool {
value.go#L3369: func convertOp(dst, src *abi.Type) func(Value, Type) Value {
value.go#L3467: func makeInt(f flag, bits uint64, t Type) Value {
value.go#L3480: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3485: func makeFloat(f flag, v float64, t Type) Value {
value.go#L3494: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3498: func makeFloat32(f flag, v float32, t Type) Value {
value.go#L3502: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3507: func makeComplex(f flag, v complex128, t Type) Value {
value.go#L3516: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3519: func makeString(f flag, v string, t Type) Value {
value.go#L3526: func makeBytes(f flag, v []byte, t Type) Value {
value.go#L3533: func makeRunes(f flag, v []rune, t Type) Value {
value.go#L3546: func cvtInt(v Value, t Type) Value {
value.go#L3551: func cvtUint(v Value, t Type) Value {
value.go#L3556: func cvtFloatInt(v Value, t Type) Value {
value.go#L3561: func cvtFloatUint(v Value, t Type) Value {
value.go#L3566: func cvtIntFloat(v Value, t Type) Value {
value.go#L3571: func cvtUintFloat(v Value, t Type) Value {
value.go#L3576: func cvtFloat(v Value, t Type) Value {
value.go#L3587: func cvtComplex(v Value, t Type) Value {
value.go#L3592: func cvtIntString(v Value, t Type) Value {
value.go#L3601: func cvtUintString(v Value, t Type) Value {
value.go#L3610: func cvtBytesString(v Value, t Type) Value {
value.go#L3615: func cvtStringBytes(v Value, t Type) Value {
value.go#L3620: func cvtRunesString(v Value, t Type) Value {
value.go#L3625: func cvtStringRunes(v Value, t Type) Value {
value.go#L3630: func cvtSliceArrayPtr(v Value, t Type) Value {
value.go#L3636: return Value{t.common(), h.Data, v.flag&^(flagIndir|flagAddr|flagKindMask) | flag(Pointer)}
value.go#L3640: func cvtSliceArray(v Value, t Type) Value {
value.go#L3652: return Value{typ, ptr, v.flag&^(flagAddr|flagKindMask) | flag(Array)}
value.go#L3656: func cvtDirect(v Value, typ Type) Value {
value.go#L3667: return Value{t, ptr, v.flag.ro() | f} // v.flag.ro()|f == f?
value.go#L3671: func cvtT2I(v Value, typ Type) Value {
value.go#L3679: return Value{typ.common(), target, v.flag.ro() | flagIndir | flag(Interface)}
value.go#L3683: func cvtI2I(v Value, typ Type) Value {
database/sql
convert.go#L357: var sv reflect.Value
convert.go#L521: func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
encoding/asn1
asn1.go#L632: func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
asn1.go#L709: func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err error) {
asn1.go#L1050: func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
marshal.go#L458: func makeBody(value reflect.Value, params fieldParameters) (e encoder, err error) {
marshal.go#L579: func makeField(v reflect.Value, params fieldParameters) (e encoder, err error) {
encoding/binary
binary.go#L698: func dataSize(v reflect.Value) int {
binary.go#L845: func (d *decoder) value(v reflect.Value) {
binary.go#L914: func (e *encoder) value(v reflect.Value) {
binary.go#L977: func (d *decoder) skip(v reflect.Value) {
binary.go#L981: func (e *encoder) skip(v reflect.Value) {
encoding/json
decode.go#L363: func (d *decodeState) value(v reflect.Value) error {
decode.go#L432: func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
decode.go#L486: return u, nil, reflect.Value{}
decode.go#L490: return nil, u, reflect.Value{}
decode.go#L507: func (d *decodeState) array(v reflect.Value) error {
decode.go#L566: if err := d.value(reflect.Value{}); err != nil {
decode.go#L604: func (d *decodeState) object(v reflect.Value) error {
decode.go#L660: var mapElem reflect.Value
decode.go#L687: var subv reflect.Value
decode.go#L721: subv = reflect.Value{}
decode.go#L776: var kv reflect.Value
decode.go#L856: func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
encode.go#L253: Value reflect.Value
encode.go#L352: func isEmptyValue(v reflect.Value) bool {
encode.go#L366: func (e *encodeState) reflectValue(v reflect.Value, opts encOpts) {
encode.go#L377: type encoderFunc func(e *encodeState, v reflect.Value, opts encOpts)
encode.go#L381: func valueEncoder(v reflect.Value) encoderFunc {
encode.go#L402: fi, loaded := encoderCache.LoadOrStore(t, encoderFunc(func(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L469: func invalidValueEncoder(e *encodeState, v reflect.Value, _ encOpts) {
encode.go#L473: func marshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L495: func addrMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L514: func textMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L531: func addrTextMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L545: func boolEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L553: func intEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L561: func uintEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L571: func (bits floatEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L610: func stringEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L695: func interfaceEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L703: func unsupportedTypeEncoder(e *encodeState, v reflect.Value, _ encOpts) {
encode.go#L717: func (se structEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L765: func (me mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L824: func encodeByteSlice(e *encodeState, v reflect.Value, _ encOpts) {
encode.go#L843: func (se sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L883: func (ae arrayEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L904: func (pe ptrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L932: func (ce condAddrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L975: v reflect.Value
encode.go#L979: func resolveKeyName(k reflect.Value) (string, error) {
encode.go#L1081: isZero func(reflect.Value) bool
encode.go#L1196: field.isZero = func(v reflect.Value) bool {
encode.go#L1204: field.isZero = func(v reflect.Value) bool {
encode.go#L1209: field.isZero = func(v reflect.Value) bool {
encode.go#L1213: field.isZero = func(v reflect.Value) bool {
encoding/xml
marshal.go#L421: func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo, startTemplate *StartElement) error {
marshal.go#L584: func (p *printer) marshalAttr(start *StartElement, name Name, val reflect.Value) error {
marshal.go#L794: func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
marshal.go#L835: func indirect(vf reflect.Value) reflect.Value {
marshal.go#L845: func (p *printer) marshalStruct(tinfo *typeInfo, val reflect.Value) error {
marshal.go#L1136: func isEmptyValue(v reflect.Value) bool {
read.go#L251: func (d *Decoder) unmarshalAttr(val reflect.Value, attr Attr) error {
read.go#L324: func (d *Decoder) unmarshal(val reflect.Value, start *StartElement, depth int) error {
read.go#L392: saveData reflect.Value
read.go#L394: saveComment reflect.Value
read.go#L395: saveXML reflect.Value
read.go#L398: saveAny reflect.Value
read.go#L399: sv reflect.Value
read.go#L597: saveData = reflect.Value{}
read.go#L608: saveData = reflect.Value{}
read.go#L636: func copyValue(dst reflect.Value, src []byte) (err error) {
read.go#L709: func (d *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement, depth int) (consumed bool, err error) {
typeinfo.go#L350: func (finfo *fieldInfo) value(v reflect.Value, shouldInitNilPointers bool) reflect.Value {
typeinfo.go#L357: return reflect.Value{}
flag
flag.go#L543: var z reflect.Value
fmt
print.go#L127: value reflect.Value
print.go#L179: p.value = reflect.Value{}
print.go#L342: func getField(v reflect.Value, i int) reflect.Value {
print.go#L372: func (p *pp) unknownType(v reflect.Value) {
print.go#L550: func (p *pp) fmtPointer(value reflect.Value, verb rune) {
print.go#L684: p.value = reflect.Value{}
print.go#L745: case reflect.Value:
print.go#L767: func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
github.com/jackc/pgx/v5/pgtype
array_codec.go#L409: func isRagged(slice reflect.Value) bool {
builtin_wrappers.go#L714: exportedFields []reflect.Value
builtin_wrappers.go#L732: exportedFields []reflect.Value
builtin_wrappers.go#L748: slice reflect.Value
builtin_wrappers.go#L790: slice reflect.Value
builtin_wrappers.go#L887: func (a *anyMultiDimSliceArray) makeMultidimensionalSlice(sliceType reflect.Type, dimensions []ArrayDimension, flatSlice reflect.Value, flatSliceIdx int) reflect.Value {
builtin_wrappers.go#L915: array reflect.Value
convert.go#L28: func toInterface(dst reflect.Value, t reflect.Type) (any, bool) {
pgtype.go#L568: var elemValue reflect.Value
pgtype.go#L915: var targetElemValue reflect.Value
pgtype.go#L1810: func getExportedFieldValues(structValue reflect.Value) []reflect.Value {
pgtype.go#L1812: exportedFields := make([]reflect.Value, 0, structValue.NumField())
go.uber.org/mock/gomock
call.go#L131: vArgs := make([]reflect.Value, len(args))
call.go#L172: vArgs := make([]reflect.Value, len(args))
call.go#L479: func setSlice(arg any, v reflect.Value) {
call.go#L486: func setMap(arg any, v reflect.Value) {
call.go#L489: va.SetMapIndex(e, reflect.Value{})
matchers.go#L317: func (m inAnyOrderMatcher) prepareValue(x any) (reflect.Value, bool) {
matchers.go#L323: return reflect.Value{}, false
go/ast
print.go#L18: type FieldFilter func(name string, value reflect.Value) bool
print.go#L22: func NotNilFilter(_ string, v reflect.Value) bool {
print.go#L143: func (p *printer) print(x reflect.Value) {
google.golang.org/protobuf/internal/descfmt
stringer.go#L100: v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
stringer.go#L108: method reflect.Value
stringer.go#L300: func (rs *records) Append(v reflect.Value, accessors ...methodAndName) {
stringer.go#L305: var rv reflect.Value
google.golang.org/protobuf/internal/impl
codec_field.go#L54: var vw reflect.Value // pointer to wrapper type
codec_field.go#L783: func asMessage(v reflect.Value) protoreflect.ProtoMessage {
codec_map.go#L92: func sizeMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) int {
codec_map.go#L115: func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L175: func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L242: func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L283: func appendMap(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L302: func appendMapDeterministic(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L331: func isInitMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo) error {
convert.go#L23: PBValueOf(reflect.Value) protoreflect.Value
convert.go#L26: GoValueOf(protoreflect.Value) reflect.Value
convert.go#L32: IsValidGo(reflect.Value) bool
convert.go#L150: func (c *boolConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L156: func (c *boolConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L163: func (c *boolConverter) IsValidGo(v reflect.Value) bool {
convert.go#L174: func (c *int32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L180: func (c *int32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L187: func (c *int32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L198: func (c *int64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L204: func (c *int64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L211: func (c *int64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L222: func (c *uint32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L228: func (c *uint32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L235: func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L246: func (c *uint64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L252: func (c *uint64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L259: func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L270: func (c *float32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L276: func (c *float32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L283: func (c *float32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L294: func (c *float64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L300: func (c *float64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L307: func (c *float64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L318: func (c *stringConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L324: func (c *stringConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L337: func (c *stringConverter) IsValidGo(v reflect.Value) bool {
convert.go#L348: func (c *bytesConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L357: func (c *bytesConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L364: func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
convert.go#L385: func (c *enumConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L392: func (c *enumConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L401: func (c *enumConverter) IsValidGo(v reflect.Value) bool {
convert.go#L421: func (c *messageConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L438: func (c *messageConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L440: var rv reflect.Value
convert.go#L464: var rv reflect.Value
convert.go#L476: func (c *messageConverter) IsValidGo(v reflect.Value) bool {
convert_list.go#L29: func (c *listConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert_list.go#L38: func (c *listConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert_list.go#L54: func (c *listConverter) IsValidGo(v reflect.Value) bool {
convert_list.go#L71: func (c *listPtrConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert_list.go#L78: func (c *listPtrConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert_list.go#L90: func (c *listPtrConverter) IsValidGo(v reflect.Value) bool {
convert_list.go#L103: v reflect.Value // *[]T
convert_map.go#L30: func (c *mapConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert_map.go#L37: func (c *mapConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert_map.go#L49: func (c *mapConverter) IsValidGo(v reflect.Value) bool {
convert_map.go#L62: v reflect.Value // map[K]V
convert_map.go#L90: ms.v.SetMapIndex(rk, reflect.Value{})
legacy_enum.go#L36: func legacyWrapEnum(v reflect.Value) protoreflect.Enum {
legacy_message.go#L24: func legacyWrapMessage(v reflect.Value) protoreflect.Message {
legacy_message.go#L218: for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
legacy_message.go#L229: vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
legacy_message.go#L492: v reflect.Value
message.go#L205: for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
pointer_unsafe.go#L47: func pointerOfValue(v reflect.Value) pointer {
pointer_unsafe.go#L76: func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
internal/buildcfg
exp.go#L170: var rBase reflect.Value
internal/fmtsort
sort.go#L28: Key, Value reflect.Value
sort.go#L49: func Sort(mapValue reflect.Value) SortedMap {
sort.go#L72: func compare(aVal, bVal reflect.Value) int {
sort.go#L143: func nilCompare(aVal, bVal reflect.Value) (int, bool) {
net/http/httptrace
trace.go#L202: newFunc := reflect.MakeFunc(hookType, func(args []reflect.Value) []reflect.Value {
testing
fuzz.go#L329: args := []reflect.Value{reflect.ValueOf(t)}
text/template
exec.go#L45: value reflect.Value
exec.go#L49: func (s *state) push(name string, value reflect.Value) {
exec.go#L65: func (s *state) setVar(name string, value reflect.Value) {
exec.go#L76: func (s *state) setTopVar(n int, value reflect.Value) {
exec.go#L81: func (s *state) varValue(name string) reflect.Value {
exec.go#L91: var zero reflect.Value
exec.go#L99: func isMissing(v reflect.Value) bool {
exec.go#L212: value, ok := data.(reflect.Value)
exec.go#L261: func (s *state) walk(dot reflect.Value, node parse.Node) {
exec.go#L299: func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
exec.go#L324: func isTrue(val reflect.Value) (truth, ok bool) {
exec.go#L352: func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
exec.go#L363: oneIteration := func(index, elem reflect.Value) {
exec.go#L408: oneIteration(reflect.Value{}, v)
exec.go#L464: oneIteration(reflect.Value{}, v)
exec.go#L481: oneIteration(reflect.Value{}, i)
exec.go#L498: func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
exec.go#L525: func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
exec.go#L548: func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
exec.go#L554: func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
exec.go#L593: func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
exec.go#L628: func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L633: func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L646: func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L660: func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L669: func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L682: func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value {
exec.go#L766: reflectValueType = reflect.TypeFor[reflect.Value]()
exec.go#L772: func (s *state) evalCall(dot, fun reflect.Value, isBuiltin bool, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L794: unwrap := func(v reflect.Value) reflect.Value {
exec.go#L796: v = v.Interface().(reflect.Value)
exec.go#L804: var v reflect.Value
exec.go#L806: v = s.evalArg(dot, argType, arg).Interface().(reflect.Value)
exec.go#L826: argv := make([]reflect.Value, numIn)
exec.go#L866: argv = append([]reflect.Value{reflect.ValueOf(calleeName)}, argv...)
exec.go#L892: func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
exec.go#L934: func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L981: func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L992: func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1003: func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1014: func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1025: func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1036: func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L1046: func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
exec.go#L1076: func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
exec.go#L1089: func indirectInterface(v reflect.Value) reflect.Value {
exec.go#L1094: return reflect.Value{}
exec.go#L1101: func (s *state) printValue(n parse.Node, v reflect.Value) {
exec.go#L1115: func printableValue(v reflect.Value) (any, bool) {
funcs.go#L66: var builtinFuncs = sync.OnceValue(func() map[string]reflect.Value {
funcs.go#L68: m := make(map[string]reflect.Value, len(funcMap))
funcs.go#L74: func addValueFuncs(out map[string]reflect.Value, in FuncMap) {
funcs.go#L131: func findFunction(name string, tmpl *Template) (v reflect.Value, isBuiltin, ok bool) {
funcs.go#L142: return reflect.Value{}, false, false
funcs.go#L147: func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
funcs.go#L150: return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
funcs.go#L161: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L175: func indexArg(index reflect.Value, cap int) (int, error) {
funcs.go#L198: func index(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
funcs.go#L201: return reflect.Value{}, fmt.Errorf("index of untyped nil")
funcs.go#L207: return reflect.Value{}, fmt.Errorf("index of nil pointer")
funcs.go#L213: return reflect.Value{}, err
funcs.go#L219: return reflect.Value{}, err
funcs.go#L230: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L242: func slice(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
funcs.go#L245: return reflect.Value{}, fmt.Errorf("slice of untyped nil")
funcs.go#L249: return reflect.Value{}, fmt.Errorf("slice of nil pointer")
funcs.go#L252: return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
funcs.go#L258: return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
funcs.go#L264: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L271: return reflect.Value{}, err
funcs.go#L277: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
funcs.go#L284: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
funcs.go#L292: func length(item reflect.Value) (int, error) {
funcs.go#L306: func emptyCall(fn reflect.Value, args ...reflect.Value) reflect.Value {
funcs.go#L312: func call(name string, fn reflect.Value, args ...reflect.Value) (reflect.Value, error) {
funcs.go#L315: return reflect.Value{}, fmt.Errorf("call of nil")
funcs.go#L319: return reflect.Value{}, fmt.Errorf("non-function %s of type %s", name, typ)
funcs.go#L323: return reflect.Value{}, err
funcs.go#L329: return reflect.Value{}, fmt.Errorf("wrong number of args for %s: got %d want at least %d", name, len(args), numIn-1)
funcs.go#L334: return reflect.Value{}, fmt.Errorf("wrong number of args for %s: got %d want %d", name, len(args), numIn)
funcs.go#L337: argv := make([]reflect.Value, len(args))
funcs.go#L348: return reflect.Value{}, fmt.Errorf("arg %d: %w", i, err)
funcs.go#L356: func safeCall(fun reflect.Value, args []reflect.Value) (val reflect.Value, err error) {
funcs.go#L375: func truth(arg reflect.Value) bool {
funcs.go#L382: func and(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
funcs.go#L388: func or(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
funcs.go#L393: func not(arg reflect.Value) bool {
funcs.go#L418: func basicKind(v reflect.Value) (kind, error) {
funcs.go#L437: func isNil(v reflect.Value) bool {
funcs.go#L450: func canCompare(v1, v2 reflect.Value) bool {
funcs.go#L461: func eq(arg1 reflect.Value, arg2 ...reflect.Value) (bool, error) {
funcs.go#L519: func ne(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L526: func lt(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L568: func le(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L578: func gt(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L588: func ge(arg1, arg2 reflect.Value) (bool, error) {
template.go#L24: execFuncs map[string]reflect.Value
template.go#L76: c.execFuncs = make(map[string]reflect.Value)