Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

42798 0 0 Zig
Normal View History Raw
rename std lib files to new convention
2019-03-02 16:46:04 -05:00
const std = @import("std.zig");
move std/debug.zig to a subdirectory self hosted compiler parser tests do some fuzz testing
2017-12-23 22:08:53 -05:00
const debug = std.debug;
add CBuf to standard library and fix ability to take address of variables from other namespaces
2016-08-11 22:25:13 -07:00
const assert = debug.assert;
std.debug.assert: remove special case for test builds Previously, std.debug.assert would `@panic` in test builds, if the assertion failed. Now, it's always `unreachable`. This makes release mode test builds more accurately test the actual code that will be run. However this requires tests to call `std.testing.expect` rather than `std.debug.assert` to make sure output is correct. Here is the explanation of when to use either one, copied from the assert doc comments: Inside a test block, it is best to use the `std.testing` module rather than assert, because assert may not detect a test failure in ReleaseFast and ReleaseSafe mode. Outside of a test block, assert is the correct function to use. closes #1304
2019-02-08 18:18:47 -05:00
const testing = std.testing;
move std/debug.zig to a subdirectory self hosted compiler parser tests do some fuzz testing
2017-12-23 22:08:53 -05:00
const mem = std.mem;
std.ArrayList.ensureTotalCapacity: optimize and fix integer overflow Fixes #12099
2022-07-13 17:30:51 +04:30
const math = std.math;
add list implementation to standard library
2016-05-08 01:34:00 -07:00
const Allocator = mem.Allocator;
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
/// A contiguous, growable list of items in memory.
/// This is a wrapper around an array of T values. Initialize with `init`.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
///
/// This struct internally stores a `std.mem.Allocator` for memory management.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// To manually specify an allocator with each function call see `ArrayListUnmanaged`.
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 04:10:11 -05:00
pub fn ArrayList(comptime T: type) type {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return ArrayListAligned(T, null);
rendering source code without recursion
2017-12-10 19:40:46 -05:00
}
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// A contiguous, growable list of arbitrarily aligned items in memory.
/// This is a wrapper around an array of T values aligned to `alignment`-byte
/// addresses. If the specified alignment is `null`, then `@alignOf(T)` is used.
/// Initialize with `init`.
///
/// This struct internally stores a `std.mem.Allocator` for memory management.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// To manually specify an allocator with each function call see `ArrayListAlignedUnmanaged`.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn ArrayListAligned(comptime T: type, comptime alignment: ?u29) type {
align(@alignOf(T)) T does not force resolution of T
2019-08-30 14:53:44 -04:00
if (alignment) |a| {
if (a == @alignOf(T)) {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return ArrayListAligned(T, null);
align(@alignOf(T)) T does not force resolution of T
2019-08-30 14:53:44 -04:00
}
}
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
return struct {
remove `this`. add `@This()`. closes #1283
2018-09-13 16:34:33 -04:00
const Self = @This();
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Contents of the list. This field is intended to be accessed
/// directly.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
///
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Pointers to elements in this slice are invalidated by various
/// functions of this ArrayList in accordance with the respective
/// documentation. In all cases, "invalidated" means that the memory
/// has been passed to this allocator's resize or free function.
fix some std lib dependency loops
2019-08-26 11:23:25 -04:00
items: Slice,
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// How many T values this list can hold without allocating
/// additional memory.
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
capacity: usize,
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
allocator: Allocator,
add list implementation to standard library
2016-05-08 01:34:00 -07:00
fix some std lib dependency loops
2019-08-26 11:23:25 -04:00
pub const Slice = if (alignment) |a| ([]align(a) T) else []T;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
pub fn SentinelSlice(comptime s: T) type {
return if (alignment) |a| ([:s]align(a) T) else [:s]T;
}
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
/// Deinitialize with `deinit` or use `toOwnedSlice`.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn init(allocator: Allocator) Self {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
return Self{
remove type coercion from array values to references * Implements #3768. This is a sweeping breaking change that requires many (trivial) edits to Zig source code. Array values no longer coerced to slices; however one may use `&` to obtain a reference to an array value, which may then be coerced to a slice. * Adds `IrInstruction::dump`, for debugging purposes. It's useful to call to inspect the instruction when debugging Zig IR. * Fixes bugs with result location semantics. See the new behavior test cases, and compile error test cases. * Fixes bugs with `@typeInfo` not properly resolving const values. * Behavior tests are passing but std lib tests are not yet. There is more work to do before merging this branch.
2019-11-27 03:30:39 -05:00
.items = &[_]T{},
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
.capacity = 0,
IR: add FnProto instruction
2016-12-18 19:40:26 -05:00
.allocator = allocator,
explicitly return from blocks instead of last statement being expression value closes #629
2017-12-22 00:50:30 -05:00
};
stack trace is able to figure out compilation unit each address is contained within also fix a bug having to do with codegen for enum value initialization expressions
2016-09-23 02:00:23 -04:00
}
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 21:56:19 +01:00
docs: Fix outdated doc comments about allocating 'at least' the requested size The 'at least' behavior of the Allocator interface was removed in #13666, so anything that used reallocAtLeast or the .at_least Exact behavior could still have doc comments that reference no-longer-true behavior. Funnily enough, ArrayList is the only place that used this functionality (outside of allocator test cases), so its doc comments are the only things that need to be fixed. This was checked by resetting to deda6b514691c3a7ffc7931469886d0e7be2f67e and searching for all instances of `reallocAtLeast` and `.at_least` (one of which would need to be used to get the `.at_least` behavior)
2023-07-12 16:49:10 -07:00
/// Initialize with capacity to hold `num` elements.
/// The resulting capacity will equal `num` exactly.
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
/// Deinitialize with `deinit` or use `toOwnedSlice`.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn initCapacity(allocator: Allocator, num: usize) Allocator.Error!Self {
Added initCapacity and relevant test Added ArrayList.initCapcity() as a way to preallocate a block of memory to reduce future allocations. Added a test "std.ArrayList.initCapacity" that ensures initCapacity adds no elements and increases capacity by at least the requested amount
2019-11-23 22:54:33 -05:00
var self = Self.init(allocator);
std.ArrayList: add ensureTotalCapacityPrecise and update doc comments initCapacity did and still does use the ensureTotalCapacityPrecise logic because the initial capacity of an ArrayList is not important in terms of how it grows, so allocating a more exact slice up-front allows for saving memory when the array list never exceeds that initial allocation size. There are use cases where this precise capacity is useful outside of the `init` function, though, like in instances where the user does not call the `init` function themselves but otherwise knows that an ArrayList is empty so calling `ensureTotalCapacityPrecise` can give the same memory savings that `initCapacity` would have. Closes #9775
2021-11-01 00:38:11 -07:00
try self.ensureTotalCapacityPrecise(num);
Added initCapacity and relevant test Added ArrayList.initCapcity() as a way to preallocate a block of memory to reduce future allocations. Added a test "std.ArrayList.initCapacity" that ensures initCapacity adds no elements and increases capacity by at least the requested amount
2019-11-23 22:54:33 -05:00
return self;
}
add list implementation to standard library
2016-05-08 01:34:00 -07:00
Add some documentation for standard library things. (#3540) * Add some documentation for standard library things. Added a bunch of descriptions for array_list. Added some usage notes for failing_allocator. Documented some of mem.Allocator.
2019-10-28 03:57:23 -04:00
/// Release all allocated memory.
don't automatically take pointer when passing by non-copying value this commit does not have all tests passing
2018-06-15 13:49:39 -04:00
pub fn deinit(self: Self) void {
std/ArrayList: Allow `ArrayList(u0)` to be created Enable creating ArrayList with zero-sized types. This type still tracks length, but does not allocate additional memory.
2021-04-23 14:24:58 -04:00
if (@sizeOf(T) > 0) {
self.allocator.free(self.allocatedSlice());
}
IR: add FnProto instruction
2016-12-18 19:40:26 -05:00
}
stack trace is able to figure out compilation unit each address is contained within also fix a bug having to do with codegen for enum value initialization expressions
2016-09-23 02:00:23 -04:00
implement command line argument parsing for windows See #302
2017-10-11 10:16:13 -04:00
/// ArrayList takes ownership of the passed in slice. The slice must have been
/// allocated with `allocator`.
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
/// Deinitialize with `deinit` or use `toOwnedSlice`.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn fromOwnedSlice(allocator: Allocator, slice: Slice) Self {
New Zig formal grammar (#1685) Reverted #1628 and changed the grammar+parser of the language to not allow certain expr where types are expected
2018-11-13 05:08:37 -08:00
return Self{
implement command line argument parsing for windows See #302
2017-10-11 10:16:13 -04:00
.items = slice,
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
.capacity = slice.len,
implement command line argument parsing for windows See #302
2017-10-11 10:16:13 -04:00
.allocator = allocator,
};
}
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
/// ArrayList takes ownership of the passed in slice. The slice must have been
/// allocated with `allocator`.
/// Deinitialize with `deinit` or use `toOwnedSlice`.
pub fn fromOwnedSliceSentinel(allocator: Allocator, comptime sentinel: T, slice: [:sentinel]T) Self {
return Self{
.items = slice,
.capacity = slice.len + 1,
.allocator = allocator,
};
}
stage2: rework the C backend * std.ArrayList gains `moveToUnmanaged` and dead code `ArrayListUnmanaged.appendWrite` is deleted. * emit_h state is attached to Module rather than Compilation. * remove the implementation of emit-h because it did not properly integrate with incremental compilation. I will re-implement it in a follow-up commit. * Compilation: use the .codegen_failure tag rather than .dependency_failure tag for when `bin_file.updateDecl` fails. C backend: * Use a CValue tagged union instead of strings for C values. * Cleanly separate state into Object and DeclGen: - Object is present only when generating a .c file - DeclGen is present for both generating a .c and .h * Move some functions into their respective Object/DeclGen namespace. * Forward decls are managed by the incremental compilation frontend; C backend no longer renders function signatures based on callsites. For simplicity, all functions always get forward decls. * Constants are managed by the incremental compilation frontend. C backend no longer has a "constants" section. * Participate in incremental compilation. Each Decl gets an ArrayList for its generated C code and it is updated when the Decl is updated. During flush(), all these are joined together in the output file. * The new CValue tagged union is used to clean up using of assigning to locals without an additional pointer local. * Fix bug with bitcast of non-pointers making the memcpy destination immutable.
2021-01-05 11:08:34 -07:00
/// Initializes an ArrayListUnmanaged with the `items` and `capacity` fields
/// of this ArrayList. Empties this ArrayList.
pub fn moveToUnmanaged(self: *Self) ArrayListAlignedUnmanaged(T, alignment) {
const allocator = self.allocator;
compiler: remove anonymous struct types, unify all tuples This commit reworks how anonymous struct literals and tuples work. Previously, an untyped anonymous struct literal (e.g. `const x = .{ .a = 123 }`) was given an "anonymous struct type", which is a special kind of struct which coerces using structural equivalence. This mechanism was a holdover from before we used RLS / result types as the primary mechanism of type inference. This commit changes the language so that the type assigned here is a "normal" struct type. It uses a form of equivalence based on the AST node and the type's structure, much like a reified (`@Type`) type. Additionally, tuples have been simplified. The distinction between "simple" and "complex" tuple types is eliminated. All tuples, even those explicitly declared using `struct { ... }` syntax, use structural equivalence, and do not undergo staged type resolution. Tuples are very restricted: they cannot have non-`auto` layouts, cannot have aligned fields, and cannot have default values with the exception of `comptime` fields. Tuples currently do not have optimized layout, but this can be changed in the future. This change simplifies the language, and fixes some problematic coercions through pointers which led to unintuitive behavior. Resolves: #16865
2024-10-26 23:13:58 +01:00
const result: ArrayListAlignedUnmanaged(T, alignment) = .{ .items = self.items, .capacity = self.capacity };
stage2: rework the C backend * std.ArrayList gains `moveToUnmanaged` and dead code `ArrayListUnmanaged.appendWrite` is deleted. * emit_h state is attached to Module rather than Compilation. * remove the implementation of emit-h because it did not properly integrate with incremental compilation. I will re-implement it in a follow-up commit. * Compilation: use the .codegen_failure tag rather than .dependency_failure tag for when `bin_file.updateDecl` fails. C backend: * Use a CValue tagged union instead of strings for C values. * Cleanly separate state into Object and DeclGen: - Object is present only when generating a .c file - DeclGen is present for both generating a .c and .h * Move some functions into their respective Object/DeclGen namespace. * Forward decls are managed by the incremental compilation frontend; C backend no longer renders function signatures based on callsites. For simplicity, all functions always get forward decls. * Constants are managed by the incremental compilation frontend. C backend no longer has a "constants" section. * Participate in incremental compilation. Each Decl gets an ArrayList for its generated C code and it is updated when the Decl is updated. During flush(), all these are joined together in the output file. * The new CValue tagged union is used to clean up using of assigning to locals without an additional pointer local. * Fix bug with bitcast of non-pointers making the memcpy destination immutable.
2021-01-05 11:08:34 -07:00
self.* = init(allocator);
return result;
}
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
/// The caller owns the returned memory. Empties this ArrayList.
/// Its capacity is cleared, making `deinit` safe but unnecessary to call.
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
pub fn toOwnedSlice(self: *Self) Allocator.Error!Slice {
implement command line argument parsing for windows See #302
2017-10-11 10:16:13 -04:00
const allocator = self.allocator;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
const old_memory = self.allocatedSlice();
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
if (allocator.remap(old_memory, self.items.len)) |new_items| {
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
self.* = init(allocator);
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
return new_items;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
}
const new_memory = try allocator.alignedAlloc(T, alignment, self.items.len);
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(new_memory, self.items);
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
self.clearAndFree();
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
return new_memory;
implement command line argument parsing for windows See #302
2017-10-11 10:16:13 -04:00
}
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// The caller owns the returned memory. Empties this ArrayList.
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
pub fn toOwnedSliceSentinel(self: *Self, comptime sentinel: T) Allocator.Error!SentinelSlice(sentinel) {
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
// This addition can never overflow because `self.items` can never occupy the whole address space
try self.ensureTotalCapacityPrecise(self.items.len + 1);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
self.appendAssumeCapacity(sentinel);
const result = try self.toOwnedSlice();
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
return result[0 .. result.len - 1 :sentinel];
}
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
/// Creates a copy of this ArrayList, using the same allocator.
Allow const ArrayLists to be cloned
2022-12-04 23:46:32 -06:00
pub fn clone(self: Self) Allocator.Error!Self {
Preserve alignment when cloning
2021-12-16 10:55:35 +01:00
var cloned = try Self.initCapacity(self.allocator, self.capacity);
Implement clone with initCapacity and appendSliceAssumeCapacity `ArrayList.ensureTotalCapacityPrecise` uses `Allocator.reallocAtLeast` under the hood, which can return more than `new_capacity` bytes if `alignment != @alignOf(T)`. This implementation of `clone` assures that the case of `ensureTotalCapacityPrecise` is handled correctly. Thanks @Vexu and @squeek502 for pointing this out.
2021-12-13 15:01:05 +01:00
cloned.appendSliceAssumeCapacity(self.items);
return cloned;
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Insert `item` at index `i`. Moves `list[i .. list.len]` to higher indices to make room.
/// If `i` is equal to the length of the list this operation is equivalent to append.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// This operation is O(N).
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
/// Asserts that the index is in bounds or equal to the length.
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
pub fn insert(self: *Self, i: usize, item: T) Allocator.Error!void {
const dst = try self.addManyAt(i, 1);
Improve (Unmanaged)ArrayList.insert (Unmanaged)ArrayList.insert has the same inefficiency as the old insertSlice. With the new addManyAt, the solution is trivial. Also improves the test "growing memory preserves contents". In the previous implementation, if any changes were made to the ArrayList memory growth policy (function growMemory), the list could end up with enough capacity to not trigger a memory growth, defeating the purpose of the test. The new implementation more robustly triggers a memory growth.
2023-09-30 14:43:08 -03:00
dst[0] = item;
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Insert `item` at index `i`. Moves `list[i .. list.len]` to higher indices to make room.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// If `i` is equal to the length of the list this operation is
/// equivalent to appendAssumeCapacity.
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
/// This operation is O(N).
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that there is enough capacity for the new item.
/// Asserts that the index is in bounds or equal to the length.
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
pub fn insertAssumeCapacity(self: *Self, i: usize, item: T) void {
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
assert(self.items.len < self.capacity);
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
self.items.len += 1;
Add ArrayList functions (#755) at - Get the item at the n-th index. insert - Insert and item into the middle of the list, resizing and copying existing elements if needed. insertSlice - Insert a slice into the middle of the list, resizing and copying existing elements if needed.
2018-02-09 05:22:31 +13:00
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
mem.copyBackwards(T, self.items[i + 1 .. self.items.len], self.items[i .. self.items.len - 1]);
self.items[i] = item;
Add ArrayList functions (#755) at - Get the item at the n-th index. insert - Insert and item into the middle of the list, resizing and copying existing elements if needed. insertSlice - Insert a slice into the middle of the list, resizing and copying existing elements if needed.
2018-02-09 05:22:31 +13:00
}
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
/// Add `count` new elements at position `index`, which have
/// `undefined` values. Returns a slice pointing to the newly allocated
/// elements, which becomes invalid after various `ArrayList`
/// operations.
/// Invalidates pre-existing pointers to elements at and after `index`.
/// Invalidates all pre-existing element pointers if capacity must be
std: fix typos (#20560)
2024-07-10 00:25:42 +03:00
/// increased to accommodate the new elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the index is in bounds or equal to the length.
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
pub fn addManyAt(self: *Self, index: usize, count: usize) Allocator.Error![]T {
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
const new_len = try addOrOom(self.items.len, count);
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
if (self.capacity >= new_len)
return addManyAtAssumeCapacity(self, index, count);
// Here we avoid copying allocated but unused bytes by
// attempting a resize in place, and falling back to allocating
// a new buffer and doing our own copy. With a realloc() call,
// the allocator implementation would pointlessly copy our
// extra capacity.
std.ArrayList: initial capacity based on cache line size also std.MultiArrayList
2025-02-11 18:53:13 -08:00
const new_capacity = ArrayListAlignedUnmanaged(T, alignment).growCapacity(self.capacity, new_len);
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
const old_memory = self.allocatedSlice();
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
if (self.allocator.remap(old_memory, new_capacity)) |new_memory| {
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
return addManyAtAssumeCapacity(self, index, count);
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
}
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
// Make a new allocation, avoiding `ensureTotalCapacity` in order
// to avoid extra memory copies.
const new_memory = try self.allocator.alignedAlloc(T, alignment, new_capacity);
const to_move = self.items[index..];
@memcpy(new_memory[0..index], self.items[0..index]);
@memcpy(new_memory[index + count ..][0..to_move.len], to_move);
self.allocator.free(old_memory);
self.items = new_memory[0..new_len];
self.capacity = new_memory.len;
// The inserted elements at `new_memory[index..][0..count]` have
// already been set to `undefined` by memory allocation.
return new_memory[index..][0..count];
}
/// Add `count` new elements at position `index`, which have
/// `undefined` values. Returns a slice pointing to the newly allocated
/// elements, which becomes invalid after various `ArrayList`
/// operations.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that there is enough capacity for the new elements.
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
/// Invalidates pre-existing pointers to elements at and after `index`, but
/// does not invalidate any before that.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the index is in bounds or equal to the length.
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
pub fn addManyAtAssumeCapacity(self: *Self, index: usize, count: usize) []T {
const new_len = self.items.len + count;
assert(self.capacity >= new_len);
const to_move = self.items[index..];
self.items.len = new_len;
mem.copyBackwards(T, self.items[index + count ..], to_move);
const result = self.items[index..][0..count];
@memset(result, undefined);
return result;
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// Insert slice `items` at index `i` by moving `list[i .. list.len]` to make room.
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
/// This operation is O(N).
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
/// Invalidates pre-existing pointers to elements at and after `index`.
/// Invalidates all pre-existing element pointers if capacity must be
std: fix typos (#20560)
2024-07-10 00:25:42 +03:00
/// increased to accommodate the new elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the index is in bounds or equal to the length.
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
pub fn insertSlice(
self: *Self,
index: usize,
items: []const T,
) Allocator.Error!void {
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
const dst = try self.addManyAt(index, items.len);
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
@memcpy(dst, items);
Add ArrayList functions (#755) at - Get the item at the n-th index. insert - Insert and item into the middle of the list, resizing and copying existing elements if needed. insertSlice - Insert a slice into the middle of the list, resizing and copying existing elements if needed.
2018-02-09 05:22:31 +13:00
}
std.ArrayList: pedantic fixups to previous commit * fix and clarify incorrect doc comments * unify the pattern of calling unmanaged methods
2024-01-19 15:46:23 -07:00
/// Grows or shrinks the list as necessary.
/// Invalidates element pointers if additional capacity is allocated.
std.ArrayList.replaceRange: remove unneded overflow checks The code asserted that the range to be replaced is within bounds of `self.items`. This is now reflected in the doc comment. The old, wrong doc comment was copied from the `insert*` fns. With this assertion holding true, `start + len` is always within the address space and `start + new_items.len` is, at this point, always strictly within bounds of `self.items`.
2024-01-19 00:25:44 +01:00
/// Asserts that the range is in bounds.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn replaceRange(self: *Self, start: usize, len: usize, new_items: []const T) Allocator.Error!void {
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
var unmanaged = self.moveToUnmanaged();
defer self.* = unmanaged.toManaged(self.allocator);
return unmanaged.replaceRange(self.allocator, start, len, new_items);
}
add replaceRange() function to ArrayList generalizes functionality of ArrayList.insertSlice() to overwrite a range of elements in the list and to grow or shrink the list as needed to accommodate size difference of the replacing slice and the range of existing elements.
2020-06-02 11:12:26 -05:00
std.ArrayList: pedantic fixups to previous commit * fix and clarify incorrect doc comments * unify the pattern of calling unmanaged methods
2024-01-19 15:46:23 -07:00
/// Grows or shrinks the list as necessary.
/// Never invalidates element pointers.
/// Asserts the capacity is enough for additional items.
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
pub fn replaceRangeAssumeCapacity(self: *Self, start: usize, len: usize, new_items: []const T) void {
var unmanaged = self.moveToUnmanaged();
std.ArrayList: pedantic fixups to previous commit * fix and clarify incorrect doc comments * unify the pattern of calling unmanaged methods
2024-01-19 15:46:23 -07:00
defer self.* = unmanaged.toManaged(self.allocator);
return unmanaged.replaceRangeAssumeCapacity(start, len, new_items);
add replaceRange() function to ArrayList generalizes functionality of ArrayList.insertSlice() to overwrite a range of elements in the list and to grow or shrink the list as needed to accommodate size difference of the replacing slice and the range of existing elements.
2020-06-02 11:12:26 -05:00
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Extends the list by 1 element. Allocates more memory as necessary.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn append(self: *Self, item: T) Allocator.Error!void {
clean up std.ArrayList * add `std.debug.assertError` * `std.ArrayList` update everything to follow `self` convention * rename `std.ArrayList.set` to `std.ArrayList.setOrError` * add `std.ArrayList.set` which asserts Before 1.0.0 we might remove some of this API, because you can use `toSlice()` for everything, but it's ok to add these functions as an experiment before then.
2018-06-09 12:03:11 -04:00
const new_item_ptr = try self.addOne();
don't automatically take pointer when passing by non-copying value this commit does not have all tests passing
2018-06-15 13:49:39 -04:00
new_item_ptr.* = item;
IR: add FnProto instruction
2016-12-18 19:40:26 -05:00
}
std.ArrayList - rename remove to swapRemove
2018-07-14 10:01:45 -04:00
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Extends the list by 1 element.
/// Never invalidates element pointers.
/// Asserts that the list can hold one additional item.
Add capacity and appendAssumeCapacity to ArrayList
2018-09-09 12:54:00 +02:00
pub fn appendAssumeCapacity(self: *Self, item: T) void {
std.array_list: tiny refactor for pleasure
2024-12-05 21:32:07 -08:00
self.addOneAssumeCapacity().* = item;
Add capacity and appendAssumeCapacity to ArrayList
2018-09-09 12:54:00 +02:00
}
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// Remove the element at index `i`, shift elements after index
/// `i` forward, and return the removed element.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers to end of list.
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
/// This operation is O(N).
Improvements to docs and text * docs(std.math): elaborate on difference between absCast and absInt * docs(std.rand.Random.weightedIndex): elaborate on likelihood I think this makes it easier to understand. * langref: add small reminder * docs(std.fs.path.extension): brevity * docs(std.bit_set.StaticBitSet): mention the specific types * std.debug.TTY: explain what purpose this struct serves This should also make it clearer that this struct is not supposed to provide unrelated terminal manipulation functionality such as setting the cursor position or something because terminals are complicated and we should keep this struct simple and focused on debugging. * langref(package listing): brevity * langref: explain what exactly `threadlocal` causes to happen * std.array_list: link between swapRemove and orderedRemove Maybe this can serve as a TLDR and make it easier to decide. * PrefetchOptions.locality: clarify docs that this is a range This confused me previously and I thought I can only use either 0 or 3. * fix typos and more * std.builtin.CallingConvention: document some CCs * langref: explain possibly cryptic names I think it helps knowing what exactly these acronyms (@clz and @ctz) and abbreviations (@popCount) mean. * variadic function error: add missing preposition * std.fmt.format docs: nicely hyphenate * help menu: say what to optimize for I think this is slightly more specific than just calling it "optimizations". These are speed optimizations. I used the word "performance" here.
2023-04-23 20:06:21 +02:00
/// This preserves item order. Use `swapRemove` if order preservation is not important.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the index is in bounds.
/// Asserts that the list is not empty.
std: add std.ArrayList.orderedRemove
2019-04-12 12:23:44 +02:00
pub fn orderedRemove(self: *Self, i: usize) T {
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
const old_item = self.items[i];
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
self.replaceRangeAssumeCapacity(i, 1, &.{});
std: add std.ArrayList.orderedRemove
2019-04-12 12:23:44 +02:00
return old_item;
}
Added `remove` to ArrayList
2018-07-11 12:52:30 -05:00
/// Removes the element at the specified index and returns it.
std.ArrayList - rename remove to swapRemove
2018-07-14 10:01:45 -04:00
/// The empty slot is filled from the end of the list.
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
/// This operation is O(1).
Improvements to docs and text * docs(std.math): elaborate on difference between absCast and absInt * docs(std.rand.Random.weightedIndex): elaborate on likelihood I think this makes it easier to understand. * langref: add small reminder * docs(std.fs.path.extension): brevity * docs(std.bit_set.StaticBitSet): mention the specific types * std.debug.TTY: explain what purpose this struct serves This should also make it clearer that this struct is not supposed to provide unrelated terminal manipulation functionality such as setting the cursor position or something because terminals are complicated and we should keep this struct simple and focused on debugging. * langref(package listing): brevity * langref: explain what exactly `threadlocal` causes to happen * std.array_list: link between swapRemove and orderedRemove Maybe this can serve as a TLDR and make it easier to decide. * PrefetchOptions.locality: clarify docs that this is a range This confused me previously and I thought I can only use either 0 or 3. * fix typos and more * std.builtin.CallingConvention: document some CCs * langref: explain possibly cryptic names I think it helps knowing what exactly these acronyms (@clz and @ctz) and abbreviations (@popCount) mean. * variadic function error: add missing preposition * std.fmt.format docs: nicely hyphenate * help menu: say what to optimize for I think this is slightly more specific than just calling it "optimizations". These are speed optimizations. I used the word "performance" here.
2023-04-23 20:06:21 +02:00
/// This may not preserve item order. Use `orderedRemove` if you need to preserve order.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list is not empty.
/// Asserts that the index is in bounds.
std.ArrayList - rename remove to swapRemove
2018-07-14 10:01:45 -04:00
pub fn swapRemove(self: *Self, i: usize) T {
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
if (self.items.len - 1 == i) return self.pop().?;
std.ArrayList - rename remove to swapRemove
2018-07-14 10:01:45 -04:00
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
const old_item = self.items[i];
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
self.items[i] = self.pop().?;
Added `remove` to ArrayList
2018-07-11 12:52:30 -05:00
return old_item;
}
std.ArrayList - rename remove to swapRemove
2018-07-14 10:01:45 -04:00
Add some documentation for standard library things. (#3540) * Add some documentation for standard library things. Added a bunch of descriptions for array_list. Added some usage notes for failing_allocator. Documented some of mem.Allocator.
2019-10-28 03:57:23 -04:00
/// Append the slice of items to the list. Allocates more
/// memory as necessary.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn appendSlice(self: *Self, items: []const T) Allocator.Error!void {
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
try self.ensureUnusedCapacity(items.len);
self-hosted: rework the memory layout of ir.Module and related types * add TypedValue.Managed which represents a Type, a Value, and some kind of memory management strategy. * introduce an analysis queue * flesh out how incremental compilation works with respect to exports * ir.text.Module is only capable of one error message during parsing * link.zig no longer has a decl table map and instead has structs that exist directly on ir.Module.Decl and ir.Module.Export * implement primitive .text block allocation * implement linker code for updating Decls and Exports * implement null Type Some supporting std lib changes: * add std.ArrayList.appendSliceAssumeCapacity * add std.fs.File.copyRange and copyRangeAll * fix std.HashMap having modification safety on in ReleaseSmall builds * add std.HashMap.putAssumeCapacityNoClobber
2020-05-12 01:02:48 -04:00
self.appendSliceAssumeCapacity(items);
}
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Append the slice of items to the list.
/// Never invalidates element pointers.
/// Asserts that the list can hold the additional items.
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
pub fn appendSliceAssumeCapacity(self: *Self, items: []const T) void {
std.ArrayList: add missing assertion in appendSliceAssumeCapacity
2021-07-19 18:57:57 -07:00
const old_len = self.items.len;
const new_len = old_len + items.len;
assert(new_len <= self.capacity);
self.items.len = new_len;
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(self.items[old_len..][0..items.len], items);
Add appendSlice function (#448)
2017-09-10 05:49:40 +12:00
}
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
/// Append an unaligned slice of items to the list. Allocates more
/// memory as necessary. Only call this function if calling
/// `appendSlice` instead would be a compile error.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
pub fn appendUnalignedSlice(self: *Self, items: []align(1) const T) Allocator.Error!void {
try self.ensureUnusedCapacity(items.len);
self.appendUnalignedSliceAssumeCapacity(items);
}
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Append the slice of items to the list.
/// Never invalidates element pointers.
/// This function is only needed when calling
/// `appendSliceAssumeCapacity` instead would be a compile error due to the
/// alignment of the `items` parameter.
/// Asserts that the list can hold the additional items.
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
pub fn appendUnalignedSliceAssumeCapacity(self: *Self, items: []align(1) const T) void {
const old_len = self.items.len;
const new_len = old_len + items.len;
assert(new_len <= self.capacity);
self.items.len = new_len;
change semantics of `@memcpy` and `@memset` Now they use slices or array pointers with any element type instead of requiring byte pointers. This is a breaking enhancement to the language. The safety check for overlapping pointers will be implemented in a future commit. closes #14040
2023-04-13 21:44:40 -07:00
@memcpy(self.items[old_len..][0..items.len], items);
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
}
std.os.windows: reorg to avoid `usingnamespace` Down to 19 uses of `usingnamespace`.
2021-08-25 17:39:30 -07:00
pub const Writer = if (T != u8)
@compileError("The Writer interface is only defined for ArrayList(u8) " ++
"but the given type is ArrayList(" ++ @typeName(T) ++ ")")
else
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
std.io.Writer(*Self, Allocator.Error, appendWrite);
std.os.windows: reorg to avoid `usingnamespace` Down to 19 uses of `usingnamespace`.
2021-08-25 17:39:30 -07:00
/// Initializes a Writer which will append to the list.
pub fn writer(self: *Self) Writer {
return .{ .context = self };
}
ArrayList(u8) support writer interface
2020-06-13 11:35:18 -06:00
std.os.windows: reorg to avoid `usingnamespace` Down to 19 uses of `usingnamespace`.
2021-08-25 17:39:30 -07:00
/// Same as `append` except it returns the number of bytes written, which is always the same
/// as `m.len`. The purpose of this function existing is to match `std.io.Writer` API.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
fn appendWrite(self: *Self, m: []const u8) Allocator.Error!usize {
std.os.windows: reorg to avoid `usingnamespace` Down to 19 uses of `usingnamespace`.
2021-08-25 17:39:30 -07:00
try self.appendSlice(m);
return m.len;
}
std: add std.ArrayList(u8).outStream()
2020-03-01 19:13:26 +11:00
Dwarf: rework self-hosted debug info from scratch This is in preparation for incremental and actually being able to debug executables built by the x86_64 backend.
2024-08-06 11:22:37 -04:00
pub const FixedWriter = std.io.Writer(*Self, Allocator.Error, appendWriteFixed);
/// Initializes a Writer which will append to the list but will return
/// `error.OutOfMemory` rather than increasing capacity.
pub fn fixedWriter(self: *Self) FixedWriter {
return .{ .context = self };
}
/// The purpose of this function existing is to match `std.io.Writer` API.
fn appendWriteFixed(self: *Self, m: []const u8) error{OutOfMemory}!usize {
const available_capacity = self.capacity - self.items.len;
if (m.len > available_capacity)
return error.OutOfMemory;
self.appendSliceAssumeCapacity(m);
return m.len;
}
fixups and revert a few things
2020-04-01 11:56:39 -04:00
/// Append a value to the list `n` times.
/// Allocates more memory as necessary.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
/// The function is inline so that a comptime-known `value` parameter will
/// have a more optimal memset codegen in case it has a repeated byte pattern.
pub inline fn appendNTimes(self: *Self, value: T, n: usize) Allocator.Error!void {
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
const old_len = self.items.len;
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
try self.resize(try addOrOom(old_len, n));
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
@memset(self.items[old_len..self.items.len], value);
Add an appendValues method to ArrayList to append a value n times. (#4460)
2020-02-19 17:33:35 +01:00
}
std.ArrayList: add appendNTimesAssumeCapacity
2020-07-31 01:16:17 -07:00
/// Append a value to the list `n` times.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
/// The function is inline so that a comptime-known `value` parameter will
/// have a more optimal memset codegen in case it has a repeated byte pattern.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
pub inline fn appendNTimesAssumeCapacity(self: *Self, value: T, n: usize) void {
std.ArrayList: add appendNTimesAssumeCapacity
2020-07-31 01:16:17 -07:00
const new_len = self.items.len + n;
assert(new_len <= self.capacity);
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
@memset(self.items.ptr[self.items.len..new_len], value);
std.ArrayList: add appendNTimesAssumeCapacity
2020-07-31 01:16:17 -07:00
self.items.len = new_len;
}
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Adjust the list length to `new_len`.
/// Additional elements contain the value `undefined`.
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn resize(self: *Self, new_len: usize) Allocator.Error!void {
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
try self.ensureTotalCapacity(new_len);
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
self.items.len = new_len;
IR: add FnProto instruction
2016-12-18 19:40:26 -05:00
}
add list implementation to standard library
2016-05-08 01:34:00 -07:00
Add some documentation for standard library things. (#3540) * Add some documentation for standard library things. Added a bunch of descriptions for array_list. Added some usage notes for failing_allocator. Documented some of mem.Allocator.
2019-10-28 03:57:23 -04:00
/// Reduce allocated capacity to `new_len`.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// May invalidate element pointers.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the new length is less than or equal to the previous length.
std: Rename ArrayList shrink => shrinkAndFree
2020-12-29 16:22:22 +11:00
pub fn shrinkAndFree(self: *Self, new_len: usize) void {
std.ArrayList: fix shrinkAndFree Fixes a regression introduced in e35f297aeb993ec956ae80379ddf7f86069e109b. Now there is test coverage for ArrayList.shrinkAndFree in the case when resizing fails.
2022-11-30 15:42:59 -07:00
var unmanaged = self.moveToUnmanaged();
unmanaged.shrinkAndFree(self.allocator, new_len);
self.* = unmanaged.toManaged(self.allocator);
zig build system supports building a library See #329 Supporting work: * move std.cstr.Buffer0 to std.buffer.Buffer * add build.zig to example/shared_library/ and add an automated test for it * add std.list.List.resizeDown * improve std.os.makePath - no longer recursive - takes into account . and .. * add std.os.path.isAbsolute * add std.os.path.resolve * reimplement std.os.path.dirname - no longer requires an allocator - handles edge cases correctly
2017-04-21 01:56:12 -04:00
}
reimplement std.HashMap * breaking changes to the API. Some of the weird decisions from before are changed to what would be more expected. - `get` returns `?V`, use `getEntry` for the old API. - `put` returns `!void`, use `fetchPut` for the old API. * HashMap now has a comptime parameter of whether to store hashes with entries. AutoHashMap has heuristics on whether to set this parameter. For example, for integers, it is false, since equality checking is cheap, but for strings, it is true, since equality checking is probably expensive. * The implementation has a separate array for entry_index / distance_from_start_index. Entries no longer has holes; it is an ArrayList, and iteration is simpler and more cache coherent. This is inspired by Python's new dictionaries. * HashMap is separated into an "unmanaged" and a "managed" API. The unmanaged API is where the actual implementation is; the managed API wraps it and provides a more convenient API, storing the allocator. * Memory usage: When there are less than or equal to 8 entries, HashMap now incurs only a single pointer-size integer as overhead, opposed to using an ArrayList. * Since the entries array is separate from the indexes array, the holes in the indexes array take up less room than the holes in the entries array otherwise would. However the entries array also allocates additional capacity for appending into the array. * HashMap now maintains insertion order. Deletion performs a "swap remove". It's now possible to modify the HashMap while iterating.
2020-07-03 23:57:24 +00:00
/// Reduce length to `new_len`.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers for the elements `items[new_len..]`.
/// Asserts that the new length is less than or equal to the previous length.
reimplement std.HashMap * breaking changes to the API. Some of the weird decisions from before are changed to what would be more expected. - `get` returns `?V`, use `getEntry` for the old API. - `put` returns `!void`, use `fetchPut` for the old API. * HashMap now has a comptime parameter of whether to store hashes with entries. AutoHashMap has heuristics on whether to set this parameter. For example, for integers, it is false, since equality checking is cheap, but for strings, it is true, since equality checking is probably expensive. * The implementation has a separate array for entry_index / distance_from_start_index. Entries no longer has holes; it is an ArrayList, and iteration is simpler and more cache coherent. This is inspired by Python's new dictionaries. * HashMap is separated into an "unmanaged" and a "managed" API. The unmanaged API is where the actual implementation is; the managed API wraps it and provides a more convenient API, storing the allocator. * Memory usage: When there are less than or equal to 8 entries, HashMap now incurs only a single pointer-size integer as overhead, opposed to using an ArrayList. * Since the entries array is separate from the indexes array, the holes in the indexes array take up less room than the holes in the entries array otherwise would. However the entries array also allocates additional capacity for appending into the array. * HashMap now maintains insertion order. Deletion performs a "swap remove". It's now possible to modify the HashMap while iterating.
2020-07-03 23:57:24 +00:00
pub fn shrinkRetainingCapacity(self: *Self, new_len: usize) void {
assert(new_len <= self.items.len);
self.items.len = new_len;
}
std.ArrayList: add clearRetainingCapacity and clearAndFree
2021-05-05 16:55:49 -07:00
/// Invalidates all element pointers.
pub fn clearRetainingCapacity(self: *Self) void {
self.items.len = 0;
}
/// Invalidates all element pointers.
pub fn clearAndFree(self: *Self) void {
self.allocator.free(self.allocatedSlice());
self.items.len = 0;
self.capacity = 0;
}
std.ArrayList: Clarify that ensureTotalCapacity/ensureTotalCapacityPrecise will never shrink the array Closes #18499
2024-01-11 16:09:32 -08:00
/// If the current capacity is less than `new_capacity`, this function will
/// modify the array so that it can hold at least `new_capacity` items.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) Allocator.Error!void {
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
if (@sizeOf(T) == 0) {
self.capacity = math.maxInt(usize);
return;
}
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
if (self.capacity >= new_capacity) return;
translate-c cleanup and zig fmt
2020-04-15 15:15:32 +03:00
std.ArrayList: initial capacity based on cache line size also std.MultiArrayList
2025-02-11 18:53:13 -08:00
const better_capacity = ArrayListAlignedUnmanaged(T, alignment).growCapacity(self.capacity, new_capacity);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
return self.ensureTotalCapacityPrecise(better_capacity);
std.ArrayList: add ensureTotalCapacityPrecise and update doc comments initCapacity did and still does use the ensureTotalCapacityPrecise logic because the initial capacity of an ArrayList is not important in terms of how it grows, so allocating a more exact slice up-front allows for saving memory when the array list never exceeds that initial allocation size. There are use cases where this precise capacity is useful outside of the `init` function, though, like in instances where the user does not call the `init` function themselves but otherwise knows that an ArrayList is empty so calling `ensureTotalCapacityPrecise` can give the same memory savings that `initCapacity` would have. Closes #9775
2021-11-01 00:38:11 -07:00
}
std.ArrayList: Clarify that ensureTotalCapacity/ensureTotalCapacityPrecise will never shrink the array Closes #18499
2024-01-11 16:09:32 -08:00
/// If the current capacity is less than `new_capacity`, this function will
/// modify the array so that it can hold exactly `new_capacity` items.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn ensureTotalCapacityPrecise(self: *Self, new_capacity: usize) Allocator.Error!void {
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
if (@sizeOf(T) == 0) {
self.capacity = math.maxInt(usize);
return;
}
std.ArrayList: add ensureTotalCapacityPrecise and update doc comments initCapacity did and still does use the ensureTotalCapacityPrecise logic because the initial capacity of an ArrayList is not important in terms of how it grows, so allocating a more exact slice up-front allows for saving memory when the array list never exceeds that initial allocation size. There are use cases where this precise capacity is useful outside of the `init` function, though, like in instances where the user does not call the `init` function themselves but otherwise knows that an ArrayList is empty so calling `ensureTotalCapacityPrecise` can give the same memory savings that `initCapacity` would have. Closes #9775
2021-11-01 00:38:11 -07:00
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
if (self.capacity >= new_capacity) return;
// Here we avoid copying allocated but unused bytes by
// attempting a resize in place, and falling back to allocating
// a new buffer and doing our own copy. With a realloc() call,
// the allocator implementation would pointlessly copy our
// extra capacity.
const old_memory = self.allocatedSlice();
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
if (self.allocator.remap(old_memory, new_capacity)) |new_memory| {
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
} else {
const new_memory = try self.allocator.alignedAlloc(T, alignment, new_capacity);
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(new_memory[0..self.items.len], self.items);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
self.allocator.free(old_memory);
std/ArrayList: Allow `ArrayList(u0)` to be created Enable creating ArrayList with zero-sized types. This type still tracks length, but does not allocate additional memory.
2021-04-23 14:24:58 -04:00
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
}
add list implementation to standard library
2016-05-08 01:34:00 -07:00
}
rename CBuf to Buffer0 and some minor std API changes
2017-02-28 03:07:11 -05:00
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
/// Modify the array so that it can hold at least `additional_count` **more** items.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) Allocator.Error!void {
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
return self.ensureTotalCapacity(try addOrOom(self.items.len, additional_count));
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
}
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
/// Increases the array's length to match the full capacity that is already allocated.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// The new elements have `undefined` values.
/// Never invalidates element pointers.
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
pub fn expandToCapacity(self: *Self) void {
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
self.items.len = self.capacity;
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
}
Add some documentation for standard library things. (#3540) * Add some documentation for standard library things. Added a bunch of descriptions for array_list. Added some usage notes for failing_allocator. Documented some of mem.Allocator.
2019-10-28 03:57:23 -04:00
/// Increase length by 1, returning pointer to the new item.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// The returned pointer becomes invalid when the list resized.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn addOne(self: *Self) Allocator.Error!*T {
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
// This can never overflow because `self.items` can never occupy the whole address space
const newlen = self.items.len + 1;
try self.ensureTotalCapacity(newlen);
Add capacity and appendAssumeCapacity to ArrayList
2018-09-09 12:54:00 +02:00
return self.addOneAssumeCapacity();
}
fixups & make some API decisions Removed: std.io.InStream.readUntilDelimiterBuffer Deprecated: std.ArrayList.toSlice std.ArrayList.toSliceConst std.ArrayList.at std.ArrayList.ptrAt std.ArrayList.setOrError std.ArrayList.set std.ArrayList.swapRemoveOrError std.Buffer.toSlice std.Buffer.toSliceConst std.io.InStream.readFull => std.io.InStream.readAll std.io.InStream.readAllBuffer New: std.ArrayList.span std.ArrayList.expandToCapacity std.Buffer.span std.io.InStream.readUntilDelimiterArrayList
2020-03-06 18:01:20 -05:00
/// Increase length by 1, returning pointer to the new item.
/// The returned pointer becomes invalid when the list is resized.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
/// Asserts that the list can hold one additional item.
Add capacity and appendAssumeCapacity to ArrayList
2018-09-09 12:54:00 +02:00
pub fn addOneAssumeCapacity(self: *Self) *T {
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
assert(self.items.len < self.capacity);
self.items.len += 1;
return &self.items[self.items.len - 1];
rename CBuf to Buffer0 and some minor std API changes
2017-02-28 03:07:11 -05:00
}
delete test_artifacts directory when tests complete * add std.os.deleteTree * add std.os.deleteDir * add std.os.page_size * add std.os API for iterating over directories * refactor duplication in build.zig * update documentation on how to run tests
2017-04-20 02:26:36 -04:00
std: add new array list functions
2020-07-06 06:09:47 +00:00
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is an array pointing to the newly allocated elements.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// The returned pointer becomes invalid when the list is resized.
/// Resizes list if `self.capacity` is not large enough.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn addManyAsArray(self: *Self, comptime n: usize) Allocator.Error!*[n]T {
std: add new array list functions
2020-07-06 06:09:47 +00:00
const prev_len = self.items.len;
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
try self.resize(try addOrOom(self.items.len, n));
std: add new array list functions
2020-07-06 06:09:47 +00:00
return self.items[prev_len..][0..n];
}
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is an array pointing to the newly allocated elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// The returned pointer becomes invalid when the list is resized.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
std: add new array list functions
2020-07-06 06:09:47 +00:00
pub fn addManyAsArrayAssumeCapacity(self: *Self, comptime n: usize) *[n]T {
assert(self.items.len + n <= self.capacity);
const prev_len = self.items.len;
self.items.len += n;
return self.items[prev_len..][0..n];
}
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is a slice pointing to the newly allocated elements.
/// The returned pointer becomes invalid when the list is resized.
/// Resizes list if `self.capacity` is not large enough.
pub fn addManyAsSlice(self: *Self, n: usize) Allocator.Error![]T {
const prev_len = self.items.len;
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
try self.resize(try addOrOom(self.items.len, n));
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
return self.items[prev_len..][0..n];
}
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is a slice pointing to the newly allocated elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
/// The returned pointer becomes invalid when the list is resized.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
pub fn addManyAsSliceAssumeCapacity(self: *Self, n: usize) []T {
assert(self.items.len + n <= self.capacity);
const prev_len = self.items.len;
self.items.len += n;
return self.items[prev_len..][0..n];
}
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
/// Remove and return the last element from the list, or return `null` if list is empty.
/// Invalidates element pointers to the removed element, if any.
pub fn pop(self: *Self) ?T {
if (self.items.len == 0) return null;
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
const val = self.items[self.items.len - 1];
self.items.len -= 1;
return val;
delete test_artifacts directory when tests complete * add std.os.deleteTree * add std.os.deleteDir * add std.os.page_size * add std.os API for iterating over directories * refactor duplication in build.zig * update documentation on how to run tests
2017-04-20 02:26:36 -04:00
}
rendering source code without recursion
2017-12-10 19:40:46 -05:00
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
/// Returns a slice of all the items plus the extra capacity, whose memory
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// contents are `undefined`.
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
pub fn allocatedSlice(self: Self) Slice {
std: reword some comments
2023-07-16 18:32:52 -07:00
// `items.len` is the length, not the capacity.
new ArrayList API, fix enough std lib to test
2020-03-31 02:47:19 +02:00
return self.items.ptr[0..self.capacity];
}
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
/// Returns a slice of only the extra capacity after items.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// This can be useful for writing directly into an ArrayList.
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
/// Note that such an operation must be followed up with a direct
/// modification of `self.items.len`.
std.ArrayList.unusedCapacitySlice: Return unaligned slice (#20490)
2024-07-14 00:56:29 +00:00
pub fn unusedCapacitySlice(self: Self) []T {
std.ChildProcess: improvements to collectOutputPosix * read directly into the ArrayList buffers. * respect max_output_bytes * std.ArrayList: - make `allocatedSlice` public. - add `unusedCapacitySlice`. I removed the Windows implementation of this stuff; I am doing a partial merge of LemonBoy's patch with the understanding that a later patch can add the Windows implementation after it is vetted.
2020-12-29 11:13:00 -07:00
return self.allocatedSlice()[self.items.len..];
}
Add the two functions 'getLast' and 'getLastOrNull' to ArrayListAligned/ArrayListAlignedUnmanaged.
2022-12-29 00:24:57 +01:00
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Returns the last element from the list.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list is not empty.
Allow const for ArrayList.getLast, fix #14522
2023-02-04 03:01:47 +01:00
pub fn getLast(self: Self) T {
Add the two functions 'getLast' and 'getLastOrNull' to ArrayListAligned/ArrayListAlignedUnmanaged.
2022-12-29 00:24:57 +01:00
const val = self.items[self.items.len - 1];
return val;
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Returns the last element from the list, or `null` if list is empty.
Allow const for ArrayList.getLast, fix #14522
2023-02-04 03:01:47 +01:00
pub fn getLastOrNull(self: Self) ?T {
Add the two functions 'getLast' and 'getLastOrNull' to ArrayListAligned/ArrayListAlignedUnmanaged.
2022-12-29 00:24:57 +01:00
if (self.items.len == 0) return null;
return self.getLast();
}
explicitly return from blocks instead of last statement being expression value closes #629
2017-12-22 00:50:30 -05:00
};
add list implementation to standard library
2016-05-08 01:34:00 -07:00
}
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// An ArrayList, but the allocator is passed as a parameter to the relevant functions
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// rather than stored in the struct itself. The same allocator must be used throughout
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// the entire lifetime of an ArrayListUnmanaged. Initialize directly or with
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
/// `initCapacity`, and deinitialize with `deinit` or use `toOwnedSlice`.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn ArrayListUnmanaged(comptime T: type) type {
return ArrayListAlignedUnmanaged(T, null);
}
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// A contiguous, growable list of arbitrarily aligned items in memory.
/// This is a wrapper around an array of T values aligned to `alignment`-byte
/// addresses. If the specified alignment is `null`, then `@alignOf(T)` is used.
///
/// Functions that potentially allocate memory accept an `Allocator` parameter.
/// Initialize directly or with `initCapacity`, and deinitialize with `deinit`
/// or use `toOwnedSlice`.
std: deprecate some incorrect default initializations In favour of newly-added decls, which can be used via decl literals.
2024-08-31 02:50:11 +01:00
///
/// Default initialization of this struct is deprecated; use `.empty` instead.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn ArrayListAlignedUnmanaged(comptime T: type, comptime alignment: ?u29) type {
if (alignment) |a| {
if (a == @alignOf(T)) {
return ArrayListAlignedUnmanaged(T, null);
}
}
return struct {
const Self = @This();
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Contents of the list. This field is intended to be accessed
/// directly.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
///
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Pointers to elements in this slice are invalidated by various
/// functions of this ArrayList in accordance with the respective
/// documentation. In all cases, "invalidated" means that the memory
/// has been passed to an allocator's resize or free function.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
items: Slice = &[_]T{},
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// How many T values this list can hold without allocating
/// additional memory.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
capacity: usize = 0,
std: deprecate some incorrect default initializations In favour of newly-added decls, which can be used via decl literals.
2024-08-31 02:50:11 +01:00
/// An ArrayList containing no elements.
pub const empty: Self = .{
.items = &.{},
.capacity = 0,
};
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub const Slice = if (alignment) |a| ([]align(a) T) else []T;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
pub fn SentinelSlice(comptime s: T) type {
return if (alignment) |a| ([:s]align(a) T) else [:s]T;
}
docs: Fix outdated doc comments about allocating 'at least' the requested size The 'at least' behavior of the Allocator interface was removed in #13666, so anything that used reallocAtLeast or the .at_least Exact behavior could still have doc comments that reference no-longer-true behavior. Funnily enough, ArrayList is the only place that used this functionality (outside of allocator test cases), so its doc comments are the only things that need to be fixed. This was checked by resetting to deda6b514691c3a7ffc7931469886d0e7be2f67e and searching for all instances of `reallocAtLeast` and `.at_least` (one of which would need to be used to get the `.at_least` behavior)
2023-07-12 16:49:10 -07:00
/// Initialize with capacity to hold `num` elements.
/// The resulting capacity will equal `num` exactly.
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
/// Deinitialize with `deinit` or use `toOwnedSlice`.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn initCapacity(allocator: Allocator, num: usize) Allocator.Error!Self {
Remove unimplemented `init` call from ArrayListUnmanaged.
2020-05-26 14:51:03 -05:00
var self = Self{};
std.ArrayList: add ensureTotalCapacityPrecise and update doc comments initCapacity did and still does use the ensureTotalCapacityPrecise logic because the initial capacity of an ArrayList is not important in terms of how it grows, so allocating a more exact slice up-front allows for saving memory when the array list never exceeds that initial allocation size. There are use cases where this precise capacity is useful outside of the `init` function, though, like in instances where the user does not call the `init` function themselves but otherwise knows that an ArrayList is empty so calling `ensureTotalCapacityPrecise` can give the same memory savings that `initCapacity` would have. Closes #9775
2021-11-01 00:38:11 -07:00
try self.ensureTotalCapacityPrecise(allocator, num);
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return self;
}
std.ArrayList: add initBuffer to the unmanaged array list This is useful when you want to have an array list backed by a fixed slice of memory and no Allocator will be used. It's an alternative to BoundedArray as you will see in the following commit.
2023-11-21 18:30:42 -07:00
/// Initialize with externally-managed memory. The buffer determines the
/// capacity, and the length is set to zero.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// When initialized this way, all functions that accept an Allocator
/// argument cause illegal behavior.
std.ArrayList: add initBuffer to the unmanaged array list This is useful when you want to have an array list backed by a fixed slice of memory and no Allocator will be used. It's an alternative to BoundedArray as you will see in the following commit.
2023-11-21 18:30:42 -07:00
pub fn initBuffer(buffer: Slice) Self {
return .{
.items = buffer[0..0],
.capacity = buffer.len,
};
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// Release all allocated memory.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn deinit(self: *Self, allocator: Allocator) void {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
allocator.free(self.allocatedSlice());
self.* = undefined;
}
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// Convert this list into an analogous memory-managed one.
/// The returned list has ownership of the underlying memory.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn toManaged(self: *Self, allocator: Allocator) ArrayListAligned(T, alignment) {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return .{ .items = self.items, .capacity = self.capacity, .allocator = allocator };
}
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
/// ArrayListUnmanaged takes ownership of the passed in slice. The slice must have been
/// allocated with `allocator`.
/// Deinitialize with `deinit` or use `toOwnedSlice`.
pub fn fromOwnedSlice(slice: Slice) Self {
return Self{
.items = slice,
.capacity = slice.len,
};
}
/// ArrayListUnmanaged takes ownership of the passed in slice. The slice must have been
/// allocated with `allocator`.
/// Deinitialize with `deinit` or use `toOwnedSlice`.
pub fn fromOwnedSliceSentinel(comptime sentinel: T, slice: [:sentinel]T) Self {
return Self{
.items = slice,
.capacity = slice.len + 1,
};
}
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
/// The caller owns the returned memory. Empties this ArrayList.
/// Its capacity is cleared, making deinit() safe but unnecessary to call.
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
pub fn toOwnedSlice(self: *Self, allocator: Allocator) Allocator.Error!Slice {
const old_memory = self.allocatedSlice();
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
if (allocator.remap(old_memory, self.items.len)) |new_items| {
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
self.* = .empty;
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
return new_items;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
}
const new_memory = try allocator.alignedAlloc(T, alignment, self.items.len);
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(new_memory, self.items);
ArrayList.toOwnedSlice: Fix potential for leaks when using errdefer #13666 introduced a footgun when using `toOwnedSlice` with `errdefer array_list.deinit()`, since `toOwnedSlice` could retain capacity if `resize` failed, meaning it would leak without `deinit` being called. This meant that the only correct way to use `toOwnedSlice` was with `defer` instead of `errdefer` to ensure that the ArrayList would get cleaned up. Now, toOwnedSlice will now behave similarly to how it did before #13666, in that it will always clear the ArrayList's capacity if the resize/realloc succeeds. This also reverts commit 05890a12f532ba9d58904a14381ec174b9efe473, which was contingent on the modified toOwnedSlice behavior. Closes #13946
2022-12-14 19:05:25 -08:00
self.clearAndFree(allocator);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
return new_memory;
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
/// The caller owns the returned memory. ArrayList becomes empty.
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
pub fn toOwnedSliceSentinel(self: *Self, allocator: Allocator, comptime sentinel: T) Allocator.Error!SentinelSlice(sentinel) {
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
// This addition can never overflow because `self.items` can never occupy the whole address space
try self.ensureTotalCapacityPrecise(allocator, self.items.len + 1);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
self.appendAssumeCapacity(sentinel);
const result = try self.toOwnedSlice(allocator);
move ArrayListSentineled to std lib orphanage
2020-12-23 16:24:22 +02:00
return result[0 .. result.len - 1 :sentinel];
}
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
/// Creates a copy of this ArrayList.
Allow const ArrayLists to be cloned
2022-12-04 23:46:32 -06:00
pub fn clone(self: Self, allocator: Allocator) Allocator.Error!Self {
Preserve alignment when cloning
2021-12-16 10:55:35 +01:00
var cloned = try Self.initCapacity(allocator, self.capacity);
Implement clone with initCapacity and appendSliceAssumeCapacity `ArrayList.ensureTotalCapacityPrecise` uses `Allocator.reallocAtLeast` under the hood, which can return more than `new_capacity` bytes if `alignment != @alignOf(T)`. This implementation of `clone` assures that the case of `ensureTotalCapacityPrecise` is handled correctly. Thanks @Vexu and @squeek502 for pointing this out.
2021-12-13 15:01:05 +01:00
cloned.appendSliceAssumeCapacity(self.items);
return cloned;
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Insert `item` at index `i`. Moves `list[i .. list.len]` to higher indices to make room.
/// If `i` is equal to the length of the list this operation is equivalent to append.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// This operation is O(N).
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
/// Asserts that the index is in bounds or equal to the length.
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
pub fn insert(self: *Self, allocator: Allocator, i: usize, item: T) Allocator.Error!void {
const dst = try self.addManyAt(allocator, i, 1);
Improve (Unmanaged)ArrayList.insert (Unmanaged)ArrayList.insert has the same inefficiency as the old insertSlice. With the new addManyAt, the solution is trivial. Also improves the test "growing memory preserves contents". In the previous implementation, if any changes were made to the ArrayList memory growth policy (function growMemory), the list could end up with enough capacity to not trigger a memory growth, defeating the purpose of the test. The new implementation more robustly triggers a memory growth.
2023-09-30 14:43:08 -03:00
dst[0] = item;
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Insert `item` at index `i`. Moves `list[i .. list.len]` to higher indices to make room.
/// If in` is equal to the length of the list this operation is equivalent to append.
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
/// This operation is O(N).
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list has capacity for one additional item.
/// Asserts that the index is in bounds or equal to the length.
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
pub fn insertAssumeCapacity(self: *Self, i: usize, item: T) void {
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
assert(self.items.len < self.capacity);
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
self.items.len += 1;
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
mem.copyBackwards(T, self.items[i + 1 .. self.items.len], self.items[i .. self.items.len - 1]);
self.items[i] = item;
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
/// Add `count` new elements at position `index`, which have
/// `undefined` values. Returns a slice pointing to the newly allocated
/// elements, which becomes invalid after various `ArrayList`
/// operations.
/// Invalidates pre-existing pointers to elements at and after `index`.
/// Invalidates all pre-existing element pointers if capacity must be
std: fix typos (#20560)
2024-07-10 00:25:42 +03:00
/// increased to accommodate the new elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the index is in bounds or equal to the length.
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
pub fn addManyAt(
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
self: *Self,
allocator: Allocator,
index: usize,
count: usize,
) Allocator.Error![]T {
var managed = self.toManaged(allocator);
defer self.* = managed.moveToUnmanaged();
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
return managed.addManyAt(index, count);
}
/// Add `count` new elements at position `index`, which have
/// `undefined` values. Returns a slice pointing to the newly allocated
/// elements, which becomes invalid after various `ArrayList`
/// operations.
/// Invalidates pre-existing pointers to elements at and after `index`, but
/// does not invalidate any before that.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list has capacity for the additional items.
/// Asserts that the index is in bounds or equal to the length.
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
pub fn addManyAtAssumeCapacity(self: *Self, index: usize, count: usize) []T {
const new_len = self.items.len + count;
assert(self.capacity >= new_len);
const to_move = self.items[index..];
self.items.len = new_len;
mem.copyBackwards(T, self.items[index + count ..], to_move);
const result = self.items[index..][0..count];
@memset(result, undefined);
return result;
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
}
/// Insert slice `items` at index `i` by moving `list[i .. list.len]` to make room.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// This operation is O(N).
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
/// Invalidates pre-existing pointers to elements at and after `index`.
/// Invalidates all pre-existing element pointers if capacity must be
std: fix typos (#20560)
2024-07-10 00:25:42 +03:00
/// increased to accommodate the new elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the index is in bounds or equal to the length.
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
pub fn insertSlice(
self: *Self,
allocator: Allocator,
index: usize,
items: []const T,
) Allocator.Error!void {
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
const dst = try self.addManyAt(
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
allocator,
index,
items.len,
);
@memcpy(dst, items);
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
std.ArrayList: pedantic fixups to previous commit * fix and clarify incorrect doc comments * unify the pattern of calling unmanaged methods
2024-01-19 15:46:23 -07:00
/// Grows or shrinks the list as necessary.
/// Invalidates element pointers if additional capacity is allocated.
/// Asserts that the range is in bounds.
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
pub fn replaceRange(
self: *Self,
allocator: Allocator,
start: usize,
len: usize,
new_items: []const T,
) Allocator.Error!void {
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
const after_range = start + len;
const range = self.items[start..after_range];
if (range.len < new_items.len) {
const first = new_items[0..range.len];
const rest = new_items[range.len..];
@memcpy(range[0..first.len], first);
try self.insertSlice(allocator, after_range, rest);
} else {
self.replaceRangeAssumeCapacity(start, len, new_items);
}
}
std.ArrayList: pedantic fixups to previous commit * fix and clarify incorrect doc comments * unify the pattern of calling unmanaged methods
2024-01-19 15:46:23 -07:00
/// Grows or shrinks the list as necessary.
/// Never invalidates element pointers.
/// Asserts the capacity is enough for additional items.
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
pub fn replaceRangeAssumeCapacity(self: *Self, start: usize, len: usize, new_items: []const T) void {
const after_range = start + len;
const range = self.items[start..after_range];
if (range.len == new_items.len)
@memcpy(range[0..new_items.len], new_items)
else if (range.len < new_items.len) {
const first = new_items[0..range.len];
const rest = new_items[range.len..];
@memcpy(range[0..first.len], first);
const dst = self.addManyAtAssumeCapacity(after_range, rest.len);
@memcpy(dst, rest);
} else {
const extra = range.len - new_items.len;
@memcpy(range[0..new_items.len], new_items);
std.mem.copyForwards(
T,
self.items[after_range - extra ..],
self.items[after_range..],
);
@memset(self.items[self.items.len - extra ..], undefined);
self.items.len -= extra;
}
add replaceRange() function to ArrayList generalizes functionality of ArrayList.insertSlice() to overwrite a range of elements in the list and to grow or shrink the list as needed to accommodate size difference of the replacing slice and the range of existing elements.
2020-06-02 11:12:26 -05:00
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// Extend the list by 1 element. Allocates more memory as necessary.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn append(self: *Self, allocator: Allocator, item: T) Allocator.Error!void {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
const new_item_ptr = try self.addOne(allocator);
new_item_ptr.* = item;
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Extend the list by 1 element.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
/// Asserts that the list can hold one additional item.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn appendAssumeCapacity(self: *Self, item: T) void {
std.array_list: tiny refactor for pleasure
2024-12-05 21:32:07 -08:00
self.addOneAssumeCapacity().* = item;
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
/// Remove the element at index `i` from the list and return its value.
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Invalidates pointers to the last element.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// This operation is O(N).
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list is not empty.
/// Asserts that the index is in bounds.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn orderedRemove(self: *Self, i: usize) T {
const old_item = self.items[i];
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
self.replaceRangeAssumeCapacity(i, 1, &.{});
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return old_item;
}
/// Removes the element at the specified index and returns it.
/// The empty slot is filled from the end of the list.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// Invalidates pointers to last element.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// This operation is O(1).
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list is not empty.
/// Asserts that the index is in bounds.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn swapRemove(self: *Self, i: usize) T {
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
if (self.items.len - 1 == i) return self.pop().?;
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
const old_item = self.items[i];
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
self.items[i] = self.pop().?;
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return old_item;
}
/// Append the slice of items to the list. Allocates more
/// memory as necessary.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn appendSlice(self: *Self, allocator: Allocator, items: []const T) Allocator.Error!void {
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
try self.ensureUnusedCapacity(allocator, items.len);
self-hosted: rework the memory layout of ir.Module and related types * add TypedValue.Managed which represents a Type, a Value, and some kind of memory management strategy. * introduce an analysis queue * flesh out how incremental compilation works with respect to exports * ir.text.Module is only capable of one error message during parsing * link.zig no longer has a decl table map and instead has structs that exist directly on ir.Module.Decl and ir.Module.Export * implement primitive .text block allocation * implement linker code for updating Decls and Exports * implement null Type Some supporting std lib changes: * add std.ArrayList.appendSliceAssumeCapacity * add std.fs.File.copyRange and copyRangeAll * fix std.HashMap having modification safety on in ReleaseSmall builds * add std.HashMap.putAssumeCapacityNoClobber
2020-05-12 01:02:48 -04:00
self.appendSliceAssumeCapacity(items);
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Append the slice of items to the list.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
pub fn appendSliceAssumeCapacity(self: *Self, items: []const T) void {
std.ArrayList: add missing assertion in appendSliceAssumeCapacity
2021-07-19 18:57:57 -07:00
const old_len = self.items.len;
const new_len = old_len + items.len;
assert(new_len <= self.capacity);
self.items.len = new_len;
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(self.items[old_len..][0..items.len], items);
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
/// Append the slice of items to the list. Allocates more
/// memory as necessary. Only call this function if a call to `appendSlice` instead would
/// be a compile error.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
pub fn appendUnalignedSlice(self: *Self, allocator: Allocator, items: []align(1) const T) Allocator.Error!void {
try self.ensureUnusedCapacity(allocator, items.len);
self.appendUnalignedSliceAssumeCapacity(items);
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// Append an unaligned slice of items to the list.
/// Only call this function if a call to `appendSliceAssumeCapacity`
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
/// instead would be a compile error.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
pub fn appendUnalignedSliceAssumeCapacity(self: *Self, items: []align(1) const T) void {
const old_len = self.items.len;
const new_len = old_len + items.len;
assert(new_len <= self.capacity);
self.items.len = new_len;
change semantics of `@memcpy` and `@memset` Now they use slices or array pointers with any element type instead of requiring byte pointers. This is a breaking enhancement to the language. The safety check for overlapping pointers will be implemented in a future commit. closes #14040
2023-04-13 21:44:40 -07:00
@memcpy(self.items[old_len..][0..items.len], items);
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
}
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
pub const WriterContext = struct {
self: *Self,
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
allocator: Allocator,
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
};
pub const Writer = if (T != u8)
@compileError("The Writer interface is only defined for ArrayList(u8) " ++
"but the given type is ArrayList(" ++ @typeName(T) ++ ")")
else
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
std.io.Writer(WriterContext, Allocator.Error, appendWrite);
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
/// Initializes a Writer which will append to the list.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn writer(self: *Self, allocator: Allocator) Writer {
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
return .{ .context = .{ .self = self, .allocator = allocator } };
}
std.ArrayList: add writerAssumeCapacity Useful when you want to use an ArrayList to operate on a static buffer.
2024-02-20 03:16:02 -07:00
/// Same as `append` except it returns the number of bytes written,
/// which is always the same as `m.len`. The purpose of this function
/// existing is to match `std.io.Writer` API.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
fn appendWrite(context: WriterContext, m: []const u8) Allocator.Error!usize {
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
try context.self.appendSlice(context.allocator, m);
return m.len;
}
std.ArrayList: fixedWriter A writer that appends to the list, returning error.OutOfMemory rather than attempting to increase capacity.
2024-02-21 17:37:41 -07:00
pub const FixedWriter = std.io.Writer(*Self, Allocator.Error, appendWriteFixed);
std.ArrayList: add writerAssumeCapacity Useful when you want to use an ArrayList to operate on a static buffer.
2024-02-20 03:16:02 -07:00
std.ArrayList: fixedWriter A writer that appends to the list, returning error.OutOfMemory rather than attempting to increase capacity.
2024-02-21 17:37:41 -07:00
/// Initializes a Writer which will append to the list but will return
/// `error.OutOfMemory` rather than increasing capacity.
pub fn fixedWriter(self: *Self) FixedWriter {
std.ArrayList: add writerAssumeCapacity Useful when you want to use an ArrayList to operate on a static buffer.
2024-02-20 03:16:02 -07:00
return .{ .context = self };
}
std.ArrayList: fixedWriter A writer that appends to the list, returning error.OutOfMemory rather than attempting to increase capacity.
2024-02-21 17:37:41 -07:00
/// The purpose of this function existing is to match `std.io.Writer` API.
fn appendWriteFixed(self: *Self, m: []const u8) error{OutOfMemory}!usize {
const available_capacity = self.capacity - self.items.len;
if (m.len > available_capacity)
return error.OutOfMemory;
std.ArrayList: add writerAssumeCapacity Useful when you want to use an ArrayList to operate on a static buffer.
2024-02-20 03:16:02 -07:00
self.appendSliceAssumeCapacity(m);
return m.len;
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// Append a value to the list `n` times.
/// Allocates more memory as necessary.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
/// The function is inline so that a comptime-known `value` parameter will
/// have a more optimal memset codegen in case it has a repeated byte pattern.
pub inline fn appendNTimes(self: *Self, allocator: Allocator, value: T, n: usize) Allocator.Error!void {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
const old_len = self.items.len;
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
try self.resize(allocator, try addOrOom(old_len, n));
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
@memset(self.items[old_len..self.items.len], value);
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
std.ArrayList: add appendNTimesAssumeCapacity
2020-07-31 01:16:17 -07:00
/// Append a value to the list `n` times.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
/// The function is inline so that a comptime-known `value` parameter will
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
/// have better memset codegen in case it has a repeated byte pattern.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
pub inline fn appendNTimesAssumeCapacity(self: *Self, value: T, n: usize) void {
std.ArrayList: add appendNTimesAssumeCapacity
2020-07-31 01:16:17 -07:00
const new_len = self.items.len + n;
assert(new_len <= self.capacity);
std.ArrayList: mark the appendNTimes methods inline The previous commit introduced an optimization to the LLVM backend that makes `@memset` lower more optimally when the element is comptime-known and has a repeating byte pattern. By making these functions inline, if the element parameter is comptime-known at the callsite, it will be comptime-known in the `@memset` call, causing more use of the LLVM `memset` intrinsic rather than an inline for loop when using the LLVM backend. This affects, for example, std.crypto.argon2, which calls appendNTimesAssumeCapacity with a `[128]u64` as the element. This is now lowered with a single `memset` call.
2023-04-26 13:48:38 -07:00
@memset(self.items.ptr[self.items.len..new_len], value);
std.ArrayList: add appendNTimesAssumeCapacity
2020-07-31 01:16:17 -07:00
self.items.len = new_len;
}
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Adjust the list length to `new_len`.
/// Additional elements contain the value `undefined`.
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn resize(self: *Self, allocator: Allocator, new_len: usize) Allocator.Error!void {
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
try self.ensureTotalCapacity(allocator, new_len);
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
self.items.len = new_len;
}
/// Reduce allocated capacity to `new_len`.
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
/// May invalidate element pointers.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the new length is less than or equal to the previous length.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn shrinkAndFree(self: *Self, allocator: Allocator, new_len: usize) void {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
assert(new_len <= self.items.len);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
if (@sizeOf(T) == 0) {
self.items.len = new_len;
return;
}
const old_memory = self.allocatedSlice();
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
if (allocator.remap(old_memory, new_len)) |new_items| {
self.capacity = new_items.len;
self.items = new_items;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
return;
}
const new_memory = allocator.alignedAlloc(T, alignment, new_len) catch |e| switch (e) {
error.OutOfMemory => {
// No problem, capacity is still correct then.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
self.items.len = new_len;
return;
},
};
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(new_memory, self.items[0..new_len]);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
allocator.free(old_memory);
self.items = new_memory;
self.capacity = new_memory.len;
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
reimplement std.HashMap * breaking changes to the API. Some of the weird decisions from before are changed to what would be more expected. - `get` returns `?V`, use `getEntry` for the old API. - `put` returns `!void`, use `fetchPut` for the old API. * HashMap now has a comptime parameter of whether to store hashes with entries. AutoHashMap has heuristics on whether to set this parameter. For example, for integers, it is false, since equality checking is cheap, but for strings, it is true, since equality checking is probably expensive. * The implementation has a separate array for entry_index / distance_from_start_index. Entries no longer has holes; it is an ArrayList, and iteration is simpler and more cache coherent. This is inspired by Python's new dictionaries. * HashMap is separated into an "unmanaged" and a "managed" API. The unmanaged API is where the actual implementation is; the managed API wraps it and provides a more convenient API, storing the allocator. * Memory usage: When there are less than or equal to 8 entries, HashMap now incurs only a single pointer-size integer as overhead, opposed to using an ArrayList. * Since the entries array is separate from the indexes array, the holes in the indexes array take up less room than the holes in the entries array otherwise would. However the entries array also allocates additional capacity for appending into the array. * HashMap now maintains insertion order. Deletion performs a "swap remove". It's now possible to modify the HashMap while iterating.
2020-07-03 23:57:24 +00:00
/// Reduce length to `new_len`.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// Invalidates pointers to elements `items[new_len..]`.
reimplement std.HashMap * breaking changes to the API. Some of the weird decisions from before are changed to what would be more expected. - `get` returns `?V`, use `getEntry` for the old API. - `put` returns `!void`, use `fetchPut` for the old API. * HashMap now has a comptime parameter of whether to store hashes with entries. AutoHashMap has heuristics on whether to set this parameter. For example, for integers, it is false, since equality checking is cheap, but for strings, it is true, since equality checking is probably expensive. * The implementation has a separate array for entry_index / distance_from_start_index. Entries no longer has holes; it is an ArrayList, and iteration is simpler and more cache coherent. This is inspired by Python's new dictionaries. * HashMap is separated into an "unmanaged" and a "managed" API. The unmanaged API is where the actual implementation is; the managed API wraps it and provides a more convenient API, storing the allocator. * Memory usage: When there are less than or equal to 8 entries, HashMap now incurs only a single pointer-size integer as overhead, opposed to using an ArrayList. * Since the entries array is separate from the indexes array, the holes in the indexes array take up less room than the holes in the entries array otherwise would. However the entries array also allocates additional capacity for appending into the array. * HashMap now maintains insertion order. Deletion performs a "swap remove". It's now possible to modify the HashMap while iterating.
2020-07-03 23:57:24 +00:00
/// Keeps capacity the same.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the new length is less than or equal to the previous length.
reimplement std.HashMap * breaking changes to the API. Some of the weird decisions from before are changed to what would be more expected. - `get` returns `?V`, use `getEntry` for the old API. - `put` returns `!void`, use `fetchPut` for the old API. * HashMap now has a comptime parameter of whether to store hashes with entries. AutoHashMap has heuristics on whether to set this parameter. For example, for integers, it is false, since equality checking is cheap, but for strings, it is true, since equality checking is probably expensive. * The implementation has a separate array for entry_index / distance_from_start_index. Entries no longer has holes; it is an ArrayList, and iteration is simpler and more cache coherent. This is inspired by Python's new dictionaries. * HashMap is separated into an "unmanaged" and a "managed" API. The unmanaged API is where the actual implementation is; the managed API wraps it and provides a more convenient API, storing the allocator. * Memory usage: When there are less than or equal to 8 entries, HashMap now incurs only a single pointer-size integer as overhead, opposed to using an ArrayList. * Since the entries array is separate from the indexes array, the holes in the indexes array take up less room than the holes in the entries array otherwise would. However the entries array also allocates additional capacity for appending into the array. * HashMap now maintains insertion order. Deletion performs a "swap remove". It's now possible to modify the HashMap while iterating.
2020-07-03 23:57:24 +00:00
pub fn shrinkRetainingCapacity(self: *Self, new_len: usize) void {
assert(new_len <= self.items.len);
self.items.len = new_len;
}
std.ArrayList: add clearRetainingCapacity and clearAndFree
2021-05-05 16:55:49 -07:00
/// Invalidates all element pointers.
pub fn clearRetainingCapacity(self: *Self) void {
self.items.len = 0;
}
/// Invalidates all element pointers.
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
pub fn clearAndFree(self: *Self, allocator: Allocator) void {
std.ArrayList: add clearRetainingCapacity and clearAndFree
2021-05-05 16:55:49 -07:00
allocator.free(self.allocatedSlice());
self.items.len = 0;
self.capacity = 0;
}
reimplement std.HashMap * breaking changes to the API. Some of the weird decisions from before are changed to what would be more expected. - `get` returns `?V`, use `getEntry` for the old API. - `put` returns `!void`, use `fetchPut` for the old API. * HashMap now has a comptime parameter of whether to store hashes with entries. AutoHashMap has heuristics on whether to set this parameter. For example, for integers, it is false, since equality checking is cheap, but for strings, it is true, since equality checking is probably expensive. * The implementation has a separate array for entry_index / distance_from_start_index. Entries no longer has holes; it is an ArrayList, and iteration is simpler and more cache coherent. This is inspired by Python's new dictionaries. * HashMap is separated into an "unmanaged" and a "managed" API. The unmanaged API is where the actual implementation is; the managed API wraps it and provides a more convenient API, storing the allocator. * Memory usage: When there are less than or equal to 8 entries, HashMap now incurs only a single pointer-size integer as overhead, opposed to using an ArrayList. * Since the entries array is separate from the indexes array, the holes in the indexes array take up less room than the holes in the entries array otherwise would. However the entries array also allocates additional capacity for appending into the array. * HashMap now maintains insertion order. Deletion performs a "swap remove". It's now possible to modify the HashMap while iterating.
2020-07-03 23:57:24 +00:00
std.ArrayList: initial capacity based on cache line size also std.MultiArrayList
2025-02-11 18:53:13 -08:00
/// Modify the array so that it can hold at least `new_capacity` items.
/// Implements super-linear growth to achieve amortized O(1) append operations.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
std.ArrayList: initial capacity based on cache line size also std.MultiArrayList
2025-02-11 18:53:13 -08:00
pub fn ensureTotalCapacity(self: *Self, gpa: Allocator, new_capacity: usize) Allocator.Error!void {
std.ArrayList.ensureTotalCapacity: optimize and fix integer overflow Fixes #12099
2022-07-13 17:30:51 +04:30
if (self.capacity >= new_capacity) return;
std.ArrayList: initial capacity based on cache line size also std.MultiArrayList
2025-02-11 18:53:13 -08:00
return self.ensureTotalCapacityPrecise(gpa, growCapacity(self.capacity, new_capacity));
std.ArrayList: add ensureTotalCapacityPrecise and update doc comments initCapacity did and still does use the ensureTotalCapacityPrecise logic because the initial capacity of an ArrayList is not important in terms of how it grows, so allocating a more exact slice up-front allows for saving memory when the array list never exceeds that initial allocation size. There are use cases where this precise capacity is useful outside of the `init` function, though, like in instances where the user does not call the `init` function themselves but otherwise knows that an ArrayList is empty so calling `ensureTotalCapacityPrecise` can give the same memory savings that `initCapacity` would have. Closes #9775
2021-11-01 00:38:11 -07:00
}
std.ArrayList: Clarify that ensureTotalCapacity/ensureTotalCapacityPrecise will never shrink the array Closes #18499
2024-01-11 16:09:32 -08:00
/// If the current capacity is less than `new_capacity`, this function will
/// modify the array so that it can hold exactly `new_capacity` items.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn ensureTotalCapacityPrecise(self: *Self, allocator: Allocator, new_capacity: usize) Allocator.Error!void {
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
if (@sizeOf(T) == 0) {
self.capacity = math.maxInt(usize);
return;
}
std.ArrayList: add ensureTotalCapacityPrecise and update doc comments initCapacity did and still does use the ensureTotalCapacityPrecise logic because the initial capacity of an ArrayList is not important in terms of how it grows, so allocating a more exact slice up-front allows for saving memory when the array list never exceeds that initial allocation size. There are use cases where this precise capacity is useful outside of the `init` function, though, like in instances where the user does not call the `init` function themselves but otherwise knows that an ArrayList is empty so calling `ensureTotalCapacityPrecise` can give the same memory savings that `initCapacity` would have. Closes #9775
2021-11-01 00:38:11 -07:00
if (self.capacity >= new_capacity) return;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
// Here we avoid copying allocated but unused bytes by
// attempting a resize in place, and falling back to allocating
// a new buffer and doing our own copy. With a realloc() call,
// the allocator implementation would pointlessly copy our
// extra capacity.
const old_memory = self.allocatedSlice();
std.mem.Allocator: introduce `remap` function to the interface This one changes the size of an allocation, allowing it to be relocated. However, the implementation will still return `null` if it would be equivalent to new = alloc memcpy(new, old) free(old) Mainly this prepares for taking advantage of `mremap` which I thought would be a bigger deal but apparently is only available on Linux. Still, we should use it on Linux.
2025-02-03 19:55:09 -08:00
if (allocator.remap(old_memory, new_capacity)) |new_memory| {
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
} else {
const new_memory = try allocator.alignedAlloc(T, alignment, new_capacity);
update codebase to use `@memset` and `@memcpy`
2023-04-26 13:57:08 -07:00
@memcpy(new_memory[0..self.items.len], self.items);
std.mem.Allocator: allow shrink to fail closes #13535
2022-11-27 01:07:35 -07:00
allocator.free(old_memory);
self.items.ptr = new_memory.ptr;
self.capacity = new_memory.len;
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
}
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
/// Modify the array so that it can hold at least `additional_count` **more** items.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Invalidates element pointers if additional memory is needed.
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
pub fn ensureUnusedCapacity(
self: *Self,
allocgate: std Allocator interface refactor
2021-10-29 00:37:25 +01:00
allocator: Allocator,
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
additional_count: usize,
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
) Allocator.Error!void {
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
return self.ensureTotalCapacity(allocator, try addOrOom(self.items.len, additional_count));
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// Increases the array's length to match the full capacity that is already allocated.
/// The new elements have `undefined` values.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn expandToCapacity(self: *Self) void {
self.items.len = self.capacity;
}
/// Increase length by 1, returning pointer to the new item.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// The returned element pointer becomes invalid when the list is resized.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn addOne(self: *Self, allocator: Allocator) Allocator.Error!*T {
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
// This can never overflow because `self.items` can never occupy the whole address space
const newlen = self.items.len + 1;
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
try self.ensureTotalCapacity(allocator, newlen);
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return self.addOneAssumeCapacity();
}
/// Increase length by 1, returning pointer to the new item.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
/// The returned element pointer becomes invalid when the list is resized.
/// Asserts that the list can hold one additional item.
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
pub fn addOneAssumeCapacity(self: *Self) *T {
assert(self.items.len < self.capacity);
self.items.len += 1;
return &self.items[self.items.len - 1];
}
std: add new array list functions
2020-07-06 06:09:47 +00:00
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is an array pointing to the newly allocated elements.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// The returned pointer becomes invalid when the list is resized.
[std.ArrayList] return explicit errors All errors from std.ArrayList are allocation errors. Mark them as such. This is helpful when one wants to obtain a function pointer.
2022-02-20 11:39:51 +02:00
pub fn addManyAsArray(self: *Self, allocator: Allocator, comptime n: usize) Allocator.Error!*[n]T {
std: add new array list functions
2020-07-06 06:09:47 +00:00
const prev_len = self.items.len;
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
try self.resize(allocator, try addOrOom(self.items.len, n));
std: add new array list functions
2020-07-06 06:09:47 +00:00
return self.items[prev_len..][0..n];
}
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is an array pointing to the newly allocated elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// The returned pointer becomes invalid when the list is resized.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
std: add new array list functions
2020-07-06 06:09:47 +00:00
pub fn addManyAsArrayAssumeCapacity(self: *Self, comptime n: usize) *[n]T {
assert(self.items.len + n <= self.capacity);
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
const prev_len = self.items.len;
self.items.len += n;
return self.items[prev_len..][0..n];
}
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is a slice pointing to the newly allocated elements.
/// The returned pointer becomes invalid when the list is resized.
/// Resizes list if `self.capacity` is not large enough.
pub fn addManyAsSlice(self: *Self, allocator: Allocator, n: usize) Allocator.Error![]T {
const prev_len = self.items.len;
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
try self.resize(allocator, try addOrOom(self.items.len, n));
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
return self.items[prev_len..][0..n];
}
/// Resize the array, adding `n` new elements, which have `undefined` values.
/// The return value is a slice pointing to the newly allocated elements.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Never invalidates element pointers.
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
/// The returned pointer becomes invalid when the list is resized.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list can hold the additional items.
InternPool: port most of value tags
2023-05-22 07:58:02 -04:00
pub fn addManyAsSliceAssumeCapacity(self: *Self, n: usize) []T {
assert(self.items.len + n <= self.capacity);
std: add new array list functions
2020-07-06 06:09:47 +00:00
const prev_len = self.items.len;
self.items.len += n;
return self.items[prev_len..][0..n];
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
/// Remove and return the last element from the list.
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
/// If the list is empty, returns `null`.
Improve documentation for ArrayList, ArrayListUnmanaged, etc. (#7624) * Improve ArrayList & co documentation - Added doc comments about the validity of references to elements in an ArrayList and how they may become invalid after resizing operations. - This should help users avoid footguns in future. * Improve ArrayListUnmanaged & co's documentation - Port improved documentation from ArrayList and ArrayList aligned to their unmanaged counterparts. - Made documentation for ArrayListUnmanaged & co more inclusive and up-to-date. - Made documentation more consistent with `ArrayList`. * Corrections on ArrayList documentation. - Remove incorrect/unpreferred wording on ArrayList vs ArrayListUnmanaged. - Fix notes about the alignment of ArrayListAligned - Be more verbose with warnings on when pointers are invalidated. - Copy+paste a few warnings * add warning to replaceRange * revert changes to append documentation
2021-01-02 18:06:51 -06:00
/// Invalidates pointers to last element.
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
pub fn pop(self: *Self) ?T {
if (self.items.len == 0) return null;
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
const val = self.items[self.items.len - 1];
self.items.len -= 1;
return val;
}
std: reword some comments
2023-07-16 18:32:52 -07:00
/// Returns a slice of all the items plus the extra capacity, whose memory
/// contents are `undefined`.
std: publicize ArrayListUnmanaged.allocatedSlice to match ArrayList
2021-09-11 00:11:51 +01:00
pub fn allocatedSlice(self: Self) Slice {
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
return self.items.ptr[0..self.capacity];
}
ArrayList: add unusedCapacitySlice to the unmanaged API This function is super nice thank you whoever added it 👍
2022-02-18 19:35:39 -07:00
/// Returns a slice of only the extra capacity after items.
/// This can be useful for writing directly into an ArrayList.
/// Note that such an operation must be followed up with a direct
/// modification of `self.items.len`.
std.ArrayList.unusedCapacitySlice: Return unaligned slice (#20490)
2024-07-14 00:56:29 +00:00
pub fn unusedCapacitySlice(self: Self) []T {
ArrayList: add unusedCapacitySlice to the unmanaged API This function is super nice thank you whoever added it 👍
2022-02-18 19:35:39 -07:00
return self.allocatedSlice()[self.items.len..];
}
Add the two functions 'getLast' and 'getLastOrNull' to ArrayListAligned/ArrayListAlignedUnmanaged.
2022-12-29 00:24:57 +01:00
/// Return the last element from the list.
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Asserts that the list is not empty.
Allow const for ArrayList.getLast, fix #14522
2023-02-04 03:01:47 +01:00
pub fn getLast(self: Self) T {
Add the two functions 'getLast' and 'getLastOrNull' to ArrayListAligned/ArrayListAlignedUnmanaged.
2022-12-29 00:24:57 +01:00
const val = self.items[self.items.len - 1];
return val;
}
/// Return the last element from the list, or
/// return `null` if list is empty.
Allow const for ArrayList.getLast, fix #14522
2023-02-04 03:01:47 +01:00
pub fn getLastOrNull(self: Self) ?T {
Add the two functions 'getLast' and 'getLastOrNull' to ArrayListAligned/ArrayListAlignedUnmanaged.
2022-12-29 00:24:57 +01:00
if (self.items.len == 0) return null;
return self.getLast();
}
rework self-hosted compiler for incremental builds * introduce std.ArrayListUnmanaged for when you have the allocator stored elsewhere * move std.heap.ArenaAllocator implementation to its own file. extract the main state into std.heap.ArenaAllocator.State, which can be stored as an alternative to storing the entire ArenaAllocator, saving 24 bytes per ArenaAllocator on 64 bit targets. * std.LinkedList.Node pointer field now defaults to being null initialized. * Rework self-hosted compiler Package API * Delete almost all the bitrotted self-hosted compiler code. The only bit rotted code left is in main.zig and compilation.zig * Add call instruction to ZIR * self-hosted compiler ir API and link API are reworked to support a long-running compiler that incrementally updates declarations * Introduce the concept of scopes to ZIR semantic analysis * ZIR text format supports referencing named decls that are declared later in the file * Figure out how memory management works for the long-running compiler and incremental compilation. The main roots are top level declarations. There is a table of decls. The key is a cryptographic hash of the fully qualified decl name. Each decl has an arena allocator where all of the memory related to that decl is stored. Each code block has its own arena allocator for the lifetime of the block. Values that want to survive when going out of scope in a block must get copied into the outer block. Finally, values must get copied into the Decl arena to be long-lived. * Delete the unused MemoryCell struct. Instead, comptime pointers are based on references to Decl structs. * Figure out how caching works. Each Decl will store a set of other Decls which must be recompiled when it changes. This branch is still work-in-progress; this commit breaks the build.
2020-05-10 02:05:54 -04:00
std.ArrayList: initial capacity based on cache line size also std.MultiArrayList
2025-02-11 18:53:13 -08:00
const init_capacity = @as(comptime_int, @max(1, std.atomic.cache_line / @sizeOf(T)));
/// Called when memory growth is necessary. Returns a capacity larger than
/// minimum that grows super-linearly.
fn growCapacity(current: usize, minimum: usize) usize {
var new = current;
while (true) {
new +|= new / 2 + init_capacity;
if (new >= minimum)
return new;
}
}
};
std.ArrayList: fixups for the previous commit * Move `computeBetterCapacity` to the bottom so that `pub` stuff shows up first. * Rename `computeBetterCapacity` to `growCapacity`. Every function implicitly computes something; that word is always redundant in a function name. "better" is vague. Better in what way? Instead we describe what is actually happening. "grow". * Improve doc comments to be very explicit about when element pointers are invalidated or not. * Rename `addManyAtIndex` to `addManyAt`. The parameter is named `index`; that is enough. * Extract some duplicated code into `addManyAtAssumeCapacity` and make it `pub`. * Since I audited every line of code for correctness, I changed the style to my personal preference. * Avoid a redundant `@memset` to `undefined` - memory allocation does that already. * Fixed comment giving the wrong reason for not calling `ensureTotalCapacity`.
2023-09-29 13:36:47 -07:00
}
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
/// Integer addition returning `error.OutOfMemory` on overflow.
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
fn addOrOom(a: usize, b: usize) error{OutOfMemory}!usize {
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
const result, const overflow = @addWithOverflow(a, b);
if (overflow != 0) return error.OutOfMemory;
return result;
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "init" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
{
var list = ArrayList(i32).init(testing.allocator);
defer list.deinit();
Add capacity and appendAssumeCapacity to ArrayList
2018-09-09 12:54:00 +02:00
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 0);
try testing.expect(list.capacity == 0);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Add capacity and appendAssumeCapacity to ArrayList
2018-09-09 12:54:00 +02:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
const list: ArrayListUnmanaged(i32) = .empty;
Added initCapacity and relevant test Added ArrayList.initCapcity() as a way to preallocate a block of memory to reduce future allocations. Added a test "std.ArrayList.initCapacity" that ensures initCapacity adds no elements and increases capacity by at least the requested amount
2019-11-23 22:54:33 -05:00
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 0);
try testing.expect(list.capacity == 0);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
}
add list implementation to standard library
2016-05-08 01:34:00 -07:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "initCapacity" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.allocator;
behavior tests passing with new pointer deref syntax
2018-05-01 01:53:04 -04:00
{
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
var list = try ArrayList(i8).initCapacity(a, 200);
defer list.deinit();
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 0);
try testing.expect(list.capacity >= 200);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
var list = try ArrayListUnmanaged(i8).initCapacity(a, 200);
defer list.deinit(a);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 0);
try testing.expect(list.capacity >= 200);
behavior tests passing with new pointer deref syntax
2018-05-01 01:53:04 -04:00
}
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
add list implementation to standard library
2016-05-08 01:34:00 -07:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "clone" {
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
const a = testing.allocator;
{
var array = ArrayList(i32).init(a);
try array.append(-1);
try array.append(3);
try array.append(5);
const cloned = try array.clone();
defer cloned.deinit();
Use expectEqualSlices instead of loop
2021-12-13 09:01:18 +01:00
try testing.expectEqualSlices(i32, array.items, cloned.items);
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
try testing.expectEqual(array.allocator, cloned.allocator);
Implement clone with initCapacity and appendSliceAssumeCapacity `ArrayList.ensureTotalCapacityPrecise` uses `Allocator.reallocAtLeast` under the hood, which can return more than `new_capacity` bytes if `alignment != @alignOf(T)`. This implementation of `clone` assures that the case of `ensureTotalCapacityPrecise` is handled correctly. Thanks @Vexu and @squeek502 for pointing this out.
2021-12-13 15:01:05 +01:00
try testing.expect(cloned.capacity >= array.capacity);
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
array.deinit();
Set len on copied items array Also fix the argument order for `expectEquals`.
2021-12-13 01:33:22 +01:00
try testing.expectEqual(@as(i32, -1), cloned.items[0]);
try testing.expectEqual(@as(i32, 3), cloned.items[1]);
try testing.expectEqual(@as(i32, 5), cloned.items[2]);
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var array: ArrayListUnmanaged(i32) = .empty;
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
try array.append(a, -1);
try array.append(a, 3);
try array.append(a, 5);
var cloned = try array.clone(a);
defer cloned.deinit(a);
Use expectEqualSlices instead of loop
2021-12-13 09:01:18 +01:00
try testing.expectEqualSlices(i32, array.items, cloned.items);
Implement clone with initCapacity and appendSliceAssumeCapacity `ArrayList.ensureTotalCapacityPrecise` uses `Allocator.reallocAtLeast` under the hood, which can return more than `new_capacity` bytes if `alignment != @alignOf(T)`. This implementation of `clone` assures that the case of `ensureTotalCapacityPrecise` is handled correctly. Thanks @Vexu and @squeek502 for pointing this out.
2021-12-13 15:01:05 +01:00
try testing.expect(cloned.capacity >= array.capacity);
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
array.deinit(a);
Set len on copied items array Also fix the argument order for `expectEquals`.
2021-12-13 01:33:22 +01:00
try testing.expectEqual(@as(i32, -1), cloned.items[0]);
try testing.expectEqual(@as(i32, 3), cloned.items[1]);
try testing.expectEqual(@as(i32, 5), cloned.items[2]);
Add ArrayList.clone This is a common operation and matches the API on other stdlib collections like HashMap and MultiArrayList.
2021-12-13 00:00:04 +01:00
}
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "basic" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.allocator;
behavior tests passing with new pointer deref syntax
2018-05-01 01:53:04 -04:00
{
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
var list = ArrayList(i32).init(a);
defer list.deinit();
{
var i: usize = 0;
while (i < 10) : (i += 1) {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
list.append(@as(i32, @intCast(i + 1))) catch unreachable;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
}
{
var i: usize = 0;
while (i < 10) : (i += 1) {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try testing.expect(list.items[i] == @as(i32, @intCast(i + 1)));
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
}
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (list.items, 0..) |v, i| {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try testing.expect(v == @as(i32, @intCast(i + 1)));
behavior tests passing with new pointer deref syntax
2018-05-01 01:53:04 -04:00
}
delete test_artifacts directory when tests complete * add std.os.deleteTree * add std.os.deleteDir * add std.os.page_size * add std.os API for iterating over directories * refactor duplication in build.zig * update documentation on how to run tests
2017-04-20 02:26:36 -04:00
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.pop() == 10);
try testing.expect(list.items.len == 9);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
list.appendSlice(&[_]i32{ 1, 2, 3 }) catch unreachable;
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 12);
try testing.expect(list.pop() == 3);
try testing.expect(list.pop() == 2);
try testing.expect(list.pop() == 1);
try testing.expect(list.items.len == 9);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
var unaligned: [3]i32 align(1) = [_]i32{ 4, 5, 6 };
list.appendUnalignedSlice(&unaligned) catch unreachable;
try testing.expect(list.items.len == 12);
try testing.expect(list.pop() == 6);
try testing.expect(list.pop() == 5);
try testing.expect(list.pop() == 4);
try testing.expect(list.items.len == 9);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
list.appendSlice(&[_]i32{}) catch unreachable;
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 9);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
// can only set on indices < self.items.len
list.items[7] = 33;
list.items[8] = 42;
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.pop() == 42);
try testing.expect(list.pop() == 33);
Made container methods that can be const, const
2018-05-04 23:48:14 +02:00
}
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer list.deinit(a);
{
var i: usize = 0;
while (i < 10) : (i += 1) {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
list.append(a, @as(i32, @intCast(i + 1))) catch unreachable;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
}
{
var i: usize = 0;
while (i < 10) : (i += 1) {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try testing.expect(list.items[i] == @as(i32, @intCast(i + 1)));
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
}
update std lib and compiler sources to new for loop syntax
2023-02-18 09:02:57 -07:00
for (list.items, 0..) |v, i| {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
try testing.expect(v == @as(i32, @intCast(i + 1)));
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Made container methods that can be const, const
2018-05-04 23:48:14 +02:00
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.pop() == 10);
try testing.expect(list.items.len == 9);
Add appendSlice function (#448)
2017-09-10 05:49:40 +12:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
list.appendSlice(a, &[_]i32{ 1, 2, 3 }) catch unreachable;
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 12);
try testing.expect(list.pop() == 3);
try testing.expect(list.pop() == 2);
try testing.expect(list.pop() == 1);
try testing.expect(list.items.len == 9);
Add appendSlice function (#448)
2017-09-10 05:49:40 +12:00
link.MachO: use accurate alignment attribute on pointers Also adds a new method to ArrayList: appendUnalignedSlice
2022-08-10 22:26:29 -07:00
var unaligned: [3]i32 align(1) = [_]i32{ 4, 5, 6 };
list.appendUnalignedSlice(a, &unaligned) catch unreachable;
try testing.expect(list.items.len == 12);
try testing.expect(list.pop() == 6);
try testing.expect(list.pop() == 5);
try testing.expect(list.pop() == 4);
try testing.expect(list.items.len == 9);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
list.appendSlice(a, &[_]i32{}) catch unreachable;
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 9);
clean up std.ArrayList * add `std.debug.assertError` * `std.ArrayList` update everything to follow `self` convention * rename `std.ArrayList.set` to `std.ArrayList.setOrError` * add `std.ArrayList.set` which asserts Before 1.0.0 we might remove some of this API, because you can use `toSlice()` for everything, but it's ok to add these functions as an experiment before then.
2018-06-09 12:03:11 -04:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
// can only set on indices < self.items.len
list.items[7] = 33;
list.items[8] = 42;
add set function to arraylist so you can set a value without growing the underlying buffer, with range safety checks
2018-06-07 10:00:27 -04:00
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.pop() == 42);
try testing.expect(list.pop() == 33);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
add list implementation to standard library
2016-05-08 01:34:00 -07:00
}
Add ArrayList functions (#755) at - Get the item at the n-th index. insert - Insert and item into the middle of the list, resizing and copying existing elements if needed. insertSlice - Insert a slice into the middle of the list, resizing and copying existing elements if needed.
2018-02-09 05:22:31 +13:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "appendNTimes" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendNTimes(2, 10);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(usize, 10), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
for (list.items) |element| {
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 2), element);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer list.deinit(a);
Add an appendValues method to ArrayList to append a value n times. (#4460)
2020-02-19 17:33:35 +01:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.appendNTimes(a, 2, 10);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(usize, 10), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
for (list.items) |element| {
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 2), element);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Add an appendValues method to ArrayList to append a value n times. (#4460)
2020-02-19 17:33:35 +01:00
}
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "appendNTimes with failing allocator" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.failing_allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectError(error.OutOfMemory, list.appendNTimes(2, 10));
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer list.deinit(a);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectError(error.OutOfMemory, list.appendNTimes(a, 2, 10));
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Add an appendValues method to ArrayList to append a value n times. (#4460)
2020-02-19 17:33:35 +01:00
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "orderedRemove" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.append(1);
try list.append(2);
try list.append(3);
try list.append(4);
try list.append(5);
try list.append(6);
try list.append(7);
//remove from middle
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 4), list.orderedRemove(3));
try testing.expectEqual(@as(i32, 5), list.items[3]);
try testing.expectEqual(@as(usize, 6), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from end
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 7), list.orderedRemove(5));
try testing.expectEqual(@as(usize, 5), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from front
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 1), list.orderedRemove(0));
try testing.expectEqual(@as(i32, 2), list.items[0]);
try testing.expectEqual(@as(usize, 4), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer list.deinit(a);
std: add std.ArrayList.orderedRemove
2019-04-12 12:23:44 +02:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.append(a, 1);
try list.append(a, 2);
try list.append(a, 3);
try list.append(a, 4);
try list.append(a, 5);
try list.append(a, 6);
try list.append(a, 7);
//remove from middle
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 4), list.orderedRemove(3));
try testing.expectEqual(@as(i32, 5), list.items[3]);
try testing.expectEqual(@as(usize, 6), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from end
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 7), list.orderedRemove(5));
try testing.expectEqual(@as(usize, 5), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from front
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqual(@as(i32, 1), list.orderedRemove(0));
try testing.expectEqual(@as(i32, 2), list.items[0]);
try testing.expectEqual(@as(usize, 4), list.items.len);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
{
// remove last item
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.append(1);
try testing.expectEqual(@as(i32, 1), list.orderedRemove(0));
try testing.expectEqual(@as(usize, 0), list.items.len);
}
{
// remove last item
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
defer list.deinit(a);
try list.append(a, 1);
try testing.expectEqual(@as(i32, 1), list.orderedRemove(0));
try testing.expectEqual(@as(usize, 0), list.items.len);
}
std: add std.ArrayList.orderedRemove
2019-04-12 12:23:44 +02:00
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "swapRemove" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
Added `remove` to ArrayList
2018-07-11 12:52:30 -05:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.append(1);
try list.append(2);
try list.append(3);
try list.append(4);
try list.append(5);
try list.append(6);
try list.append(7);
//remove from middle
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.swapRemove(3) == 4);
try testing.expect(list.items[3] == 7);
try testing.expect(list.items.len == 6);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from end
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.swapRemove(5) == 6);
try testing.expect(list.items.len == 5);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from front
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.swapRemove(0) == 1);
try testing.expect(list.items[0] == 5);
try testing.expect(list.items.len == 4);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer list.deinit(a);
try list.append(a, 1);
try list.append(a, 2);
try list.append(a, 3);
try list.append(a, 4);
try list.append(a, 5);
try list.append(a, 6);
try list.append(a, 7);
//remove from middle
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.swapRemove(3) == 4);
try testing.expect(list.items[3] == 7);
try testing.expect(list.items.len == 6);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from end
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.swapRemove(5) == 6);
try testing.expect(list.items.len == 5);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
//remove from front
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.swapRemove(0) == 1);
try testing.expect(list.items[0] == 5);
try testing.expect(list.items.len == 4);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Added `remove` to ArrayList
2018-07-11 12:52:30 -05:00
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "insert" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
Add ArrayList functions (#755) at - Get the item at the n-th index. insert - Insert and item into the middle of the list, resizing and copying existing elements if needed. insertSlice - Insert a slice into the middle of the list, resizing and copying existing elements if needed.
2018-02-09 05:22:31 +13:00
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
try list.insert(0, 1);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.append(2);
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
try list.insert(2, 3);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.insert(0, 5);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items[0] == 5);
try testing.expect(list.items[1] == 1);
try testing.expect(list.items[2] == 2);
try testing.expect(list.items[3] == 3);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer list.deinit(a);
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
try list.insert(a, 0, 1);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.append(a, 2);
std: Add ArrayList.insertAssumeCapacity() Also test and document that inserting at list.items.len is allowed.
2023-03-11 14:52:38 +01:00
try list.insert(a, 2, 3);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.insert(a, 0, 5);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items[0] == 5);
try testing.expect(list.items[1] == 1);
try testing.expect(list.items[2] == 2);
try testing.expect(list.items[3] == 3);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Improve ArrayList insert unit tests.
2018-07-13 22:35:34 +02:00
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "insertSlice" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = testing.allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
Add ArrayList functions (#755) at - Get the item at the n-th index. insert - Insert and item into the middle of the list, resizing and copying existing elements if needed. insertSlice - Insert a slice into the middle of the list, resizing and copying existing elements if needed.
2018-02-09 05:22:31 +13:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.append(1);
try list.append(2);
try list.append(3);
try list.append(4);
try list.insertSlice(1, &[_]i32{ 9, 8 });
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items[0] == 1);
try testing.expect(list.items[1] == 9);
try testing.expect(list.items[2] == 8);
try testing.expect(list.items[3] == 2);
try testing.expect(list.items[4] == 3);
try testing.expect(list.items[5] == 4);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const items = [_]i32{1};
try list.insertSlice(0, items[0..0]);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 6);
try testing.expect(list.items[0] == 1);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer list.deinit(a);
try list.append(a, 1);
try list.append(a, 2);
try list.append(a, 3);
try list.append(a, 4);
try list.insertSlice(a, 1, &[_]i32{ 9, 8 });
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items[0] == 1);
try testing.expect(list.items[1] == 9);
try testing.expect(list.items[2] == 8);
try testing.expect(list.items[3] == 2);
try testing.expect(list.items[4] == 3);
try testing.expect(list.items[5] == 4);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const items = [_]i32{1};
try list.insertSlice(a, 0, items[0..0]);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 6);
try testing.expect(list.items[0] == 1);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Add ArrayList functions (#755) at - Get the item at the n-th index. insert - Insert and item into the middle of the list, resizing and copying existing elements if needed. insertSlice - Insert a slice into the middle of the list, resizing and copying existing elements if needed.
2018-02-09 05:22:31 +13:00
}
tests: re: 79db394; ref: ziglang/zig#1832
2018-12-20 22:49:09 +09:00
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
test "ArrayList.replaceRange" {
const a = testing.allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(1, 0, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(1, 1, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(
i32,
&[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
list.items,
);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(1, 2, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(1, 3, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(1, 4, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
}
}
test "ArrayList.replaceRangeAssumeCapacity" {
const a = testing.allocator;
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 0, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 1, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(
i32,
&[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
list.items,
);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 2, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 3, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
}
{
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendSlice(&[_]i32{ 1, 2, 3, 4, 5 });
add replaceRange() function to ArrayList generalizes functionality of ArrayList.insertSlice() to overwrite a range of elements in the list and to grow or shrink the list as needed to accommodate size difference of the replacing slice and the range of existing elements.
2020-06-02 11:12:26 -05:00
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
list.replaceRangeAssumeCapacity(1, 4, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
}
}
add replaceRange() function to ArrayList generalizes functionality of ArrayList.insertSlice() to overwrite a range of elements in the list and to grow or shrink the list as needed to accommodate size difference of the replacing slice and the range of existing elements.
2020-06-02 11:12:26 -05:00
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
test "ArrayListUnmanaged.replaceRange" {
const a = testing.allocator;
add replaceRange() function to ArrayList generalizes functionality of ArrayList.insertSlice() to overwrite a range of elements in the list and to grow or shrink the list as needed to accommodate size difference of the replacing slice and the range of existing elements.
2020-06-02 11:12:26 -05:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(a, 1, 0, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(a, 1, 1, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(
i32,
&[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
list.items,
);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(a, 1, 2, &[_]i32{ 0, 0, 0 });
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
}
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(a, 1, 3, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
try list.replaceRange(a, 1, 4, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
}
}
test "ArrayListUnmanaged.replaceRangeAssumeCapacity" {
const a = testing.allocator;
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 0, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 2, 3, 4, 5 }, list.items);
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 1, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(
i32,
&[_]i32{ 1, 0, 0, 0, 3, 4, 5 },
list.items,
);
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 2, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 4, 5 }, list.items);
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 3, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0, 5 }, list.items);
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
Refactor ArrayList replaceRange tests
2024-03-30 16:53:15 -04:00
defer list.deinit(a);
try list.appendSlice(a, &[_]i32{ 1, 2, 3, 4, 5 });
list.replaceRangeAssumeCapacity(1, 4, &[_]i32{ 0, 0, 0 });
try testing.expectEqualSlices(i32, &[_]i32{ 1, 0, 0, 0 }, list.items);
std.ArrayList: add replaceRangeAssumeCapacity method
2023-12-14 16:03:36 -08:00
}
add replaceRange() function to ArrayList generalizes functionality of ArrayList.insertSlice() to overwrite a range of elements in the list and to grow or shrink the list as needed to accommodate size difference of the replacing slice and the range of existing elements.
2020-06-02 11:12:26 -05:00
}
tests: re: 79db394; ref: ziglang/zig#1832
2018-12-20 22:49:09 +09:00
const Item = struct {
integer: i32,
sub_items: ArrayList(Item),
};
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const ItemUnmanaged = struct {
integer: i32,
sub_items: ArrayListUnmanaged(ItemUnmanaged),
};
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "ArrayList(T) of struct T" {
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
const a = std.testing.allocator;
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var root = Item{ .integer = 1, .sub_items = .init(a) };
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer root.sub_items.deinit();
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
try root.sub_items.append(Item{ .integer = 42, .sub_items = .init(a) });
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(root.sub_items.items[0].integer == 42);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var root = ItemUnmanaged{ .integer = 1, .sub_items = .empty };
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
defer root.sub_items.deinit(a);
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
try root.sub_items.append(a, ItemUnmanaged{ .integer = 42, .sub_items = .empty });
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(root.sub_items.items[0].integer == 42);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
tests: re: 79db394; ref: ziglang/zig#1832
2018-12-20 22:49:09 +09:00
}
std: add std.ArrayList(u8).outStream()
2020-03-01 19:13:26 +11:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "ArrayList(u8) implements writer" {
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
const a = testing.allocator;
{
var buffer = ArrayList(u8).init(a);
defer buffer.deinit();
const x: i32 = 42;
const y: i32 = 1234;
try buffer.writer().print("x: {}\ny: {}\n", .{ x, y });
std: add std.ArrayList(u8).outStream()
2020-03-01 19:13:26 +11:00
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.items);
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
}
{
var list = ArrayListAligned(u8, 2).init(a);
defer list.deinit();
std: add std.ArrayList(u8).outStream()
2020-03-01 19:13:26 +11:00
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
const writer = list.writer();
try writer.writeAll("a");
try writer.writeAll("bc");
try writer.writeAll("d");
try writer.writeAll("efg");
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqualSlices(u8, list.items, "abcdefg");
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
}
std: add std.ArrayList(u8).outStream()
2020-03-01 19:13:26 +11:00
}
new ArrayList API: fix ArrayList.shrink
2020-04-01 21:05:46 +02:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "ArrayListUnmanaged(u8) implements writer" {
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
const a = testing.allocator;
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var buffer: ArrayListUnmanaged(u8) = .empty;
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
defer buffer.deinit(a);
const x: i32 = 42;
const y: i32 = 1234;
try buffer.writer(a).print("x: {}\ny: {}\n", .{ x, y });
try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", buffer.items);
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListAlignedUnmanaged(u8, 2) = .empty;
std.ArrayListUnmanaged: implement writer()
2021-10-28 13:21:17 -07:00
defer list.deinit(a);
const writer = list.writer(a);
try writer.writeAll("a");
try writer.writeAll("bc");
try writer.writeAll("d");
try writer.writeAll("efg");
try testing.expectEqualSlices(u8, list.items, "abcdefg");
}
}
std.ArrayList: fix shrinkAndFree Fixes a regression introduced in e35f297aeb993ec956ae80379ddf7f86069e109b. Now there is test coverage for ArrayList.shrinkAndFree in the case when resizing fails.
2022-11-30 15:42:59 -07:00
test "shrink still sets length when resizing is disabled" {
std: enable FailingAllocator to fail on resize Now that allocator.resize() is allowed to fail, programs may wish to test code paths that handle resize() failure. The simplest way to do this now is to replace the vtable of the testing allocator with one that uses Allocator.noResize for the 'resize' function pointer. An alternative way to support this testing capability is to augment the FailingAllocator (which is already useful for testing allocation failure scenarios) to intentionally fail on calls to resize(). To do this, add a 'resize_fail_index' parameter to the FailingAllocator that causes resize() to fail after the given number of calls.
2023-08-28 20:25:05 -05:00
var failing_allocator = testing.FailingAllocator.init(testing.allocator, .{ .resize_fail_index = 0 });
const a = failing_allocator.allocator();
new ArrayList API: fix ArrayList.shrink
2020-04-01 21:05:46 +02:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
{
var list = ArrayList(i32).init(a);
std.ArrayList: fix shrinkAndFree Fixes a regression introduced in e35f297aeb993ec956ae80379ddf7f86069e109b. Now there is test coverage for ArrayList.shrinkAndFree in the case when resizing fails.
2022-11-30 15:42:59 -07:00
defer list.deinit();
new ArrayList API: fix ArrayList.shrink
2020-04-01 21:05:46 +02:00
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.append(1);
try list.append(2);
try list.append(3);
new ArrayList API: fix ArrayList.shrink
2020-04-01 21:05:46 +02:00
std: Rename ArrayList shrink => shrinkAndFree
2020-12-29 16:22:22 +11:00
list.shrinkAndFree(1);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 1);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(i32) = .empty;
std.ArrayList: fix shrinkAndFree Fixes a regression introduced in e35f297aeb993ec956ae80379ddf7f86069e109b. Now there is test coverage for ArrayList.shrinkAndFree in the case when resizing fails.
2022-11-30 15:42:59 -07:00
defer list.deinit(a);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
try list.append(a, 1);
try list.append(a, 2);
try list.append(a, 3);
std: Rename ArrayList shrink => shrinkAndFree
2020-12-29 16:22:22 +11:00
list.shrinkAndFree(a, 1);
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expect(list.items.len == 1);
Fix std.ArrayListUnmanaged + improve test coverage
2020-09-29 19:49:13 +02:00
}
new ArrayList API: fix ArrayList.shrink
2020-04-01 21:05:46 +02:00
}
ArrayList(u8) support writer interface
2020-06-13 11:35:18 -06:00
std.ArrayList: fix shrinkAndFree Fixes a regression introduced in e35f297aeb993ec956ae80379ddf7f86069e109b. Now there is test coverage for ArrayList.shrinkAndFree in the case when resizing fails.
2022-11-30 15:42:59 -07:00
test "shrinkAndFree with a copy" {
std: enable FailingAllocator to fail on resize Now that allocator.resize() is allowed to fail, programs may wish to test code paths that handle resize() failure. The simplest way to do this now is to replace the vtable of the testing allocator with one that uses Allocator.noResize for the 'resize' function pointer. An alternative way to support this testing capability is to augment the FailingAllocator (which is already useful for testing allocation failure scenarios) to intentionally fail on calls to resize(). To do this, add a 'resize_fail_index' parameter to the FailingAllocator that causes resize() to fail after the given number of calls.
2023-08-28 20:25:05 -05:00
var failing_allocator = testing.FailingAllocator.init(testing.allocator, .{ .resize_fail_index = 0 });
const a = failing_allocator.allocator();
std.ArrayList: fix shrinkAndFree Fixes a regression introduced in e35f297aeb993ec956ae80379ddf7f86069e109b. Now there is test coverage for ArrayList.shrinkAndFree in the case when resizing fails.
2022-11-30 15:42:59 -07:00
var list = ArrayList(i32).init(a);
defer list.deinit();
try list.appendNTimes(3, 16);
list.shrinkAndFree(4);
try testing.expect(mem.eql(i32, list.items, &.{ 3, 3, 3, 3 }));
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "addManyAsArray" {
std: add new array list functions
2020-07-06 06:09:47 +00:00
const a = std.testing.allocator;
{
var list = ArrayList(u8).init(a);
defer list.deinit();
(try list.addManyAsArray(4)).* = "aoeu".*;
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
try list.ensureTotalCapacity(8);
std: add new array list functions
2020-07-06 06:09:47 +00:00
list.addManyAsArrayAssumeCapacity(4).* = "asdf".*;
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqualSlices(u8, list.items, "aoeuasdf");
std: add new array list functions
2020-07-06 06:09:47 +00:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(u8) = .empty;
std: add new array list functions
2020-07-06 06:09:47 +00:00
defer list.deinit(a);
(try list.addManyAsArray(a, 4)).* = "aoeu".*;
std: deprecate ensureCapacity, add two other capacity functions I've run into this footgun enough times, nearly every time I want `ensureUnusedCapacity`, not `ensureCapacity`. This commit deprecates `ensureCapacity` in favor of `ensureTotalCapacity` and introduces `ensureUnusedCapacity`.
2021-04-16 17:56:30 -07:00
try list.ensureTotalCapacity(a, 8);
std: add new array list functions
2020-07-06 06:09:47 +00:00
list.addManyAsArrayAssumeCapacity(4).* = "asdf".*;
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqualSlices(u8, list.items, "aoeuasdf");
std: add new array list functions
2020-07-06 06:09:47 +00:00
}
}
std: clenup, fixes, fmt
2020-12-23 18:32:39 +02:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "growing memory preserves contents" {
Improve (Unmanaged)ArrayList.insert (Unmanaged)ArrayList.insert has the same inefficiency as the old insertSlice. With the new addManyAt, the solution is trivial. Also improves the test "growing memory preserves contents". In the previous implementation, if any changes were made to the ArrayList memory growth policy (function growMemory), the list could end up with enough capacity to not trigger a memory growth, defeating the purpose of the test. The new implementation more robustly triggers a memory growth.
2023-09-30 14:43:08 -03:00
// Shrink the list after every insertion to ensure that a memory growth
// will be triggered in the next operation.
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
const a = std.testing.allocator;
{
var list = ArrayList(u8).init(a);
defer list.deinit();
(try list.addManyAsArray(4)).* = "abcd".*;
Improve (Unmanaged)ArrayList.insert (Unmanaged)ArrayList.insert has the same inefficiency as the old insertSlice. With the new addManyAt, the solution is trivial. Also improves the test "growing memory preserves contents". In the previous implementation, if any changes were made to the ArrayList memory growth policy (function growMemory), the list could end up with enough capacity to not trigger a memory growth, defeating the purpose of the test. The new implementation more robustly triggers a memory growth.
2023-09-30 14:43:08 -03:00
list.shrinkAndFree(4);
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
try list.appendSlice("efgh");
try testing.expectEqualSlices(u8, list.items, "abcdefgh");
Improve (Unmanaged)ArrayList.insert (Unmanaged)ArrayList.insert has the same inefficiency as the old insertSlice. With the new addManyAt, the solution is trivial. Also improves the test "growing memory preserves contents". In the previous implementation, if any changes were made to the ArrayList memory growth policy (function growMemory), the list could end up with enough capacity to not trigger a memory growth, defeating the purpose of the test. The new implementation more robustly triggers a memory growth.
2023-09-30 14:43:08 -03:00
list.shrinkAndFree(8);
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
try list.insertSlice(4, "ijkl");
try testing.expectEqualSlices(u8, list.items, "abcdijklefgh");
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(u8) = .empty;
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
defer list.deinit(a);
(try list.addManyAsArray(a, 4)).* = "abcd".*;
Improve (Unmanaged)ArrayList.insert (Unmanaged)ArrayList.insert has the same inefficiency as the old insertSlice. With the new addManyAt, the solution is trivial. Also improves the test "growing memory preserves contents". In the previous implementation, if any changes were made to the ArrayList memory growth policy (function growMemory), the list could end up with enough capacity to not trigger a memory growth, defeating the purpose of the test. The new implementation more robustly triggers a memory growth.
2023-09-30 14:43:08 -03:00
list.shrinkAndFree(a, 4);
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
try list.appendSlice(a, "efgh");
try testing.expectEqualSlices(u8, list.items, "abcdefgh");
Improve (Unmanaged)ArrayList.insert (Unmanaged)ArrayList.insert has the same inefficiency as the old insertSlice. With the new addManyAt, the solution is trivial. Also improves the test "growing memory preserves contents". In the previous implementation, if any changes were made to the ArrayList memory growth policy (function growMemory), the list could end up with enough capacity to not trigger a memory growth, defeating the purpose of the test. The new implementation more robustly triggers a memory growth.
2023-09-30 14:43:08 -03:00
list.shrinkAndFree(a, 8);
std.ArrayList: insertSlice avoids extra memcpy Includes a more robust implementation of replaceRange, which updates the ArrayListUnmanaged if state changes in the managed part of the code before returning an error. Co-authored-by: Andrew Kelley <andrew@ziglang.org>
2023-09-27 21:20:34 -03:00
try list.insertSlice(a, 4, "ijkl");
try testing.expectEqualSlices(u8, list.items, "abcdijklefgh");
}
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "fromOwnedSlice" {
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
const a = testing.allocator;
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
{
var orig_list = ArrayList(u8).init(a);
defer orig_list.deinit();
try orig_list.appendSlice("foobar");
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
const slice = try orig_list.toOwnedSlice();
var list = ArrayList(u8).fromOwnedSlice(a, slice);
defer list.deinit();
try testing.expectEqualStrings(list.items, "foobar");
}
{
var list = ArrayList(u8).init(a);
defer list.deinit();
try list.appendSlice("foobar");
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
const slice = try list.toOwnedSlice();
var unmanaged = ArrayListUnmanaged(u8).fromOwnedSlice(slice);
defer unmanaged.deinit(a);
try testing.expectEqualStrings(unmanaged.items, "foobar");
}
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "fromOwnedSliceSentinel" {
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
const a = testing.allocator;
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
{
var orig_list = ArrayList(u8).init(a);
defer orig_list.deinit();
try orig_list.appendSlice("foobar");
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
const sentinel_slice = try orig_list.toOwnedSliceSentinel(0);
var list = ArrayList(u8).fromOwnedSliceSentinel(a, 0, sentinel_slice);
defer list.deinit();
try testing.expectEqualStrings(list.items, "foobar");
}
{
var list = ArrayList(u8).init(a);
defer list.deinit();
try list.appendSlice("foobar");
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
const sentinel_slice = try list.toOwnedSliceSentinel(0);
var unmanaged = ArrayListUnmanaged(u8).fromOwnedSliceSentinel(0, sentinel_slice);
defer unmanaged.deinit(a);
try testing.expectEqualStrings(unmanaged.items, "foobar");
}
Add fromOwnedSliceSentinel to ArrayList ArrayList and ArrayListUnmanaged, add fromOwnedSlice to ArrayListUnmanaged
2023-01-13 20:20:55 -08:00
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "toOwnedSliceSentinel" {
std: clenup, fixes, fmt
2020-12-23 18:32:39 +02:00
const a = testing.allocator;
{
var list = ArrayList(u8).init(a);
defer list.deinit();
try list.appendSlice("foobar");
const result = try list.toOwnedSliceSentinel(0);
defer a.free(result);
std lib API deprecations for the upcoming 0.9.0 release See #3811
2021-11-30 00:13:07 -07:00
try testing.expectEqualStrings(result, mem.sliceTo(result.ptr, 0));
std: clenup, fixes, fmt
2020-12-23 18:32:39 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: ArrayListUnmanaged(u8) = .empty;
std: clenup, fixes, fmt
2020-12-23 18:32:39 +02:00
defer list.deinit(a);
try list.appendSlice(a, "foobar");
const result = try list.toOwnedSliceSentinel(a, 0);
defer a.free(result);
std lib API deprecations for the upcoming 0.9.0 release See #3811
2021-11-30 00:13:07 -07:00
try testing.expectEqualStrings(result, mem.sliceTo(result.ptr, 0));
std: clenup, fixes, fmt
2020-12-23 18:32:39 +02:00
}
}
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "accepts unaligned slices" {
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
const a = testing.allocator;
{
var list = std.ArrayListAligned(u8, 8).init(a);
defer list.deinit();
try list.appendSlice(&.{ 0, 1, 2, 3 });
try list.insertSlice(2, &.{ 4, 5, 6, 7 });
try list.replaceRange(1, 3, &.{ 8, 9 });
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 });
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
}
{
Replace deprecated default initializations with decl literals
2024-09-02 22:32:21 +01:00
var list: std.ArrayListAlignedUnmanaged(u8, 8) = .empty;
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
defer list.deinit(a);
try list.appendSlice(a, &.{ 0, 1, 2, 3 });
try list.insertSlice(a, 2, &.{ 4, 5, 6, 7 });
try list.replaceRange(a, 1, 3, &.{ 8, 9 });
std: update usage of std.testing
2021-05-04 20:47:26 +03:00
try testing.expectEqualSlices(u8, list.items, &.{ 0, 8, 9, 6, 7, 2, 3 });
std: Accept unaligned slice in several ArrayListAligned ops Do not impose the internal alignment requirements to the user-supplied parameters. Closes #8647
2021-05-04 09:30:06 +02:00
}
}
std/ArrayList: Allow `ArrayList(u0)` to be created Enable creating ArrayList with zero-sized types. This type still tracks length, but does not allocate additional memory.
2021-04-23 14:24:58 -04:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "ArrayList(u0)" {
std/ArrayList: Allow `ArrayList(u0)` to be created Enable creating ArrayList with zero-sized types. This type still tracks length, but does not allocate additional memory.
2021-04-23 14:24:58 -04:00
// An ArrayList on zero-sized types should not need to allocate
std: enable FailingAllocator to fail on resize Now that allocator.resize() is allowed to fail, programs may wish to test code paths that handle resize() failure. The simplest way to do this now is to replace the vtable of the testing allocator with one that uses Allocator.noResize for the 'resize' function pointer. An alternative way to support this testing capability is to augment the FailingAllocator (which is already useful for testing allocation failure scenarios) to intentionally fail on calls to resize(). To do this, add a 'resize_fail_index' parameter to the FailingAllocator that causes resize() to fail after the given number of calls.
2023-08-28 20:25:05 -05:00
const a = testing.failing_allocator;
std/ArrayList: Allow `ArrayList(u0)` to be created Enable creating ArrayList with zero-sized types. This type still tracks length, but does not allocate additional memory.
2021-04-23 14:24:58 -04:00
var list = ArrayList(u0).init(a);
defer list.deinit();
try list.append(0);
try list.append(0);
try list.append(0);
try testing.expectEqual(list.items.len, 3);
var count: usize = 0;
for (list.items) |x| {
try testing.expectEqual(x, 0);
count += 1;
}
try testing.expectEqual(count, 3);
}
add tests for fixed stage1 bugs Closes #1957 Closes #1994 Closes #2140 Closes #2746 Closes #2802 Closes #2855 Closes #2895 Closes #2981 Closes #3054 Closes #3158 Closes #3234 Closes #3259 Closes #3371 Closes #3376 Closes #3387 Closes #3529 Closes #3653 Closes #3750 Closes #3778 Closes #3882 Closes #3915 Closes #3929 Closes #3961 Closes #3988 Closes #4123 Closes #7448
2022-12-28 15:10:12 +02:00
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
test "ArrayList(?u32).pop()" {
add tests for fixed stage1 bugs Closes #1957 Closes #1994 Closes #2140 Closes #2746 Closes #2802 Closes #2855 Closes #2895 Closes #2981 Closes #3054 Closes #3158 Closes #3234 Closes #3259 Closes #3371 Closes #3376 Closes #3387 Closes #3529 Closes #3653 Closes #3750 Closes #3778 Closes #3882 Closes #3915 Closes #3929 Closes #3961 Closes #3988 Closes #4123 Closes #7448
2022-12-28 15:10:12 +02:00
const a = testing.allocator;
var list = ArrayList(?u32).init(a);
defer list.deinit();
try list.append(null);
try list.append(1);
try list.append(2);
try testing.expectEqual(list.items.len, 3);
std.ArrayList: popOrNull() -> pop() [v2] (#22720)
2025-02-09 20:21:31 -08:00
try testing.expect(list.pop().? == @as(u32, 2));
try testing.expect(list.pop().? == @as(u32, 1));
try testing.expect(list.pop().? == null);
try testing.expect(list.pop() == null);
add tests for fixed stage1 bugs Closes #1957 Closes #1994 Closes #2140 Closes #2746 Closes #2802 Closes #2855 Closes #2895 Closes #2981 Closes #3054 Closes #3158 Closes #3234 Closes #3259 Closes #3371 Closes #3376 Closes #3387 Closes #3529 Closes #3653 Closes #3750 Closes #3778 Closes #3882 Closes #3915 Closes #3929 Closes #3961 Closes #3988 Closes #4123 Closes #7448
2022-12-28 15:10:12 +02:00
}
Allow const for ArrayList.getLast, fix #14522
2023-02-04 03:01:47 +01:00
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "ArrayList(u32).getLast()" {
Allow const for ArrayList.getLast, fix #14522
2023-02-04 03:01:47 +01:00
const a = testing.allocator;
var list = ArrayList(u32).init(a);
defer list.deinit();
try list.append(2);
const const_list = list;
try testing.expectEqual(const_list.getLast(), 2);
}
Remove redundant test name prefixes now that test names are fully qualified Follow up to #19079, which made test names fully qualified. This fixes tests that now-redundant information in their test names. For example here's a fully qualified test name before the changes in this commit: "priority_queue.test.std.PriorityQueue: shrinkAndFree" and the same test's name after the changes in this commit: "priority_queue.test.shrinkAndFree"
2024-02-25 23:31:53 -08:00
test "ArrayList(u32).getLastOrNull()" {
Allow const for ArrayList.getLast, fix #14522
2023-02-04 03:01:47 +01:00
const a = testing.allocator;
var list = ArrayList(u32).init(a);
defer list.deinit();
try testing.expectEqual(list.getLastOrNull(), null);
try list.append(2);
const const_list = list;
try testing.expectEqual(const_list.getLastOrNull().?, 2);
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
test "return OutOfMemory when capacity would exceed maximum usize integer value" {
const a = testing.allocator;
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
const new_item: u32 = 42;
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
const items = &.{ 42, 43 };
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
{
var list: ArrayListUnmanaged(u32) = .{
.items = undefined,
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
.capacity = math.maxInt(usize) - 1,
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
};
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
list.items.len = math.maxInt(usize) - 1;
try testing.expectError(error.OutOfMemory, list.appendSlice(a, items));
try testing.expectError(error.OutOfMemory, list.appendNTimes(a, new_item, 2));
try testing.expectError(error.OutOfMemory, list.appendUnalignedSlice(a, &.{ new_item, new_item }));
try testing.expectError(error.OutOfMemory, list.addManyAt(a, 0, 2));
try testing.expectError(error.OutOfMemory, list.addManyAsArray(a, 2));
try testing.expectError(error.OutOfMemory, list.addManyAsSlice(a, 2));
try testing.expectError(error.OutOfMemory, list.insertSlice(a, 0, items));
try testing.expectError(error.OutOfMemory, list.ensureUnusedCapacity(a, 2));
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
}
{
var list: ArrayList(u32) = .{
.items = undefined,
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
.capacity = math.maxInt(usize) - 1,
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
.allocator = a,
};
std.ArrayList: remove `+ 1` overflow checks
2024-01-19 00:25:43 +01:00
list.items.len = math.maxInt(usize) - 1;
try testing.expectError(error.OutOfMemory, list.appendSlice(items));
try testing.expectError(error.OutOfMemory, list.appendNTimes(new_item, 2));
try testing.expectError(error.OutOfMemory, list.appendUnalignedSlice(&.{ new_item, new_item }));
try testing.expectError(error.OutOfMemory, list.addManyAt(0, 2));
try testing.expectError(error.OutOfMemory, list.addManyAsArray(2));
try testing.expectError(error.OutOfMemory, list.addManyAsSlice(2));
try testing.expectError(error.OutOfMemory, list.insertSlice(0, items));
try testing.expectError(error.OutOfMemory, list.ensureUnusedCapacity(2));
std.ArrayList: pedantic rewordings of documentation and unit tests
2024-01-15 23:43:27 -07:00
}
std.array_list: Document and reduce illegal behavior in ArrayLists
2024-01-07 05:09:54 +01:00
}
std.ArrayList.unusedCapacitySlice: Return unaligned slice (#20490)
2024-07-14 00:56:29 +00:00
test "ArrayListAligned with non-native alignment compiles unusedCapabitySlice" {
var list = ArrayListAligned(u8, 4).init(testing.allocator);
defer list.deinit();
try list.appendNTimes(1, 4);
_ = list.unusedCapacitySlice();
}
Reference in New Issue Copy Permalink