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.

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?

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()))

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).

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.

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

Slice is already taken as a Kind.

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

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

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.

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

This proposal has been added to the active column of the proposals project
and will now be reviewed at the weekly proposal review meetings.
— rsc for the proposal review group

Have all remaining concerns about this proposal been addressed?

Two parts to the proposal.

First, add func UnsafeSlice, mimicking unsafe.Slice.

Second, update Value.Pointer and Value.UnsafePointer to handle String.

I don't think the signature concern in #61308 (comment) has been addressed yet.

The other functions and methods in the reflect package that use the word Unsafe still explicitly require the use of the unsafe package, but

func Slice(vp Value, n int) Value

(as described in #61308 (comment)) does not have that property.

I'm not sure that's quite true of the existing reflect.Value.UnsafePointer method, which does return a value of type unsafe.Pointer but can be used without importing the unsafe package.

Note that the proposed function is now named UnsafeSlice rather than Slice.

I also prefer @bcmills ' alternate signature. It has the clear advantage of using unsafe.Pointer, and I suspect in practice it will be more common that callers will have an unsafe.Pointer already, rather than a Value, so it will save the conversion (though they can convert either way).

Have all remaining concerns about this proposal been addressed?

Two parts to the proposal.

First, add func SliceAt, analogous to NewAt (which probably should have been called ValueAt) but for slices:

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

Second, update Value.Pointer and Value.UnsafePointer to handle String.

Based on the discussion above, this proposal seems like a likely accept.
— rsc for the proposal review group

Two parts to the proposal.

First, add func SliceAt, analogous to NewAt (which probably should have been called ValueAt) but for slices:

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

Second, update Value.Pointer and Value.UnsafePointer to handle String.

Change https://go.dev/cl/572117 mentions this issue: reflect: Value.Pointer and Value.UnsafePointer handle String

Change https://go.dev/cl/572118 mentions this issue: reflect: add SliceAt

Does reflect.SliceAt do all the runtime validations that unsafe.Slice do? For example, should this code panic?

_ = SliceAt(TypeOf(0), unsafe.Pointer((*int)(nil)), 1)

Yes, reflect.SliceAt should be no more unsafe than unsafe.Slice. So it should do the same validations.

No change in consensus, so accepted. 🎉
This issue now tracks the work of implementing the proposal.
— rsc for the proposal review group

Two parts to the proposal.

First, add func SliceAt, analogous to NewAt (which probably should have been called ValueAt) but for slices:

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

Second, update Value.Pointer and Value.UnsafePointer to handle String.

Change https://go.dev/cl/575956 mentions this issue: reflect: add missing String case in Value.UnsafePointer doc