spec: Conversions_from_slice_to_array_pointer: clarify behavior for subslices

[nevkontakte]

Currently the spec says the following:

go/doc/go_spec.html

Lines 4324 to 4326 in 72ab3ff

	Converting a slice to an array pointer yields a pointer to the underlying array of the slice.
	If the <a href="#Length_and_capacity">length</a> of the slice is less than the length of the array,
	a <a href="#Run_time_panics">run-time panic</a> occurs.

However, it is not clear what "underlying array" should mean for a slice created as a subslice of another array. Consider the following code:

v := make([]byte, 4)
v0 := (*[2]byte)(v[2:4])

Several interpretations are possible:

1. Operation allowed, &v0[0] == &v[2].
2. Operation panics because v[2:4] doesn't point at the beginning of the v's underlying array.
3. Operation allowed, &v0[0] == &v[0], since the "underlying array" is interpreted as the block of memory that was originally allocated for v. This is perhaps counter-intuitive, but not prohibited by the spec.

In my experimentation #1 is the actual behavior, and it makes sense, since in a general case the user has no way of knowing whether a slice is sharing its underlying array with any other slice and how they may be overlapping. Formalizing it in the spec would be useful to ensure third-party Go implementations behave similarly.

CC @flimzy since it's relevant to gopherjs/gopherjs#1043.

[randall77]

One more example might help.

s1 := (*[1]byte)(s[1:]) // &s1[0] == &s[1]

[cuonglm]

While I agree with adding more example, I don't think the spec is not clear. In the "Slice Expressions" section, it's well defined what "underlying array" mean for subslice https://golang.org/ref/spec#Slice_expressions, example from the spec:

var a [10]int
s1 := a[3:7]   // underlying array of s1 is array a; &s1[2] == &a[5]
s2 := s1[1:4]  // underlying array of s2 is underlying array of s1 which is array a; &s2[1] == &a[5]
s2[1] = 42     // s2[1] == s1[2] == a[5] == 42; they all refer to the same underlying array element

[gopherbot]

Change https://golang.org/cl/340351 mentions this issue: doc: add example for conversion from slice expressions to array ptr

[nevkontakte]

@cuonglm arguably the way spec describes underlying array leaves the meaning of "yields a pointer to the underlying array of the slice" ambiguous. Paraphrasing the example you've referenced:

var a1 [10]int
s1 := a1[:]  // underlying array of s1 is a, &a1[0] == &s1[0]
s2 := s[5:] // underlying array of s2 is still a1 as per spec, but &a1[0] != &s2[0] and s2 doesn't contain information on where a1 begins.
a2 := (*[5]int)(s2) // not a pointer to a1: unsafe.Pointer(&a1) != unsafe.Pointer(a2)

So if a1 is considered to be the underlying array of both s2 and s1, then the conversion did not return a pointer to a1, it returned a pointer to inside of a1.

However, that's quite a nitpick on my part, and the additional example resolves the ambiguity. Thanks for a quick fix!