reflect: implement NewAt

src/internal/reflectlite/value.go

@@ -2303,5 +2303,9 @@ func (v Value) Recv() (x Value, ok bool) {
 }
 
 func NewAt(typ Type, p unsafe.Pointer) Value {
-	panic("unimplemented: reflect.New()")
+	return Value{
+		typecode: pointerTo(typ.(*RawType)),
+		value:    p,
+		flags:    valueFlagExported,
+	}
 }

src/reflect/value.go

@@ -235,7 +235,7 @@ func (v Value) TryRecv() (x Value, ok bool) {
 }
 
 func NewAt(typ Type, p unsafe.Pointer) Value {
-	panic("unimplemented: reflect.New()")
+	return Value{reflectlite.NewAt(toRawType(typ), p)}
 }
 
 // Deprecated: Use unsafe.Slice or unsafe.SliceData instead.

src/reflect/value_test.go

@@ -11,6 +11,7 @@ import (
 	"sort"
 	"strings"
 	"testing"
+	"unsafe"
 )
 
 func TestTinyIndirectPointers(t *testing.T) {
@@ -45,6 +46,52 @@ func TestTinyInvalidValueString(t *testing.T) {
 	}
 }
 
+func TestNewAt(t *testing.T) {
+	value := 42
+	v := NewAt(TypeOf(value), unsafe.Pointer(&value))
+	if got, want := v.Type(), TypeOf((*int)(nil)); got != want {
+		t.Fatalf("NewAt type = %v, want %v", got, want)
+	}
+	if got := v.Interface().(*int); got != &value {
+		t.Fatalf("NewAt pointer = %p, want %p", got, &value)
+	}
+	v.Elem().SetInt(23)
+	if value != 23 {
+		t.Fatalf("NewAt value = %d, want 23", value)
+	}
+	if !v.Elem().CanAddr() || !v.Elem().CanSet() {
+		t.Fatal("NewAt element is not addressable and settable")
+	}
+	if got := v.Elem().Addr().Interface(); got != v.Interface() {
+		t.Fatalf("address of NewAt element = %v, want %v", got, v.Interface())
+	}
+
+	type composite struct {
+		Value   int
+		Pointer *int
+	}
+	pointed := 1
+	compositeValue := composite{Value: 42, Pointer: &pointed}
+	compositePointer := NewAt(TypeOf(compositeValue), unsafe.Pointer(&compositeValue))
+	compositePointer.Elem().Field(0).SetInt(23)
+	if compositeValue.Value != 23 {
+		t.Fatalf("NewAt struct field = %d, want 23", compositeValue.Value)
+	}
+	other := 2
+	compositePointer.Elem().Field(1).Set(ValueOf(&other))
+	if compositeValue.Pointer != &other {
+		t.Fatalf("NewAt pointer field = %p, want %p", compositeValue.Pointer, &other)
+	}
+
+	nilValue := NewAt(TypeOf(value), nil)
+	if !nilValue.IsNil() {
+		t.Fatal("NewAt with nil pointer is not nil")
+	}
+	if nilValue.Elem().IsValid() {
+		t.Fatal("Elem of NewAt with nil pointer is valid")
+	}
+}
+
 func TestTinyMap(t *testing.T) {
 
 	m := make(map[string]int)