Adds Compiler support for remaining Array methods - sort, reduce, and more

[lourd]

Summary

Was discussing some unexpected bailouts I'd run into with the Compiler with @josephsavona on Bluesky https://bsky.app/profile/en-js.bsky.social/post/3lrlh3rdbok2s and he kindly pointed me towards where I could fix them myself 😄

These changes cover the cases of using array methods like sort in a useMemo, the Compiler will keep them memoized and won't bail on optimizing the component as is the current behavior.

How did you test this change?

• Ran the Playground app locally and tested that patterns that would get bailed on before now didn't
• Added Compiler test fixtures, updating the expected fixtures after running the tests. I don't think I got this part quite right, I don't know why the "(kind: exception) Fixture not implemented" section at the end of all of them is there. I didn't add them for every single array method I added, either.

[poteto]

Thanks for contributing!

[josephsavona]

This is a great start! Great job paying attention to the details on how each of these functions may affect the operands and which effects to use. There are a few cases that look like they might need to be addressed. Also, we'll need to make the tests more thorough to ensure that mutation of return values of these functions is correctly connected to mutation of the values within the original array.

I'm also happy to help, this type of testing can definitely be tedious.

[josephsavona]

this is subtle, but the behavior of fill(value, start, end) is that value is stored into the array (Effect.Capture), while the rest of the args are just read. So a more precise declaration would be:

positionalParams: [Effect.Capture],
restParam: Effect.Read,

[josephsavona]

These need calleeEffect: Effect.Capture since the items of the original array can be modified through the returned array

[josephsavona]

let's be precise here too, it's with(index, value) so: positionalParams: [Effect.Read, Effect.Capture]

[josephsavona]

For the tests, it isn't sufficient to check that the useeMemo is preserved. We also have to check if the result of calling the function propagates mutability in the correct way. For example, we should add a varaint of this fixture (array-to-sorted-mutate) that mutates the result of toStorted. Something like:

function Component(props) {
  const sorted = useMemo(() => {
    const array = [{value: 'c'}, {value: 'b'}, {value: 'a'}];
    const sorted = array.toSorted();
    mutate(sorted, props.value);
    return sorted;
  }, [props.value]);
  return <ValidateMemoization inputs={[props.value]} output={sorted} />;
}