C++: handle cast arrays properly in off-by-one query

[rdmarsh2]

Previously, pointer arithmetic done using a different size than the original array were excluded in the constant size off-by-one query. This PR handles that case by using the byte length of the array and dividing by the element size at the pointer arithmetic.

This PR follows #13045 and #13116. Only 2b40498 is new.

[geoffw0]

LGTM (assuming the two PRs under it get merged first).

[geoffw0]

I had to convince myself rounding down here is the right thing to do, by considering some examples.

The pointer size is larger than the array element size:

char buffer[100]; // getByteSize() = 100
int *ptr = (int *)buffer; // pai.getElementSize() will be sizeof(int) = 4 -> size = 25

ptr[24] = ...; // writes bytes 96, 97, 98, 99 - GOOD
ptr[25] = ...; // writes bytes 100, 101, 102, 103 - BAD

The pointer size is smaller than the array element size but does not divide it:

struct vec2 {
	int x, y;
}

struct vec3 {
	int x, y, z;
}

vec3 array[3]; // getByteSize() = 9 * sizeof(int)
vec2 *ptr = (vec2 *)array; // pai.getElementSize() will be 2 * sizeof(int) -> size = 4

ptr[3] = ... // writes ints 6, 7 - OK
ptr[4] = ... // writes ints 8, 9 - BAD

The pointer size is larger than the array element size and does not divide it:

vec2 array[2]; // getByteSize() = 4 * sizeof(int)
vec3 *ptr = (vec3 *)array; // pai.getElementSize() will be 3 * sizeof(int) -> size = 1

ptr[0] = ... // writes ints 0, 1, 2 - OK
ptr[1] = ... // writes ints 3, 4, 5 - BAD

(my examples are untested, may be naive about struct padding)

[MathiasVP]

Thanks for those excellent testcases, Geoffrey! I've added them in 51176bd. It looks like we get the first two cases correct, but miss the last one. I haven't quite figured out why yet.

[MathiasVP]

Performance looks fine (even with the cartesian product we've identified) and the new result LGTM. Let's fix that missing result in @geoffw0's testcases at a later point.