It's a complex issue because unsafe.Sizeof is defined to return a compile-time constant. That implies that it's OK to write [unsafe.Sizeof(T)]byte. And that carries some complex implications for the implementation. So at least for now I think we do not permit unsafe.Sizeof on generic types.

Because I don't think this is an issue with cmd/go2go, I'm going to close this issue. This is something to bring up during or after the discussion of the generics proposal itself.

Thanks @ianlancetaylor for the explanation. FYI, my use case for this was that I was trying to write a generic function to obtain the exact index of a pointer to an element in a slice:

// IndexPointer returns the index of the element in s that is exactly identical to p,
// or -1 if p is not present in s.
func IndexPointer[T any](s []T, p *T) int {
	if len(s) == 0 || p == nil {
		return -1
	}
	if &s[0] == p {
		return 0 // handles the special case where unsafe.Sizeof(T) is zero
	}
	var t T
	offset := uintptr(unsafe.Pointer(p)) - uintptr(unsafe.Pointer(&s[0]))
	index := offset / unsafe.Sizeof(t)
	if index < uintptr(len(s)) && &s[index] == p {
		return int(index)
	}
	return -1
}

Without the use of unsafe, I don't believe there is a way to do the above in O(1), the best in O(n):

func IndexPointer[T any](s []T, p *T) int {
	for i := range s {
		if &s[i] == p {
			return i
		}
	}
	return -1
}

There have been several times where I needed an operation like this, and it would be nice if a standard library function in Go 2 provided it.

How about reflect.TypeOf(t).Size()?

Possibly a duplicate of #40301

Yes, this is essentially #40301; thanks @AndrewWPhillips .