reflect: add SliceAt function

[ianlancetaylor]

In Go 1.21 we are introducing some new functions in the unsafe package: unsafe.Slice, unsafe.SliceData, unsafe.String, unsafe.StringData. It should be possible to access this functionality through the reflect package as well.

The value returned by unsafe.SliceData is already available by calling the reflect.Value.Pointer method.

I propose that we extend reflect.Value.Pointer so that if it is called on a value of kind String, it returns the equivalent of unsafe.StringData.

The equivalent to unsafe.String is simply reflect.ValueOf(unsafe.String((*byte)(vp.UnsafePointer()), n)), so I don't think we need to add anything for that.

I propose one new function:

package reflect

// UnsafeSlice returns a Value representing a slice whose underlying data starts at vp,
// with length and capacity equal to n. vp.Kind() must be Pointer.
// The returned slice will have element type vp.Type().Elem().
// This is like unsafe.Slice.
func UnsafeSlice(vp Value, n int) Value

(edited to change function name from Slice to UnsafeSlice`)

[bcmills]

It seems to me that the new functionality is to MakeSlice as NewAt is to New. So I suggest:

func SliceAt(typ Type, p unsafe.Pointer, len int) Value

That has the additional advantage of passing through the type unsafe.Pointer, which clarifies that it is in fact unsafe.

[rittneje]

Why does the proposed reflect.Slice (or reflect.SliceAt) require the length and capacity to be the same instead of having two separate parameters like reflect.MakeSlice?

[DeedleFake]

Those functions were introduced starting in 1.17 and then more in 1.20.

The equivalent to unsafe.String is simply reflect.ValueOf(unsafe.String(vp.Pointer(), n)), so I don't think we need to add anything for that.

That won't work. unsafe.String() requires a *byte, not a uintptr. The conversion requires first converting through an unsafe.Pointer, so I think having an equivalent top-level function makes sense for that one, too. It's not really any different from a slice otherwise except for the type always being the same:

reflect.ValueOf(unsafe.String((*byte)(unsafe.Pointer(v.Pointer())), v.Len()))
reflect.ValueOf(unsafe.Slice((*T)(unsafe.Pointer(v.Pointer())), v.Len()))

[bcmills]

Why does the proposed reflect.Slice (or reflect.SliceAt) require the length and capacity to be the same … ?

Because unsafe.Slice does too. Most of the time you do want them to be the same, and if you want to reduce the capacity that's easy enough to do as a separate operation (via SetCap).

[bcmills]

For the string case,

reflect.ValueOf(unsafe.String(v.Interface().(*byte), v.Len()))

or

reflect.ValueOf(unsafe.String((*byte)(v.UnsafePointer()), v.Len()))

will often suffice.

[cuonglm]

I think the function name should be UnsafeSlice instead of Slice.

Slice is already taken as a Kind.

[gopherbot]

Change https://go.dev/cl/516597 mentions this issue: reflect: add UnsafeSlice

[gopherbot]

Change https://go.dev/cl/516596 mentions this issue: reflect: handle String kind in Value.Pointer

[rsc]

I think the function name should be UnsafeSlice instead of Slice.
Slice is already taken as a Kind.

Another reason is that these are in fact unsafe, so the name should begin with Unsafe to distinguish it from the normal, safe reflect API.

[rsc]

It seems like we should also update UnsafePointer to handle String (not just update Pointer).