std: existing LinkedList is actually a TailQueue

src-self-hosted/compilation.zig

@@ -160,7 +160,7 @@ pub const Compilation = struct {
     /// it uses an optional pointer so that tombstone removals are possible
     fn_link_set: event.Locked(FnLinkSet),
 
-    pub const FnLinkSet = std.LinkedList(?*Value.Fn);
+    pub const FnLinkSet = std.TailQueue(?*Value.Fn);
 
     windows_subsystem_windows: bool,
     windows_subsystem_console: bool,

src-self-hosted/value.zig

@@ -186,7 +186,7 @@ pub const Value = struct {
         /// Path to the object file that contains this function
         containing_object: Buffer,
 
-        link_set_node: *std.LinkedList(?*Value.Fn).Node,
+        link_set_node: *std.TailQueue(?*Value.Fn).Node,
 
         /// Creates a Fn value with 1 ref
         /// Takes ownership of symbol_name

std/atomic/queue.zig

@@ -14,7 +14,7 @@ pub fn Queue(comptime T: type) type {
         mutex: std.Mutex,
 
         pub const Self = @This();
-        pub const Node = std.LinkedList(T).Node;
+        pub const Node = std.TailQueue(T).Node;
 
         pub fn init() Self {
             return Self{

std/child_process.zig

@@ -13,7 +13,7 @@ const BufMap = std.BufMap;
 const Buffer = std.Buffer;
 const builtin = @import("builtin");
 const Os = builtin.Os;
-const LinkedList = std.LinkedList;
+const TailQueue = std.TailQueue;
 const maxInt = std.math.maxInt;
 
 pub const ChildProcess = struct {
@@ -48,7 +48,7 @@ pub const ChildProcess = struct {
     pub cwd: ?[]const u8,
 
     err_pipe: if (os.windows.is_the_target) void else [2]os.fd_t,
-    llnode: if (os.windows.is_the_target) void else LinkedList(*ChildProcess).Node,
+    llnode: if (os.windows.is_the_target) void else TailQueue(*ChildProcess).Node,
 
     pub const SpawnError = error{OutOfMemory} || os.ExecveError || os.SetIdError ||
         os.ChangeCurDirError || windows.CreateProcessError;
@@ -388,7 +388,7 @@ pub const ChildProcess = struct {
 
         self.pid = pid;
         self.err_pipe = err_pipe;
-        self.llnode = LinkedList(*ChildProcess).Node.init(self);
+        self.llnode = TailQueue(*ChildProcess).Node.init(self);
         self.term = null;
 
         if (self.stdin_behavior == StdIo.Pipe) {

std/event/net.zig

@@ -19,7 +19,7 @@ pub const Server = struct {
     waiting_for_emfile_node: PromiseNode,
     listen_resume_node: event.Loop.ResumeNode,
 
-    const PromiseNode = std.LinkedList(promise).Node;
+    const PromiseNode = std.TailQueue(promise).Node;
 
     pub fn init(loop: *Loop) Server {
         // TODO can't initialize handler coroutine here because we need well defined copy elision

std/heap.zig

@@ -347,10 +347,10 @@ pub const ArenaAllocator = struct {
     pub allocator: Allocator,
 
     child_allocator: *Allocator,
-    buffer_list: std.LinkedList([]u8),
+    buffer_list: std.TailQueue([]u8),
     end_index: usize,
 
-    const BufNode = std.LinkedList([]u8).Node;
+    const BufNode = std.TailQueue([]u8).Node;
 
     pub fn init(child_allocator: *Allocator) ArenaAllocator {
         return ArenaAllocator{
@@ -359,7 +359,7 @@ pub const ArenaAllocator = struct {
                 .shrinkFn = shrink,
             },
             .child_allocator = child_allocator,
-            .buffer_list = std.LinkedList([]u8).init(),
+            .buffer_list = std.TailQueue([]u8).init(),
             .end_index = 0,
         };
     }

std/linked_list.zig

@@ -5,8 +5,13 @@ const testing = std.testing;
 const mem = std.mem;
 const Allocator = mem.Allocator;
 
-/// Generic doubly linked list.
-pub fn LinkedList(comptime T: type) type {
+/// A tail queue is headed by a pair of pointers, one to the head of the
+/// list and the other to the tail of the list. The elements are doubly
+/// linked so that an arbitrary element can be removed without a need to
+/// traverse the list. New elements can be added to the list before or
+/// after an existing element, at the head of the list, or at the end of
+/// the list. A tail queue may be traversed in either direction.
+pub fn TailQueue(comptime T: type) type {
     return struct {
         const Self = @This();
 
@@ -219,9 +224,9 @@ pub fn LinkedList(comptime T: type) type {
     };
 }
 
-test "basic linked list test" {
+test "basic TailQueue test" {
     const allocator = debug.global_allocator;
-    var list = LinkedList(u32).init();
+    var list = TailQueue(u32).init();
 
     var one = try list.createNode(1, allocator);
     var two = try list.createNode(2, allocator);
@@ -271,10 +276,10 @@ test "basic linked list test" {
     testing.expect(list.len == 2);
 }
 
-test "linked list concatenation" {
+test "TailQueue concatenation" {
     const allocator = debug.global_allocator;
-    var list1 = LinkedList(u32).init();
-    var list2 = LinkedList(u32).init();
+    var list1 = TailQueue(u32).init();
+    var list2 = TailQueue(u32).init();
 
     var one = try list1.createNode(1, allocator);
     defer list1.destroyNode(one, allocator);

std/std.zig

@@ -7,7 +7,6 @@ pub const Buffer = @import("buffer.zig").Buffer;
 pub const BufferOutStream = @import("io.zig").BufferOutStream;
 pub const DynLib = @import("dynamic_library.zig").DynLib;
 pub const HashMap = @import("hash_map.zig").HashMap;
-pub const LinkedList = @import("linked_list.zig").LinkedList;
 pub const Mutex = @import("mutex.zig").Mutex;
 pub const PackedIntArrayEndian = @import("packed_int_array.zig").PackedIntArrayEndian;
 pub const PackedIntArray = @import("packed_int_array.zig").PackedIntArray;
@@ -18,6 +17,7 @@ pub const StaticallyInitializedMutex = @import("statically_initialized_mutex.zig
 pub const SegmentedList = @import("segmented_list.zig").SegmentedList;
 pub const SpinLock = @import("spinlock.zig").SpinLock;
 pub const ChildProcess = @import("child_process.zig").ChildProcess;
+pub const TailQueue = @import("linked_list.zig").TailQueue;
 pub const Thread = @import("thread.zig").Thread;
 
 pub const atomic = @import("atomic.zig");