aboutsummaryrefslogtreecommitdiff
path: root/src/reflect
diff options
context:
space:
mode:
Diffstat (limited to 'src/reflect')
-rw-r--r--src/reflect/all_test.go228
-rw-r--r--src/reflect/asm_amd64.s12
-rw-r--r--src/reflect/deepequal.go12
-rw-r--r--src/reflect/type.go53
-rw-r--r--src/reflect/value.go44
5 files changed, 307 insertions, 42 deletions
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 5a12699472..b01158635f 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -2405,8 +2405,14 @@ func TestVariadicMethodValue(t *testing.T) {
points := []Point{{20, 21}, {22, 23}, {24, 25}}
want := int64(p.TotalDist(points[0], points[1], points[2]))
+ // Variadic method of type.
+ tfunc := TypeOf((func(Point, ...Point) int)(nil))
+ if tt := TypeOf(p).Method(4).Type; tt != tfunc {
+ t.Errorf("Variadic Method Type from TypeOf is %s; want %s", tt, tfunc)
+ }
+
// Curried method of value.
- tfunc := TypeOf((func(...Point) int)(nil))
+ tfunc = TypeOf((func(...Point) int)(nil))
v := ValueOf(p).Method(4)
if tt := v.Type(); tt != tfunc {
t.Errorf("Variadic Method Type is %s; want %s", tt, tfunc)
@@ -4001,9 +4007,12 @@ var convertTests = []struct {
{V(int16(-3)), V(string("\uFFFD"))},
{V(int32(-4)), V(string("\uFFFD"))},
{V(int64(-5)), V(string("\uFFFD"))},
+ {V(int64(-1 << 32)), V(string("\uFFFD"))},
+ {V(int64(1 << 32)), V(string("\uFFFD"))},
{V(uint(0x110001)), V(string("\uFFFD"))},
{V(uint32(0x110002)), V(string("\uFFFD"))},
{V(uint64(0x110003)), V(string("\uFFFD"))},
+ {V(uint64(1 << 32)), V(string("\uFFFD"))},
{V(uintptr(0x110004)), V(string("\uFFFD"))},
// named string
@@ -4259,24 +4268,6 @@ var gFloat32 float32
func TestConvertNaNs(t *testing.T) {
const snan uint32 = 0x7f800001
-
- // Test to see if a store followed by a load of a signaling NaN
- // maintains the signaling bit. The only platform known to fail
- // this test is 386,GO386=387. The real test below will always fail
- // if the platform can't even store+load a float without mucking
- // with the bits.
- gFloat32 = math.Float32frombits(snan)
- runtime.Gosched() // make sure we don't optimize the store/load away
- r := math.Float32bits(gFloat32)
- if r != snan {
- // This should only happen on 386,GO386=387. We have no way to
- // test for 387, so we just make sure we're at least on 386.
- if runtime.GOARCH != "386" {
- t.Errorf("store/load of sNaN not faithful")
- }
- t.Skip("skipping test, float store+load not faithful")
- }
-
type myFloat32 float32
x := V(myFloat32(math.Float32frombits(snan)))
y := x.Convert(TypeOf(float32(0)))
@@ -6006,6 +5997,14 @@ func TestReflectMethodTraceback(t *testing.T) {
}
}
+func TestSmallZero(t *testing.T) {
+ type T [10]byte
+ typ := TypeOf(T{})
+ if allocs := testing.AllocsPerRun(100, func() { Zero(typ) }); allocs > 0 {
+ t.Errorf("Creating small zero values caused %f allocs, want 0", allocs)
+ }
+}
+
func TestBigZero(t *testing.T) {
const size = 1 << 10
var v [size]byte
@@ -6017,6 +6016,27 @@ func TestBigZero(t *testing.T) {
}
}
+func TestZeroSet(t *testing.T) {
+ type T [16]byte
+ type S struct {
+ a uint64
+ T T
+ b uint64
+ }
+ v := S{
+ a: 0xaaaaaaaaaaaaaaaa,
+ T: T{9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9},
+ b: 0xbbbbbbbbbbbbbbbb,
+ }
+ ValueOf(&v).Elem().Field(1).Set(Zero(TypeOf(T{})))
+ if v != (S{
+ a: 0xaaaaaaaaaaaaaaaa,
+ b: 0xbbbbbbbbbbbbbbbb,
+ }) {
+ t.Fatalf("Setting a field to a Zero value didn't work")
+ }
+}
+
func TestFieldByIndexNil(t *testing.T) {
type P struct {
F int
@@ -7148,6 +7168,176 @@ func TestMapIterDelete1(t *testing.T) {
}
}
+func TestStructTagLookup(t *testing.T) {
+ var tests = []struct {
+ tag StructTag
+ key string
+ expectedValue string
+ expectedOK bool
+ }{
+ {
+ tag: `json:"json_value_1"`,
+ key: "json",
+ expectedValue: "json_value_1",
+ expectedOK: true,
+ },
+ {
+ tag: `json:"json_value_2" xml:"xml_value_2"`,
+ key: "json",
+ expectedValue: "json_value_2",
+ expectedOK: true,
+ },
+ {
+ tag: `json:"json_value_3" xml:"xml_value_3"`,
+ key: "xml",
+ expectedValue: "xml_value_3",
+ expectedOK: true,
+ },
+ {
+ tag: `bson json:"shared_value_4"`,
+ key: "json",
+ expectedValue: "shared_value_4",
+ expectedOK: true,
+ },
+ {
+ tag: `bson json:"shared_value_5"`,
+ key: "bson",
+ expectedValue: "shared_value_5",
+ expectedOK: true,
+ },
+ {
+ tag: `json bson xml form:"field_1,omitempty" other:"value_1"`,
+ key: "xml",
+ expectedValue: "field_1,omitempty",
+ expectedOK: true,
+ },
+ {
+ tag: `json bson xml form:"field_2,omitempty" other:"value_2"`,
+ key: "form",
+ expectedValue: "field_2,omitempty",
+ expectedOK: true,
+ },
+ {
+ tag: `json bson xml form:"field_3,omitempty" other:"value_3"`,
+ key: "other",
+ expectedValue: "value_3",
+ expectedOK: true,
+ },
+ {
+ tag: `json bson xml form:"field_4" other:"value_4"`,
+ key: "json",
+ expectedValue: "field_4",
+ expectedOK: true,
+ },
+ {
+ tag: `json bson xml form:"field_5" other:"value_5"`,
+ key: "non_existing",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: `json "json_6"`,
+ key: "json",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: `json:"json_7" bson "bson_7"`,
+ key: "json",
+ expectedValue: "json_7",
+ expectedOK: true,
+ },
+ {
+ tag: `json:"json_8" xml "xml_8"`,
+ key: "xml",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: `json bson xml form "form_9" other:"value_9"`,
+ key: "bson",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: `json bson xml form "form_10" other:"value_10"`,
+ key: "other",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: `json bson xml form:"form_11" other "value_11"`,
+ key: "json",
+ expectedValue: "form_11",
+ expectedOK: true,
+ },
+ {
+ tag: `tag1`,
+ key: "tag1",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: `tag2 :"hello_2"`,
+ key: "tag2",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: `tag3: "hello_3"`,
+ key: "tag3",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: "json\x7fbson: \"hello_4\"",
+ key: "json",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: "json\x7fbson: \"hello_5\"",
+ key: "bson",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: "json bson:\x7f\"hello_6\"",
+ key: "json",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: "json bson:\x7f\"hello_7\"",
+ key: "bson",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: "json\x09bson:\"hello_8\"",
+ key: "json",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ {
+ tag: "a\x7fb json:\"val\"",
+ key: "json",
+ expectedValue: "",
+ expectedOK: false,
+ },
+ }
+
+ for _, test := range tests {
+ v, ok := test.tag.Lookup(test.key)
+ if v != test.expectedValue {
+ t.Errorf("struct tag lookup failed, got %s, want %s", v, test.expectedValue)
+ }
+ if ok != test.expectedOK {
+ t.Errorf("struct tag lookup failed, got %t, want %t", ok, test.expectedOK)
+ }
+ }
+}
+
// iterateToString returns the set of elements
// returned by an iterator in readable form.
func iterateToString(it *MapIter) string {
diff --git a/src/reflect/asm_amd64.s b/src/reflect/asm_amd64.s
index fb28ab87f1..5c8e56558c 100644
--- a/src/reflect/asm_amd64.s
+++ b/src/reflect/asm_amd64.s
@@ -9,7 +9,9 @@
// See the comment on the declaration of makeFuncStub in makefunc.go
// for more details.
// No arg size here; runtime pulls arg map out of the func value.
-TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
+// makeFuncStub must be ABIInternal because it is placed directly
+// in function values.
+TEXT ·makeFuncStub<ABIInternal>(SB),(NOSPLIT|WRAPPER),$32
NO_LOCAL_POINTERS
MOVQ DX, 0(SP)
LEAQ argframe+0(FP), CX
@@ -17,14 +19,16 @@ TEXT ·makeFuncStub(SB),(NOSPLIT|WRAPPER),$32
MOVB $0, 24(SP)
LEAQ 24(SP), AX
MOVQ AX, 16(SP)
- CALL ·callReflect(SB)
+ CALL ·callReflect<ABIInternal>(SB)
RET
// methodValueCall is the code half of the function returned by makeMethodValue.
// See the comment on the declaration of methodValueCall in makefunc.go
// for more details.
// No arg size here; runtime pulls arg map out of the func value.
-TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
+// methodValueCall must be ABIInternal because it is placed directly
+// in function values.
+TEXT ·methodValueCall<ABIInternal>(SB),(NOSPLIT|WRAPPER),$32
NO_LOCAL_POINTERS
MOVQ DX, 0(SP)
LEAQ argframe+0(FP), CX
@@ -32,5 +36,5 @@ TEXT ·methodValueCall(SB),(NOSPLIT|WRAPPER),$32
MOVB $0, 24(SP)
LEAQ 24(SP), AX
MOVQ AX, 16(SP)
- CALL ·callMethod(SB)
+ CALL ·callMethod<ABIInternal>(SB)
RET
diff --git a/src/reflect/deepequal.go b/src/reflect/deepequal.go
index be66464129..d951d8d999 100644
--- a/src/reflect/deepequal.go
+++ b/src/reflect/deepequal.go
@@ -35,7 +35,17 @@ func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool {
// and it's safe and valid to get Value's internal pointer.
hard := func(v1, v2 Value) bool {
switch v1.Kind() {
- case Map, Slice, Ptr, Interface:
+ case Ptr:
+ if v1.typ.ptrdata == 0 {
+ // go:notinheap pointers can't be cyclic.
+ // At least, all of our current uses of go:notinheap have
+ // that property. The runtime ones aren't cyclic (and we don't use
+ // DeepEqual on them anyway), and the cgo-generated ones are
+ // all empty structs.
+ return false
+ }
+ fallthrough
+ case Map, Slice, Interface:
// Nil pointers cannot be cyclic. Avoid putting them in the visited map.
return !v1.IsNil() && !v2.IsNil()
}
diff --git a/src/reflect/type.go b/src/reflect/type.go
index 44c96fea82..1f1e70d485 100644
--- a/src/reflect/type.go
+++ b/src/reflect/type.go
@@ -50,13 +50,13 @@ type Type interface {
// It panics if i is not in the range [0, NumMethod()).
//
// For a non-interface type T or *T, the returned Method's Type and Func
- // fields describe a function whose first argument is the receiver.
+ // fields describe a function whose first argument is the receiver,
+ // and only exported methods are accessible.
//
// For an interface type, the returned Method's Type field gives the
// method signature, without a receiver, and the Func field is nil.
//
- // Only exported methods are accessible and they are sorted in
- // lexicographic order.
+ // Methods are sorted in lexicographic order.
Method(int) Method
// MethodByName returns the method with that name in the type's
@@ -69,7 +69,9 @@ type Type interface {
// method signature, without a receiver, and the Func field is nil.
MethodByName(string) (Method, bool)
- // NumMethod returns the number of exported methods in the type's method set.
+ // NumMethod returns the number of methods accessible using Method.
+ //
+ // Note that NumMethod counts unexported methods only for interface types.
NumMethod() int
// Name returns the type's name within its package for a defined type.
@@ -1102,12 +1104,16 @@ type StructField struct {
// A StructTag is the tag string in a struct field.
//
-// By convention, tag strings are a concatenation of
-// optionally space-separated key:"value" pairs.
-// Each key is a non-empty string consisting of non-control
-// characters other than space (U+0020 ' '), quote (U+0022 '"'),
-// and colon (U+003A ':'). Each value is quoted using U+0022 '"'
-// characters and Go string literal syntax.
+// By convention, tag strings are a mapping of keys to values.
+// The format is key:"value". Each key is a non-empty string consisting
+// of non-control characters other than space (U+0020 ' '),
+// quote (U+0022 '"'), and colon (U+003A ':'). Each value is quoted
+// using U+0022 '"' characters and Go string literal syntax.
+// Multiple key-value mappings are separated by zero or more spaces, as in
+// key1:"value1" key2:"value2"
+// Multiple keys may map to a single shared value by separating the keys
+// with spaces, as in
+// key1 key2:"value"
type StructTag string
// Get returns the value associated with key in the tag string.
@@ -1130,6 +1136,9 @@ func (tag StructTag) Lookup(key string) (value string, ok bool) {
// When modifying this code, also update the validateStructTag code
// in cmd/vet/structtag.go.
+ // keyFound indicates that such key on the left side has already been found.
+ var keyFound bool
+
for tag != "" {
// Skip leading space.
i := 0
@@ -1149,11 +1158,29 @@ func (tag StructTag) Lookup(key string) (value string, ok bool) {
for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f {
i++
}
- if i == 0 || i+1 >= len(tag) || tag[i] != ':' || tag[i+1] != '"' {
+ if i == 0 || i+1 >= len(tag) || tag[i] < ' ' || tag[i] == 0x7f {
break
}
name := string(tag[:i])
- tag = tag[i+1:]
+ tag = tag[i:]
+
+ // If we found a space char here - assume that we have a tag with
+ // multiple keys.
+ if tag[0] == ' ' {
+ if name == key {
+ keyFound = true
+ }
+ continue
+ }
+
+ // Spaces were filtered above so we assume that here we have
+ // only valid tag value started with `:"`.
+ if tag[0] != ':' || tag[1] != '"' {
+ break
+ }
+
+ // Remove the colon leaving tag at the start of the quoted string.
+ tag = tag[1:]
// Scan quoted string to find value.
i = 1
@@ -1169,7 +1196,7 @@ func (tag StructTag) Lookup(key string) (value string, ok bool) {
qvalue := string(tag[:i+1])
tag = tag[i+1:]
- if key == name {
+ if key == name || keyFound {
value, err := strconv.Unquote(qvalue)
if err != nil {
break
diff --git a/src/reflect/value.go b/src/reflect/value.go
index c6f24a5609..1f185b52e4 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -90,6 +90,7 @@ func (f flag) ro() flag {
// pointer returns the underlying pointer represented by v.
// v.Kind() must be Ptr, Map, Chan, Func, or UnsafePointer
+// if v.Kind() == Ptr, the base type must not be go:notinheap.
func (v Value) pointer() unsafe.Pointer {
if v.typ.size != ptrSize || !v.typ.pointers() {
panic("can't call pointer on a non-pointer Value")
@@ -1452,7 +1453,16 @@ func (v Value) Pointer() uintptr {
// TODO: deprecate
k := v.kind()
switch k {
- case Chan, Map, Ptr, UnsafePointer:
+ case Ptr:
+ if v.typ.ptrdata == 0 {
+ // Handle pointers to go:notinheap types directly,
+ // so we never materialize such pointers as an
+ // unsafe.Pointer. (Such pointers are always indirect.)
+ // See issue 42076.
+ return *(*uintptr)(v.ptr)
+ }
+ fallthrough
+ case Chan, Map, UnsafePointer:
return uintptr(v.pointer())
case Func:
if v.flag&flagMethod != 0 {
@@ -1553,7 +1563,11 @@ func (v Value) Set(x Value) {
}
x = x.assignTo("reflect.Set", v.typ, target)
if x.flag&flagIndir != 0 {
- typedmemmove(v.typ, v.ptr, x.ptr)
+ if x.ptr == unsafe.Pointer(&zeroVal[0]) {
+ typedmemclr(v.typ, v.ptr)
+ } else {
+ typedmemmove(v.typ, v.ptr, x.ptr)
+ }
} else {
*(*unsafe.Pointer)(v.ptr) = x.ptr
}
@@ -2360,11 +2374,23 @@ func Zero(typ Type) Value {
t := typ.(*rtype)
fl := flag(t.Kind())
if ifaceIndir(t) {
- return Value{t, unsafe_New(t), fl | flagIndir}
+ var p unsafe.Pointer
+ if t.size <= maxZero {
+ p = unsafe.Pointer(&zeroVal[0])
+ } else {
+ p = unsafe_New(t)
+ }
+ return Value{t, p, fl | flagIndir}
}
return Value{t, nil, fl}
}
+// must match declarations in runtime/map.go.
+const maxZero = 1024
+
+//go:linkname zeroVal runtime.zeroVal
+var zeroVal [maxZero]byte
+
// New returns a Value representing a pointer to a new zero value
// for the specified type. That is, the returned Value's Type is PtrTo(typ).
func New(typ Type) Value {
@@ -2655,12 +2681,20 @@ func cvtComplex(v Value, t Type) Value {
// convertOp: intXX -> string
func cvtIntString(v Value, t Type) Value {
- return makeString(v.flag.ro(), string(rune(v.Int())), t)
+ s := "\uFFFD"
+ if x := v.Int(); int64(rune(x)) == x {
+ s = string(rune(x))
+ }
+ return makeString(v.flag.ro(), s, t)
}
// convertOp: uintXX -> string
func cvtUintString(v Value, t Type) Value {
- return makeString(v.flag.ro(), string(rune(v.Uint())), t)
+ s := "\uFFFD"
+ if x := v.Uint(); uint64(rune(x)) == x {
+ s = string(rune(x))
+ }
+ return makeString(v.flag.ro(), s, t)
}
// convertOp: []byte -> string
generated by cgit v1.3 (git 2.53.0) at 2026-04-16 00:59:39 +0000