reflect: use cgo.Incomplete instead of go:notinheap in tests

go:notinheap will be replaced by runtime/internal/sys.NotInHeap, and for
longer term, we want to restrict all of its usages inside the runtime
package only.

Updates #46731

Change-Id: I267adc2a19f0dc8a1ed29b5b4aeec1a7dc7318d5
Reviewed-on: https://go-review.googlesource.com/c/go/+/421880
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Keith Randall <khr@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index 0398a5099d06edc110d17c47aa53f9fce3a13c65..69d537804943f86e773800e225beab2e5218a807 100644 (file)
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -8003,28 +8003,6 @@ func TestSetIter(t *testing.T) {
        }
 }
 
-//go:notinheap
-type nih struct{ x int }
-
-var global_nih = nih{x: 7}
-
-func TestNotInHeapDeref(t *testing.T) {
-       // See issue 48399.
-       v := ValueOf((*nih)(nil))
-       v.Elem()
-       shouldPanic("reflect: call of reflect.Value.Field on zero Value", func() { v.Elem().Field(0) })
-
-       v = ValueOf(&global_nih)
-       if got := v.Elem().Field(0).Int(); got != 7 {
-               t.Fatalf("got %d, want 7", got)
-       }
-
-       v = ValueOf((*nih)(unsafe.Pointer(new(int))))
-       shouldPanic("reflect: reflect.Value.Elem on an invalid notinheap pointer", func() { v.Elem() })
-       shouldPanic("reflect: reflect.Value.Pointer on an invalid notinheap pointer", func() { v.Pointer() })
-       shouldPanic("reflect: reflect.Value.UnsafePointer on an invalid notinheap pointer", func() { v.UnsafePointer() })
-}
-
 func TestMethodCallValueCodePtr(t *testing.T) {
        m := ValueOf(Point{}).Method(1)
        want := MethodValueCallCodePtr()

diff --git a/src/reflect/deepequal.go b/src/reflect/deepequal.go
index 50b436e5f6ec4548e78b27031075591996591d07..c898bc834aec5b5cf8dd56cedd7a05c26779a01a 100644 (file)
--- a/src/reflect/deepequal.go
+++ b/src/reflect/deepequal.go
@@ -40,9 +40,9 @@ func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool {
                switch v1.Kind() {
                case Pointer:
                        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
+                               // not-in-heap pointers can't be cyclic.
+                               // At least, all of our current uses of runtime/internal/sys.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

diff --git a/src/reflect/nih_test.go b/src/reflect/nih_test.go
new file mode 100644 (file)
index 0000000..f503939
--- /dev/null
+++ b/src/reflect/nih_test.go
@@ -0,0 +1,38 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build cgo
+
+package reflect_test
+
+import (
+       . "reflect"
+       "runtime/cgo"
+       "testing"
+       "unsafe"
+)
+
+type nih struct {
+       _ cgo.Incomplete
+       x int
+}
+
+var global_nih = nih{x: 7}
+
+func TestNotInHeapDeref(t *testing.T) {
+       // See issue 48399.
+       v := ValueOf((*nih)(nil))
+       v.Elem()
+       shouldPanic("reflect: call of reflect.Value.Field on zero Value", func() { v.Elem().Field(0) })
+
+       v = ValueOf(&global_nih)
+       if got := v.Elem().Field(1).Int(); got != 7 {
+               t.Fatalf("got %d, want 7", got)
+       }
+
+       v = ValueOf((*nih)(unsafe.Pointer(new(int))))
+       shouldPanic("reflect: reflect.Value.Elem on an invalid notinheap pointer", func() { v.Elem() })
+       shouldPanic("reflect: reflect.Value.Pointer on an invalid notinheap pointer", func() { v.Pointer() })
+       shouldPanic("reflect: reflect.Value.UnsafePointer on an invalid notinheap pointer", func() { v.UnsafePointer() })
+}

diff --git a/src/reflect/value.go b/src/reflect/value.go
index 3611a5a66c6694c7e0cae8f742132e25dd4f7b83..2589a6dd18149113e32310c20b151714c3987c2c 100644 (file)
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -92,7 +92,7 @@ func (f flag) ro() flag {
 
 // pointer returns the underlying pointer represented by v.
 // v.Kind() must be Pointer, Map, Chan, Func, or UnsafePointer
-// if v.Kind() == Pointer, the base type must not be go:notinheap.
+// if v.Kind() == Pointer, the base type must not be not-in-heap.
 func (v Value) pointer() unsafe.Pointer {
        if v.typ.size != goarch.PtrSize || !v.typ.pointers() {
                panic("can't call pointer on a non-pointer Value")
@@ -3156,7 +3156,7 @@ func New(typ Type) Value {
        t := typ.(*rtype)
        pt := t.ptrTo()
        if ifaceIndir(pt) {
-               // This is a pointer to a go:notinheap type.
+               // This is a pointer to a not-in-heap type.
                panic("reflect: New of type that may not be allocated in heap (possibly undefined cgo C type)")
        }
        ptr := unsafe_New(t)