@zigc/lib 0.16.0 → 0.17.0-dev.135

package/std/zig/WindowsSdk.zig

@@ -47,7 +47,7 @@ pub fn find(
         error.InstallationNotFound => null,
         error.PathTooLong => null,
         error.VersionTooLong => null,
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
     };
     errdefer if (windows10sdk) |*w| w.free(gpa);
 
@@ -55,13 +55,13 @@ pub fn find(
         error.InstallationNotFound => null,
         error.PathTooLong => null,
         error.VersionTooLong => null,
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
     };
     errdefer if (windows81sdk) |*w| w.free(gpa);
 
     const msvc_lib_dir: ?[]const u8 = MsvcLibDir.find(gpa, io, &registry, arch, environ_map) catch |err| switch (err) {
         error.MsvcLibDirNotFound => null,
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
     };
     errdefer gpa.free(msvc_lib_dir);
 
@@ -498,7 +498,7 @@ pub const Installation = struct {
                 error.StringNotFound,
                 => return error.InstallationNotFound,
 
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
             };
             defer gpa.free(path_w_maybe_with_trailing_slash);
 
@@ -572,7 +572,7 @@ pub const Installation = struct {
                 error.StringNotFound,
                 => return error.InstallationNotFound,
 
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
             };
             defer gpa.free(path_w_maybe_with_trailing_slash);
 
@@ -593,7 +593,7 @@ pub const Installation = struct {
                 error.StringNotFound,
                 => return error.InstallationNotFound,
 
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
             };
             defer gpa.free(version_without_0);
 
@@ -664,7 +664,7 @@ const MsvcLibDir = struct {
             error.StringNotFound,
             => return error.PathNotFound,
 
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
         };
         defer gpa.free(packages_path);
 
@@ -708,7 +708,7 @@ const MsvcLibDir = struct {
             error.StringNotFound,
             => return error.PathNotFound,
 
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
         };
         defer gpa.free(dll_path);
 
@@ -1042,7 +1042,7 @@ const MsvcLibDir = struct {
             const config_key = root_key.open(config_path) catch continue;
 
             const source_directories_value = config_key.getString(gpa, .{ .name = L("Source Directories") }, .wtf8) catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 else => continue,
             };
 
