@zigc/lib 0.16.0-test.1 → 0.17.0-dev.131

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,
@@ -2009,12 +2003,14 @@ pub const Inst = struct {
         /// `operand` is payload index to `BinNode`.
         /// `small` is unused.
         shl_with_overflow,
-        /// `operand` is payload index to `UnNode`.
-        c_undef,
-        /// `operand` is payload index to `UnNode`.
-        c_include,
+        /// `@round`, `@floor`, `@ceil`, or `@trunc`, with a result type.
         /// `operand` is payload index to `BinNode`.
-        c_define,
+        /// `small` is a `RoundOp` representing the specific operation being performed.
+        round_op,
+        /// Returns the type for the operand of a rounding op.
+        /// `operand` is `UnNode`.
+        /// `small` is unused.
+        round_op_ty,
         /// `operand` is payload index to `UnNode`.
         wasm_memory_size,
         /// `operand` is payload index to `BinNode`.
@@ -3233,6 +3229,13 @@ pub const Inst = struct {
         string_to_union_field_attrs,
     };
 
+    pub const RoundOp = enum(u16) {
+        round,
+        floor,
+        ceil,
+        trunc,
+    };
+
     pub const UnNode = struct {
         node: Ast.Node.Offset,
         operand: Ref,
@@ -4018,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 {
@@ -4061,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(
@@ -4344,9 +4381,7 @@ fn findTrackableInner(
                 .sub_with_overflow,
                 .mul_with_overflow,
                 .shl_with_overflow,
-                .c_undef,
-                .c_include,
-                .c_define,
+                .round_op,
                 .wasm_memory_size,
                 .wasm_memory_grow,
                 .prefetch,
@@ -4385,6 +4420,7 @@ fn findTrackableInner(
                 .dbg_empty_stmt,
                 .astgen_error,
                 .float_op_result_ty,
+                .round_op_ty,
                 => return,
 
                 // `@TypeOf` has a body.
@@ -4394,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),
             }
         },
 
@@ -4515,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/c_translation/helpers.zig

@@ -81,15 +81,20 @@ fn ToUnsigned(comptime T: type) type {
 }
 
 /// Constructs a [*c] pointer with the const and volatile annotations
-/// from Self for pointing to a C flexible array of Element.
-pub fn FlexibleArrayType(comptime Self: type, comptime Element: type) type {
-    return switch (@typeInfo(Self)) {
-        .pointer => |ptr| @Pointer(.c, .{
-            .@"const" = ptr.is_const,
-            .@"volatile" = ptr.is_volatile,
-        }, Element, null),
-        else => |info| @compileError("Invalid self type \"" ++ @tagName(info) ++ "\" for flexible array getter: " ++ @typeName(Self)),
-    };
+/// from SelfType for pointing to a C flexible array of ElementType.
+pub fn FlexibleArrayType(comptime SelfType: type, comptime ElementType: type) type {
+    switch (@typeInfo(SelfType)) {
+        .pointer => |ptr| {
+            return @Pointer(.c, .{
+                .@"const" = ptr.is_const,
+                .@"volatile" = ptr.is_volatile,
+                .@"allowzero" = true,
+                .@"addrspace" = .generic,
+                .@"align" = null,
+            }, ElementType, null);
+        },
+        else => |info| @compileError("Invalid self type \"" ++ @tagName(info) ++ "\" for flexible array getter: " ++ @typeName(SelfType)),
+    }
 }
 
 /// Promote the type of an integer literal until it fits as C would.