@zigc/lib 0.16.0-dev.3128 → 0.16.0-dev.3132

package/compiler/aro/backend/Ir/x86/Renderer.zig

@@ -21,17 +21,17 @@ const RegisterManager = zig.RegisterManager(Renderer, Register, Ir.Ref, abi.allo
 const RegisterBitSet = RegisterManager.RegisterBitSet;
 const RegisterClass = struct {
     const gp: RegisterBitSet = blk: {
-        var set = RegisterBitSet.initEmpty();
+        var set = RegisterBitSet.empty;
         for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .general_purpose) set.set(index);
         break :blk set;
     };
     const x87: RegisterBitSet = blk: {
-        var set = RegisterBitSet.initEmpty();
+        var set = RegisterBitSet.empty;
         for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .x87) set.set(index);
         break :blk set;
     };
     const sse: RegisterBitSet = blk: {
-        var set = RegisterBitSet.initEmpty();
+        var set = RegisterBitSet.empty;
         for (abi.allocatable_regs, 0..) |reg, index| if (reg.class() == .sse) set.set(index);
         break :blk set;
     };

package/compiler/resinator/compile.zig

@@ -2746,7 +2746,7 @@ pub const Compiler = struct {
         // 1. Any permutation that does not have PRELOAD in it just uses the
         //    default flags.
         const initial_flags = flags.*;
-        var flags_set = std.enums.EnumSet(rc.CommonResourceAttributes).initEmpty();
+        var flags_set = std.enums.EnumSet(rc.CommonResourceAttributes).empty;
         for (tokens) |token| {
             const attribute = rc.CommonResourceAttributes.map.get(token.slice(source)).?;
             flags_set.insert(attribute);
@@ -2769,7 +2769,7 @@ pub const Compiler = struct {
         // 3. If none of DISCARDABLE, SHARED, or PURE is specified, then PRELOAD
         //    implies `flags &= ~SHARED` and LOADONCALL implies `flags |= SHARED`
         const shared_set = comptime blk: {
-            var set = std.enums.EnumSet(rc.CommonResourceAttributes).initEmpty();
+            var set = std.enums.EnumSet(rc.CommonResourceAttributes).empty;
             set.insert(.discardable);
             set.insert(.shared);
             set.insert(.pure);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.16.0-dev.3128",
+  "version": "0.16.0-dev.3132",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Io/File/Reader.zig

@@ -309,7 +309,9 @@ fn discard(io_reader: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
                 return 0;
             };
             const logical_pos = logicalPos(r);
-            const delta = @min(@intFromEnum(limit), size - logical_pos);
+            const bytes_remaining = size - logical_pos;
+            if (bytes_remaining == 0) return error.EndOfStream;
+            const delta = @min(@intFromEnum(limit), bytes_remaining);
             setLogicalPos(r, logical_pos + delta);
             return delta;
         },

package/std/Io/Kqueue.zig

@@ -186,7 +186,7 @@ pub fn init(k: *Kqueue, gpa: Allocator, options: InitOptions) !void {
         .awaiter = null,
         .queue_next = null,
         .cancel_thread = null,
-        .awaiting_completions = .initEmpty(),
+        .awaiting_completions = .empty,
     };
     const main_thread = &k.threads.allocated[0];
     Thread.self = main_thread;
@@ -713,7 +713,7 @@ fn concurrent(
         .awaiter = null,
         .queue_next = null,
         .cancel_thread = null,
-        .awaiting_completions = .initEmpty(),
+        .awaiting_completions = .empty,
     };
     closure.* = .{
         .kqueue = k,

package/std/Io.zig

@@ -500,8 +500,8 @@ pub const Batch = struct {
     /// Returns the index that will be returned by `next` after the operation completes.
     /// Asserts that no more than `storage.len` operations are active at a time.
     pub fn add(batch: *Batch, operation: Operation) u32 {
-        const index = batch.unused.next;
-        batch.addAt(index.toIndex(), operation);
+        const index = batch.unused.head.toIndex();
+        batch.addAt(index, operation);
         return index;
     }
 

package/std/bit_set.zig

@@ -68,16 +68,24 @@ pub fn IntegerBitSet(comptime size: u16) type {
         /// The bit mask, as a single integer
         mask: MaskInt,
 
+        /// Deprecated: use `.empty`.
         /// Creates a bit set with no elements present.
         pub fn initEmpty() Self {
             return .{ .mask = 0 };
         }
 
+        /// Deprecated: use `.full`.
         /// Creates a bit set with all elements present.
         pub fn initFull() Self {
             return .{ .mask = ~@as(MaskInt, 0) };
         }
 
+        /// A bit set with no elements present.
+        pub const empty: Self = .{ .mask = 0 };
+
+        /// A bit set with all elements present.
+        pub const full: Self = .{ .mask = ~@as(MaskInt, 0) };
+
         /// Returns the number of bits in this bit set
         pub inline fn capacity(self: Self) usize {
             _ = self;
@@ -387,11 +395,13 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
         /// Padding bits at the end are undefined.
         masks: [num_masks]MaskInt,
 
+        /// Deprecated: use `.empty`.
         /// Creates a bit set with no elements present.
         pub fn initEmpty() Self {
             return .{ .masks = [_]MaskInt{0} ** num_masks };
         }
 
+        /// Deprecated: use `.full`.
         /// Creates a bit set with all elements present.
         pub fn initFull() Self {
             if (num_masks == 0) {
@@ -401,6 +411,12 @@ pub fn ArrayBitSet(comptime MaskIntType: type, comptime size: usize) type {
             }
         }
 
+        /// A bit set with no elements present.
+        pub const empty: Self = .{ .masks = @splat(0) };
+
+        /// A bit set with all elements present.
+        pub const full: Self = .{ .masks = if (num_masks == 0) .{} else ([_]MaskInt{~@as(MaskInt, 0)} ** (num_masks - 1) ++ [_]MaskInt{last_item_mask}) };
+
         /// Returns the number of bits in this bit set
         pub inline fn capacity(self: Self) usize {
             _ = self;
@@ -1633,17 +1649,17 @@ fn fillOdd(set: anytype, len: usize) void {
 }
 
 fn testPureBitSet(comptime Set: type) !void {
-    const empty = Set.initEmpty();
-    const full = Set.initFull();
+    const empty = Set.empty;
+    const full = Set.full;
 
     const even = even: {
-        var bit_set = Set.initEmpty();
+        var bit_set = Set.empty;
         fillEven(&bit_set, Set.bit_length);
         break :even bit_set;
     };
 
     const odd = odd: {
-        var bit_set = Set.initEmpty();
+        var bit_set = Set.empty;
         fillOdd(&bit_set, Set.bit_length);
         break :odd bit_set;
     };
@@ -1686,8 +1702,8 @@ fn testPureBitSet(comptime Set: type) !void {
 }
 
 fn testStaticBitSet(comptime Set: type) !void {
-    var a = Set.initEmpty();
-    var b = Set.initFull();
+    var a = Set.empty;
+    var b = Set.full;
     try testing.expectEqual(@as(usize, 0), a.count());
     try testing.expectEqual(@as(usize, Set.bit_length), b.count());
 

package/std/crypto/codecs/base64_hex_ct.zig

@@ -93,7 +93,7 @@ pub const hex = struct {
     /// The decoder will skip any characters that are in the ignore list.
     /// The ignore list must not contain any valid hexadecimal characters.
     pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
-        var ignored_chars = StaticBitSet(256).initEmpty();
+        var ignored_chars = StaticBitSet(256).empty;
         for (ignore_chars) |c| {
             switch (c) {
                 '0'...'9', 'a'...'f', 'A'...'F' => return error.InvalidCharacter,
@@ -269,7 +269,7 @@ pub const base64 = struct {
 
     /// Creates a new decoder that ignores certain characters.
     pub fn decoderWithIgnore(ignore_chars: []const u8) error{InvalidCharacter}!DecoderWithIgnore {
-        var ignored_chars = StaticBitSet(256).initEmpty();
+        var ignored_chars = StaticBitSet(256).empty;
         for (ignore_chars) |c| {
             switch (c) {
                 'A'...'Z', 'a'...'z', '0'...'9' => return error.InvalidCharacter,

package/std/enums.zig

@@ -252,7 +252,7 @@ pub fn EnumSet(comptime E: type) type {
         /// The maximum number of items in this set.
         pub const len = Indexer.count;
 
-        bits: BitSet = BitSet.initEmpty(),
+        bits: BitSet = .empty,
 
         /// Initializes the set using a struct of bools
         pub fn init(init_values: EnumFieldStruct(E, bool, false)) Self {
@@ -278,19 +278,15 @@ pub fn EnumSet(comptime E: type) type {
             return result;
         }
 
-        /// Returns a set containing no keys.
-        pub fn initEmpty() Self {
-            return .{ .bits = BitSet.initEmpty() };
-        }
+        /// A set containing no keys.
+        pub const empty: Self = .{ .bits = .empty };
 
-        /// Returns a set containing all possible keys.
-        pub fn initFull() Self {
-            return .{ .bits = BitSet.initFull() };
-        }
+        /// A set containing all possible keys.
+        pub const full: Self = .{ .bits = .full };
 
         /// Returns a set containing multiple keys.
         pub fn initMany(keys: []const Key) Self {
-            var set = initEmpty();
+            var set: Self = .empty;
             for (keys) |key| set.insert(key);
             return set;
         }
@@ -440,7 +436,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         const BitSet = std.StaticBitSet(Indexer.count);
 
         /// Bits determining whether items are in the map
-        bits: BitSet = BitSet.initEmpty(),
+        bits: BitSet = .empty,
         /// Values of items in the map.  If the associated
         /// bit is zero, the value is undefined.
         values: [Indexer.count]Value = undefined,
@@ -475,7 +471,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         /// Consider using EnumArray instead if the map will remain full.
         pub fn initFull(value: Value) Self {
             var result: Self = .{
-                .bits = Self.BitSet.initFull(),
+                .bits = .full,
                 .values = undefined,
             };
             @memset(&result.values, value);
@@ -493,7 +489,7 @@ pub fn EnumMap(comptime E: type, comptime V: type) type {
         pub fn initFullWithDefault(comptime default: ?Value, init_values: EnumFieldStruct(E, Value, default)) Self {
             @setEvalBranchQuota(2 * @typeInfo(E).@"enum".fields.len);
             var result: Self = .{
-                .bits = Self.BitSet.initFull(),
+                .bits = .full,
                 .values = undefined,
             };
             inline for (0..Self.len) |i| {
@@ -687,16 +683,14 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
             return self;
         }
 
-        /// Initializes the multiset with a count of zero.
-        pub fn initEmpty() Self {
-            return initWithCount(0);
-        }
+        /// A multiset with a count of zero.
+        pub const empty: Self = .initWithCount(0);
 
         /// Initializes the multiset with all keys at the
         /// same count.
         pub fn initWithCount(comptime c: CountSize) Self {
             return .{
-                .counts = EnumArray(E, CountSize).initDefault(c, .{}),
+                .counts = .initDefault(c, .{}),
             };
         }
 
@@ -855,7 +849,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type {
 test EnumMultiset {
     const Ball = enum { red, green, blue };
 
-    const empty = EnumMultiset(Ball).initEmpty();
+    const empty = EnumMultiset(Ball).empty;
     const r0_g1_b2 = EnumMultiset(Ball).init(.{
         .red = 0,
         .green = 1,
@@ -1162,8 +1156,8 @@ pub fn EnumArray(comptime E: type, comptime V: type) type {
 test "pure EnumSet fns" {
     const Suit = enum { spades, hearts, clubs, diamonds };
 
-    const empty = EnumSet(Suit).initEmpty();
-    const full = EnumSet(Suit).initFull();
+    const empty = EnumSet(Suit).empty;
+    const full = EnumSet(Suit).full;
     const black = EnumSet(Suit).initMany(&[_]Suit{ .spades, .clubs });
     const red = EnumSet(Suit).initMany(&[_]Suit{ .hearts, .diamonds });
 
@@ -1224,8 +1218,8 @@ test "pure EnumSet fns" {
 
 test "EnumSet empty" {
     const E = enum {};
-    const empty = EnumSet(E).initEmpty();
-    const full = EnumSet(E).initFull();
+    const empty = EnumSet(E).empty;
+    const full = EnumSet(E).full;
 
     try std.testing.expect(empty.eql(full));
     try std.testing.expect(empty.complement().eql(full));
@@ -1236,13 +1230,13 @@ test "EnumSet empty" {
 test "EnumSet const iterator" {
     const Direction = enum { up, down, left, right };
     const diag_move = init: {
-        var move = EnumSet(Direction).initEmpty();
+        var move = EnumSet(Direction).empty;
         move.insert(.right);
         move.insert(.up);
         break :init move;
     };
 
-    var result = EnumSet(Direction).initEmpty();
+    var result = EnumSet(Direction).empty;
     var it = diag_move.iterator();
     while (it.next()) |dir| {
         result.insert(dir);

package/std/http/Client.zig

@@ -1133,7 +1133,16 @@ pub const Request = struct {
     pub fn receiveHead(r: *Request, redirect_buffer: []u8) ReceiveHeadError!Response {
         var aux_buf = redirect_buffer;
         while (true) {
-            const head_buffer = try r.reader.receiveHead();
+            // This while loop is for handling redirects, which means the request's
+            // connection may be different than the previous iteration. However, it
+            // is still guaranteed to be non-null with each iteration of this loop.
+            const connection = r.connection.?;
+
+            const head_buffer = r.reader.receiveHead() catch |err| {
+                // Failure here means the connection can no longer be reused.
+                connection.closing = true;
+                return err;
+            };
             const response: Response = .{
                 .request = r,
                 .head = Response.Head.parse(head_buffer) catch return error.HttpHeadersInvalid,
@@ -1147,11 +1156,6 @@ pub const Request = struct {
                 return response; // we're not handling the 100-continue
             }
 
-            // This while loop is for handling redirects, which means the request's
-            // connection may be different than the previous iteration. However, it
-            // is still guaranteed to be non-null with each iteration of this loop.
-            const connection = r.connection.?;
-
             if (r.method == .CONNECT and head.status.class() == .success) {
                 // This connection is no longer doing HTTP.
                 connection.closing = false;