@@ -1118,7 +1118,7 @@ const MsvcLibDir = struct {
             defer vs7_key.close();
             try_vs7_key: {
                 const path_maybe_with_trailing_slash = vs7_key.getString(gpa, .{ .name = L("14.0") }, .wtf8) catch |err| switch (err) {
-                    error.OutOfMemory => return error.OutOfMemory,
+                    error.OutOfMemory => |e| return e,
                     else => break :try_vs7_key,
                 };
 
@@ -1178,11 +1178,11 @@ const MsvcLibDir = struct {
         environ_map: *const Environ.Map,
     ) error{ OutOfMemory, MsvcLibDirNotFound }![]const u8 {
         const full_path = MsvcLibDir.findViaCOM(gpa, io, registry, arch, environ_map) catch |err1| switch (err1) {
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
             error.PathNotFound => MsvcLibDir.findViaRegistry(gpa, io, arch, environ_map) catch |err2| switch (err2) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 error.PathNotFound => MsvcLibDir.findViaVs7Key(gpa, io, registry, arch, environ_map) catch |err3| switch (err3) {
-                    error.OutOfMemory => return error.OutOfMemory,
+                    error.OutOfMemory => |e| return e,
                     error.PathNotFound => return error.MsvcLibDirNotFound,
                 },
             },

package/std/zig/Zir.zig

@@ -1016,9 +1016,6 @@ pub const Inst = struct {
         /// Implements the `@max` builtin for 2 args.
         /// Uses the `pl_node` union field with payload `Bin`
         max,
-        /// Implements the `@cImport` builtin.
-        /// Uses the `pl_node` union field with payload `Block`.
-        c_import,
 
         /// Allocates stack local memory.
         /// Uses the `un_node` union field. The operand is the type of the allocated object.
@@ -1297,7 +1294,6 @@ pub const Inst = struct {
                 .memset,
                 .memmove,
                 .min,
-                .c_import,
                 .@"resume",
                 .ret_err_value_code,
                 .extended,
@@ -1577,7 +1573,6 @@ pub const Inst = struct {
                 .builtin_call,
                 .max,
                 .min,
-                .c_import,
                 .@"resume",
                 .ret_err_value_code,
                 .@"break",
@@ -1857,7 +1852,6 @@ pub const Inst = struct {
                 .memset = .pl_node,
                 .memmove = .pl_node,
                 .min = .pl_node,
-                .c_import = .pl_node,
 
                 .alloc = .un_node,
                 .alloc_mut = .un_node,
@@ -2018,12 +2012,6 @@ pub const Inst = struct {
         /// `small` is unused.
         round_op_ty,
         /// `operand` is payload index to `UnNode`.
-        c_undef,
-        /// `operand` is payload index to `UnNode`.
-        c_include,
-        /// `operand` is payload index to `BinNode`.
-        c_define,
-        /// `operand` is payload index to `UnNode`.
         wasm_memory_size,
         /// `operand` is payload index to `BinNode`.
         wasm_memory_grow,
@@ -4033,30 +4021,30 @@ pub const DeclContents = struct {
     /// This is a simple optional because ZIR guarantees that a `func`/`func_inferred`/`func_fancy` instruction
     /// can only occur once per `declaration`.
     func_decl: ?Inst.Index,
-    explicit_types: std.ArrayList(Inst.Index),
+    type_decls: std.ArrayList(Inst.Index),
     other: std.ArrayList(Inst.Index),
 
     pub const init: DeclContents = .{
         .func_decl = null,
-        .explicit_types = .empty,
+        .type_decls = .empty,
         .other = .empty,
     };
 
     pub fn clear(contents: *DeclContents) void {
         contents.func_decl = null;
-        contents.explicit_types.clearRetainingCapacity();
+        contents.type_decls.clearRetainingCapacity();
         contents.other.clearRetainingCapacity();
     }
 
     pub fn deinit(contents: *DeclContents, gpa: Allocator) void {
-        contents.explicit_types.deinit(gpa);
+        contents.type_decls.deinit(gpa);
         contents.other.deinit(gpa);
     }
 };
 
 /// Find all tracked ZIR instructions, recursively, within a `declaration` instruction. Does not recurse through
 /// nested declarations; to find all declarations, call this function recursively on the type declarations discovered
-/// in `contents.explicit_types`.
+/// in `contents.type_decls`.
 ///
 /// This populates an `ArrayList` because an iterator would need to allocate memory anyway.
 pub fn findTrackable(zir: Zir, gpa: Allocator, contents: *DeclContents, decl_inst: Zir.Inst.Index) !void {
@@ -4076,15 +4064,49 @@ pub fn findTrackable(zir: Zir, gpa: Allocator, contents: *DeclContents, decl_ins
     if (decl.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
 }
 
-/// Like `findTrackable`, but only considers the `main_struct_inst` instruction. This may return more than
-/// just that instruction because it will also traverse fields.
-pub fn findTrackableRoot(zir: Zir, gpa: Allocator, contents: *DeclContents) !void {
+/// `findTrackable` does not recurse into field expressions in a type. Instead, this function will
+/// scan specifically field expressions in a given type declaration for trackable ZIR instructions.
+pub fn findTrackableFields(
+    zir: *const Zir,
+    gpa: Allocator,
+    contents: *DeclContents,
+    type_decl_inst: Zir.Inst.Index,
+) Allocator.Error!void {
     contents.clear();
 
     var found_defers: std.AutoHashMapUnmanaged(u32, void) = .empty;
     defer found_defers.deinit(gpa);
 
-    try zir.findTrackableInner(gpa, contents, &found_defers, .main_struct_inst);
+    assert(zir.instructions.items(.tag)[@intFromEnum(type_decl_inst)] == .extended);
+    switch (zir.instructions.items(.data)[@intFromEnum(type_decl_inst)].extended.opcode) {
+        .struct_decl => {
+            const struct_decl = zir.getStructDecl(type_decl_inst);
+            var it = struct_decl.iterateFields();
+            while (it.next()) |field| {
+                try zir.findTrackableBody(gpa, contents, &found_defers, field.type_body);
+                if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+                if (field.default_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+            }
+        },
+        .union_decl => {
+            const union_decl = zir.getUnionDecl(type_decl_inst);
+            var it = union_decl.iterateFields();
+            while (it.next()) |field| {
+                if (field.type_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+                if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+                if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+            }
+        },
+        .enum_decl => {
+            const enum_decl = zir.getEnumDecl(type_decl_inst);
+            var it = enum_decl.iterateFields();
+            while (it.next()) |field| {
+                if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, &found_defers, b);
+            }
+        },
+        .opaque_decl => {},
+        else => unreachable,
+    }
 }
 
 fn findTrackableInner(
@@ -4360,9 +4382,6 @@ fn findTrackableInner(
                 .mul_with_overflow,
                 .shl_with_overflow,
                 .round_op,
-                .c_undef,
-                .c_include,
-                .c_define,
                 .wasm_memory_size,
                 .wasm_memory_grow,
                 .prefetch,
@@ -4411,49 +4430,18 @@ fn findTrackableInner(
                     try zir.findTrackableBody(gpa, contents, defers, body);
                 },
 
-                // Reifications and opaque declarations need tracking, but have no bodies.
+                // Reifications need tracking.
                 .reify_enum,
                 .reify_struct,
                 .reify_union,
-                .opaque_decl,
                 => return contents.other.append(gpa, inst),
 
-                // Struct declarations need tracking and have bodies.
-                .struct_decl => {
-                    try contents.explicit_types.append(gpa, inst);
-
-                    const struct_decl = zir.getStructDecl(inst);
-                    var it = struct_decl.iterateFields();
-                    while (it.next()) |field| {
-                        try zir.findTrackableBody(gpa, contents, defers, field.type_body);
-                        if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                        if (field.default_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                    }
-                },
-
-                // Union declarations need tracking and have bodies.
-                .union_decl => {
-                    try contents.explicit_types.append(gpa, inst);
-
-                    const union_decl = zir.getUnionDecl(inst);
-                    var it = union_decl.iterateFields();
-                    while (it.next()) |field| {
-                        if (field.type_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                        if (field.align_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                        if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                    }
-                },
-
-                // Enum declarations need tracking and have bodies.
-                .enum_decl => {
-                    try contents.explicit_types.append(gpa, inst);
-
-                    const enum_decl = zir.getEnumDecl(inst);
-                    var it = enum_decl.iterateFields();
-                    while (it.next()) |field| {
-                        if (field.value_body) |b| try zir.findTrackableBody(gpa, contents, defers, b);
-                    }
-                },
+                // Type declarations need tracking.
+                .struct_decl,
+                .union_decl,
+                .enum_decl,
+                .opaque_decl,
+                => return contents.type_decls.append(gpa, inst),
             }
         },
 
@@ -4532,7 +4520,6 @@ fn findTrackableInner(
 
         .block,
         .block_inline,
-        .c_import,
         .typeof_builtin,
         .loop,
         => {

package/std/zig/ZonGen.zig

@@ -427,10 +427,11 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
             });
 
             // For short initializers, track the names on the stack rather than going through gpa.
-            var sfba_state = std.heap.stackFallback(256, gpa);
-            const sfba = sfba_state.get();
+            var bfa_buf: [256]u8 = undefined;
+            var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, gpa);
+            const bfa = bfa_state.allocator();
             var field_names: std.AutoHashMapUnmanaged(Zoir.NullTerminatedString, Ast.TokenIndex) = .empty;
-            defer field_names.deinit(sfba);
+            defer field_names.deinit(bfa);
 
             var reported_any_duplicate = false;
 
@@ -438,7 +439,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
                 const name_token = tree.firstToken(elem_node) - 2;
                 if (zg.identAsString(name_token)) |name_str| {
                     zg.extra.items[extra_name_idx] = @intFromEnum(name_str);
-                    const gop = try field_names.getOrPut(sfba, name_str);
+                    const gop = try field_names.getOrPut(bfa, name_str);
                     if (gop.found_existing and !reported_any_duplicate) {
                         reported_any_duplicate = true;
                         const earlier_token = gop.value_ptr.*;
@@ -667,7 +668,7 @@ fn numberLiteral(zg: *ZonGen, num_node: Ast.Node.Index, src_node: Ast.Node.Index
             big_int.setString(@intFromEnum(base), num_without_prefix) catch |err| switch (err) {
                 error.InvalidCharacter => unreachable, // caught in `parseNumberLiteral`
                 error.InvalidBase => unreachable, // we only pass 16, 8, 2, see above
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
             };
             switch (sign) {
                 .positive => {},

package/std/zig/llvm/Builder.zig

@@ -7638,9 +7638,9 @@ pub const Constant = enum(u32) {
                                 std.math.big.int.calcToStringLimbsBufferLen(expected_limbs, 10)
                             ]std.math.big.Limb,
                         };
-                        var stack align(@alignOf(ExpectedContents)) =
-                            std.heap.stackFallback(@sizeOf(ExpectedContents), data.builder.gpa);
-                        const allocator = stack.get();
+                        var bfa_buf: ExpectedContents = undefined;
+                        var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), data.builder.gpa);
+                        const allocator = bfa.allocator();
                         const str = bigint.toStringAlloc(allocator, 10, undefined) catch return error.WriteFailed;
                         defer allocator.free(str);
                         try w.writeAll(str);
@@ -9209,9 +9209,9 @@ pub fn getIntrinsic(
             fields: [expected_fields_len]Type,
         },
     };
-    var stack align(@max(@alignOf(std.heap.StackFallbackAllocator(0)), @alignOf(ExpectedContents))) =
-        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
-    const allocator = stack.get();
+    var bfa_buf: ExpectedContents = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
+    const allocator = bfa.allocator();
 
     const name = name: {
         {
@@ -10607,9 +10607,9 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
                             std.math.big.int.calcToStringLimbsBufferLen(expected_limbs, 10)
                         ]std.math.big.Limb,
                     };
-                    var stack align(@alignOf(ExpectedContents)) =
-                        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
-                    const allocator = stack.get();
+                    var bfa_buf: ExpectedContents = undefined;
+                    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
+                    const allocator = bfa.allocator();
 
                     const limbs = self.metadata_limbs.items[extra.limbs_index..][0..extra.limbs_len];
                     const bigint: std.math.big.int.Const = .{
@@ -11129,9 +11129,9 @@ fn bigIntConstAssumeCapacity(
     const bits = type_item.data;
 
     const ExpectedContents = [64 / @sizeOf(std.math.big.Limb)]std.math.big.Limb;
-    var stack align(@alignOf(ExpectedContents)) =
-        std.heap.stackFallback(@sizeOf(ExpectedContents), self.gpa);
-    const allocator = stack.get();
+    var bfa_buf: ExpectedContents = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
+    const allocator = bfa.allocator();
 
     var limbs: []std.math.big.Limb = &.{};
     defer allocator.free(limbs);

package/std/zig.zig

@@ -744,6 +744,7 @@ pub fn parseTargetQueryOrReportFatalError(
 pub const EnvVar = enum {
     ZIG_GLOBAL_CACHE_DIR,
     ZIG_LOCAL_CACHE_DIR,
+    ZIG_LOCAL_PKG_DIR,
     ZIG_LIB_DIR,
     ZIG_LIBC,
     ZIG_BUILD_RUNNER,
@@ -796,11 +797,6 @@ pub const SimpleComptimeReason = enum(u32) {
     operand_branchHint,
     operand_setRuntimeSafety,
     operand_embedFile,
-    operand_cImport,
-    operand_cDefine_macro_name,
-    operand_cDefine_macro_value,
-    operand_cInclude_file_name,
-    operand_cUndef_macro_name,
     operand_shuffle_mask,
     operand_atomicRmw_operation,
     operand_reduce_operation,
@@ -891,11 +887,6 @@ pub const SimpleComptimeReason = enum(u32) {
             .operand_branchHint          => "operand to '@branchHint' must be comptime-known",
             .operand_setRuntimeSafety    => "operand to '@setRuntimeSafety' must be comptime-known",
             .operand_embedFile           => "operand to '@embedFile' must be comptime-known",
-            .operand_cImport             => "operand to '@cImport' is evaluated at comptime",
-            .operand_cDefine_macro_name  => "'@cDefine' macro name must be comptime-known",
-            .operand_cDefine_macro_value => "'@cDefine' macro value must be comptime-known",
-            .operand_cInclude_file_name  => "'@cInclude' file name must be comptime-known",
-            .operand_cUndef_macro_name   => "'@cUndef' macro name must be comptime-known",
             .operand_shuffle_mask        => "'@shuffle' mask must be comptime-known",
             .operand_atomicRmw_operation => "'@atomicRmw' operation must be comptime-known",
             .operand_reduce_operation    => "'@reduce' operation must be comptime-known",

package/std/zip.zig

@@ -143,7 +143,7 @@ pub const EndRecord = extern struct {
                 const read_buf: []u8 = buf[buf.len - new_loaded_len ..][0..read_len];
                 fr.interface.readSliceAll(read_buf) catch |err| switch (err) {
                     error.ReadFailed => return fr.err.?,
-                    error.EndOfStream => return error.EndOfStream,
+                    error.EndOfStream => |e| return e,
                 };
                 loaded_len = new_loaded_len;
             }
@@ -310,7 +310,7 @@ pub const Iterator = struct {
         try input.seekTo(stream_len - locator_end_offset);
         const locator = input.interface.takeStruct(EndLocator64, .little) catch |err| switch (err) {
             error.ReadFailed => return input.err.?,
-            error.EndOfStream => return error.EndOfStream,
+            error.EndOfStream => |e| return e,
         };
         if (!std.mem.eql(u8, &locator.signature, &end_locator64_sig))
             return error.ZipBadLocatorSig;
@@ -323,7 +323,7 @@ pub const Iterator = struct {
 
         const record64 = input.interface.takeStruct(EndRecord64, .little) catch |err| switch (err) {
             error.ReadFailed => return input.err.?,
-            error.EndOfStream => return error.EndOfStream,
+            error.EndOfStream => |e| return e,
         };
 
         if (!std.mem.eql(u8, &record64.signature, &end_record64_sig))
@@ -379,7 +379,7 @@ pub const Iterator = struct {
         try input.seekTo(header_zip_offset);
         const header = input.interface.takeStruct(CentralDirectoryFileHeader, .little) catch |err| switch (err) {
             error.ReadFailed => return input.err.?,
-            error.EndOfStream => return error.EndOfStream,
+            error.EndOfStream => |e| return e,
         };
         if (!std.mem.eql(u8, &header.signature, &central_file_header_sig))
             return error.ZipBadCdOffset;
@@ -410,7 +410,7 @@ pub const Iterator = struct {
             try input.seekTo(header_zip_offset + @sizeOf(CentralDirectoryFileHeader) + header.filename_len);
             input.interface.readSliceAll(extra) catch |err| switch (err) {
                 error.ReadFailed => return input.err.?,
-                error.EndOfStream => return error.EndOfStream,
+                error.EndOfStream => |e| return e,
             };
 
             var extra_offset: usize = 0;