Express ArrayList in ArrayListUnmanaged operations

[Snektron]

I came across several issues in ArrayListUnmanaged, namely:

• An error in initCapacity which was introduced in std: Don't trust stat() size in readAllAlloc fns #6232

  zig/lib/std/array_list.zig

  Line 374 in 7d487a4

  const new_memory = try self.allocator.allocAdvanced(T, alignment, num, .at_least);

• An error in replaceRange introduced in add replaceRange() function to ArrayList #5511

  zig/lib/std/array_list.zig

  Line 422 in 7d487a4

  pub fn replaceRange(self: *Self, start: usize, len: usize, new_items: SliceConst) !void {

This PR changes the implementation of ArrayList to use that of ArrayListUnmanaged wherever possible, which ensures that the implementation of ArrayListUnmanaged and ArrayList are the same. The original test cases now also test ArrayListUnmanaged. Furthermore, this reduces code duplication in the standard library.

Note that i've changed ArrayList.deinit to require *Self like other std containers. I've changed constness of ArrayList wherever required.

Currently, most calls to ArrayListUnmanaged are called like

var unmanaged = self.toUnmanaged();
defer self.* = unmanaged.toManaged(self.allocator);
return unmanaged.addOne(self.allocator);

I hope that this is optimization/result location friendly, i haven't done any benchmarking.

[Vexu]

Should this be changed to

        unmanaged: Unmanaged,
        allocator: *Allocator,

to make it more consistent with ArrayHashMap and HashMap?

[Snektron]

I agree that this would be the most elegant solution, if the fields of the array list weren't part of the interface. Users are encouraged to directly refer to items in the ArrayList by using .items[index], and changing this would be a big breaking change.

[marler8997]

This along with other use cases makes me think it might be useful for Zig to have a way to declare aliases. For example:

    pub alias items = unmanaged.items;

This would mean code that references array_list.items would be equivalent to array_list.unmanaged.items.

[daurnimator]

Currently, most calls to ArrayListUnmanaged are called like

var unmanaged = self.toUnmanaged();
defer self.* = unmanaged.toManaged(self.allocator);
return unmanaged.addOne(self.allocator);

I hope that this is optimization/result location friendly, i haven't done any benchmarking.

My intuition is that this wouldn't be well optimized; e.g. you'd end up writing self.allocator needlessly each operation.

[Snektron]

After discussing with Andrew a few days ago, it was decided that ArrayList/ArrayListUnmanaged should be one of the few places where code is copy pasted. The argumentation was that this yields a smaller call stack (which is nice considering these types are used fairly fundamentally), that the implementation of these types is fairly self-contained anyway, and @daurnimator's optimization point above.

So instead of my solution, there should be some generic testing function (although i'm not quite sure how that would be implemented best). One idea is to have a mixin for the operations that don't have any allocations, although i don't think there are very many.

Thoughts?

[Snektron]

Closing in favor of #6457