@zigc/lib 0.16.0 → 0.17.0-dev.131

package/std/os/uefi/tables/boot_services.zig

@@ -158,12 +158,10 @@ pub const BootServices = extern struct {
     _locateProtocol: *const fn (protocol: *const Guid, registration: ?EventRegistration, interface: *?*const anyopaque) callconv(cc) Status,
 
     /// Installs one or more protocol interfaces into the boot services environment
-    // TODO: use callconv(cc) instead once that works
-    _installMultipleProtocolInterfaces: *const fn (handle: *Handle, ...) callconv(.c) Status,
+    _installMultipleProtocolInterfaces: *const fn (handle: *?Handle, ...) callconv(cc) Status,
 
     /// Removes one or more protocol interfaces into the boot services environment
-    // TODO: use callconv(cc) instead once that works
-    _uninstallMultipleProtocolInterfaces: *const fn (handle: *Handle, ...) callconv(.c) Status,
+    _uninstallMultipleProtocolInterfaces: *const fn (handle: Handle, ...) callconv(cc) Status,
 
     /// Computes and returns a 32-bit CRC for a data buffer.
     _calculateCrc32: *const fn (data: [*]const u8, data_size: usize, *u32) callconv(cc) Status,
@@ -1238,8 +1236,9 @@ fn protocolInterfaces(
         @TypeOf(interfaces),
     ) = undefined;
     result[0] = handle_arg;
+    result[result.len - 1] = null;
 
-    var idx: usize = 1;
+    comptime var idx: usize = 1;
     inline for (interfaces) |interface| {
         const InterfacePtr = @TypeOf(interface);
         const Interface = switch (@typeInfo(InterfacePtr)) {
@@ -1272,13 +1271,15 @@ fn ProtocolInterfaces(HandleType: type, Interfaces: type) type {
         @compileError("expected tuple of protocol interfaces, got " ++ @typeName(Interfaces));
     const interfaces_info = interfaces_type_info.@"struct";
 
-    var tuple_types: [interfaces_info.fields.len * 2 + 1]type = undefined;
+    var tuple_types: [interfaces_info.fields.len * 2 + 2]type = undefined;
     tuple_types[0] = HandleType;
+    tuple_types[tuple_types.len - 1] = ?*const Guid;
+
     var idx = 1;
-    while (idx < tuple_types.len) : (idx += 2) {
+    while (idx < tuple_types.len - 1) : (idx += 2) {
         tuple_types[idx] = *const Guid;
         tuple_types[idx + 1] = *const anyopaque;
     }
 
-    return std.meta.Tuple(tuple_types[0..]);
+    return @Tuple(tuple_types[0..]);
 }

package/std/os.zig

@@ -1,4 +1,5 @@
 const builtin = @import("builtin");
+const std = @import("std.zig");
 const native_os = builtin.os.tag;
 
 pub const linux = @import("os/linux.zig");
@@ -8,6 +9,46 @@ pub const wasi = @import("os/wasi.zig");
 pub const emscripten = @import("os/emscripten.zig");
 pub const windows = @import("os/windows.zig");
 
+/// Returns whether the Zig standard library requires libc in order to interface
+/// with the operating system on the given target.
+pub fn targetRequiresLibC(target: *const std.Target) bool {
+    if (target.requiresLibC()) return true;
+    return switch (target.os.tag) {
+        .linux => switch (target.cpu.arch) {
+            // https://codeberg.org/ziglang/zig/issues/30940
+            .alpha,
+            // https://codeberg.org/ziglang/zig/issues/30942
+            .csky,
+            // https://codeberg.org/ziglang/zig/issues/30943
+            .hppa,
+            .hppa64,
+            // https://codeberg.org/ziglang/zig/issues/30944
+            .microblaze,
+            .microblazeel,
+            // https://codeberg.org/ziglang/zig/issues/30946
+            .sh,
+            .sheb,
+            // https://codeberg.org/ziglang/zig/issues/30945
+            .sparc,
+            // https://codeberg.org/ziglang/zig/issues/30947
+            .xtensa,
+            .xtensaeb,
+            => true,
+            else => false,
+        },
+        .freebsd => true, // https://codeberg.org/ziglang/zig/issues/30981
+        .netbsd => true, // https://codeberg.org/ziglang/zig/issues/30980
+        .openbsd => true, // https://codeberg.org/ziglang/zig/issues/30982
+        else => false,
+    };
+}
+
+/// Returns whether the Zig standard library requires libc in order to interface
+/// with the operating system on the current target.
+pub fn requiresLibC() bool {
+    return targetRequiresLibC(&builtin.target);
+}
+
 test {
     _ = linux;
     if (native_os == .uefi) _ = uefi;

package/std/process.zig

@@ -130,7 +130,7 @@ pub fn posixGetUserInfo(io: Io, name: []const u8) !UserInfo {
     return posixGetUserInfoPasswdStream(name, &file_reader.interface) catch |err| switch (err) {
         error.ReadFailed => return file_reader.err.?,
         error.EndOfStream => return error.UserNotFound,
-        error.CorruptPasswordFile => return error.CorruptPasswordFile,
+        error.CorruptPasswordFile => |e| return e,
     };
 }
 

package/std/sort.zig

@@ -749,9 +749,9 @@ test partitionPoint {
 
 /// Returns a tuple of the lower and upper indices in `items` between which all
 /// elements return `.eq` when given to `compareFn`.
-/// - If no element in `items` returns `.eq`, both indices are the
-/// index of the first element in `items` returning `.gt`.
-/// - If no element in `items` returns `.gt`, both indices equal `items.len`.
+/// If no element in `items` returns `.eq`, both indices are the index of the
+/// first element in `items` which returns `.gt`, or if no element returns `.gt`,
+/// both indices are `items.len`.
 ///
 /// `items` must be sorted in ascending order with respect to `compareFn`:
 /// ```

package/std/zig/Ast/Render.zig

@@ -998,8 +998,8 @@ fn rendersMultiline(r: *const Render, node: Ast.Node.Index) error{OutOfMemory}!b
         .fixups = r.fixups,
     };
 
-    renderExpression(&sub_r, node, .none) catch |e| return switch (e) {
-        error.OutOfMemory => return error.OutOfMemory,
+    renderExpression(&sub_r, node, .none) catch |err| return switch (err) {
+        error.OutOfMemory => |e| return e,
         error.WriteFailed => return true,
     };
     if (sub_ais.disabled_offset != null) return true;
@@ -1685,7 +1685,7 @@ fn renderBuiltinCall(
             assert(tree.tokenTag(str_lit_token) == .string_literal);
             const token_bytes = tree.tokenSlice(str_lit_token);
             const imported_string = std.zig.string_literal.parseAlloc(r.gpa, token_bytes) catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 error.InvalidLiteral => break :f,
             };
             defer r.gpa.free(imported_string);

package/std/zig/AstGen.zig

@@ -199,7 +199,7 @@ pub fn generate(gpa: Allocator, tree: Ast) Allocator.Error!Zir {
             assert(struct_decl_ref.toIndex().? == .main_struct_inst);
             break :fatal false;
         } else |err| switch (err) {
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
             error.AnalysisFail => break :fatal true, // Handled via compile_errors below.
         }
     } else fatal: {
@@ -1776,11 +1776,12 @@ fn structInitExpr(
     }
 
     {
-        var sfba = std.heap.stackFallback(256, astgen.arena);
-        const sfba_allocator = sfba.get();
+        var bfa_buf: [256]u8 = undefined;
+        var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, astgen.arena);
+        const bfa = bfa_state.allocator();
 
         var duplicate_names: std.array_hash_map.Auto(Zir.NullTerminatedString, ArrayList(Ast.TokenIndex)) = .empty;
-        try duplicate_names.ensureTotalCapacity(sfba_allocator, @intCast(struct_init.ast.fields.len));
+        try duplicate_names.ensureTotalCapacity(bfa, @intCast(struct_init.ast.fields.len));
 
         // When there aren't errors, use this to avoid a second iteration.
         var any_duplicate = false;
@@ -1789,14 +1790,14 @@ fn structInitExpr(
             const name_token = tree.firstToken(field) - 2;
             const name_index = try astgen.identAsString(name_token);
 
-            const gop = try duplicate_names.getOrPut(sfba_allocator, name_index);
+            const gop = try duplicate_names.getOrPut(bfa, name_index);
 
             if (gop.found_existing) {
-                try gop.value_ptr.append(sfba_allocator, name_token);
+                try gop.value_ptr.append(bfa, name_token);
                 any_duplicate = true;
             } else {
                 gop.value_ptr.* = .empty;
-                try gop.value_ptr.append(sfba_allocator, name_token);
+                try gop.value_ptr.append(bfa, name_token);
             }
         }
 
@@ -2870,7 +2871,6 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As
             .mul_add,
             .max,
             .min,
-            .c_import,
             .@"resume",
             .ret_err_value_code,
             .ret_ptr,
@@ -5681,7 +5681,7 @@ fn containerMember(
 
             const prev_decl_index = wip_decls.index;
             astgen.fnDecl(gz, scope, wip_decls, member_node, body, full) catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 error.AnalysisFail => {
                     wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
@@ -5704,7 +5704,7 @@ fn containerMember(
             const full = tree.fullVarDecl(member_node).?;
             const prev_decl_index = wip_decls.index;
             astgen.globalVarDecl(gz, scope, wip_decls, member_node, full) catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 error.AnalysisFail => {
                     wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
@@ -5722,7 +5722,7 @@ fn containerMember(
         .@"comptime" => {
             const prev_decl_index = wip_decls.index;
             astgen.comptimeDecl(gz, scope, wip_decls, member_node) catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 error.AnalysisFail => {
                     wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
@@ -5742,7 +5742,7 @@ fn containerMember(
             // Since it doesn't strictly matter *what* this is, let's save ourselves the trouble
             // of duplicating the test name logic, and just assume this is an unnamed test.
             astgen.testDecl(gz, scope, wip_decls, member_node) catch |err| switch (err) {
-                error.OutOfMemory => return error.OutOfMemory,
+                error.OutOfMemory => |e| return e,
                 error.AnalysisFail => {
                     wip_decls.index = prev_decl_index;
                     try addFailedDeclaration(
@@ -6656,9 +6656,16 @@ fn whileExpr(
                 .operand = undefined,
             } },
         });
+        if (!continue_scope.is_comptime) {
+            _ = try continue_scope.addRestoreErrRetIndex(.{ .block = continue_block }, .always, then_node);
+        }
         _ = try continue_scope.addBreak(break_tag, continue_block, .void_value);
     }
     try continue_scope.setBlockBody(continue_block);
+    if (!then_scope.is_comptime) {
+        const cont_node = while_full.ast.cont_expr.unwrap() orelse then_node;
+        _ = try then_scope.addRestoreErrRetIndex(.{ .block = cond_block }, .always, cont_node);
+    }
     _ = try then_scope.addBreak(break_tag, cond_block, .void_value);
 
     var else_scope = parent_gz.makeSubBlock(&cond_scope.base);
@@ -6703,6 +6710,9 @@ fn whileExpr(
 
         try checkUsed(parent_gz, &else_scope.base, sub_scope);
         if (!else_scope.endsWithNoReturn()) {
+            if (!else_scope.is_comptime) {
+                _ = try else_scope.addRestoreErrRetIndex(.{ .block = loop_block }, .always, else_node);
+            }
             _ = try else_scope.addBreakWithSrcNode(break_tag, loop_block, else_result, else_node);
         }
     } else {
@@ -6973,6 +6983,9 @@ fn forExpr(
     });
 
     const break_tag: Zir.Inst.Tag = if (is_inline) .break_inline else .@"break";
+    if (!then_scope.is_comptime) {
+        _ = try then_scope.addRestoreErrRetIndex(.{ .block = cond_block }, .always, then_node);
+    }
     _ = try then_scope.addBreak(break_tag, cond_block, .void_value);
 
     var else_scope = parent_gz.makeSubBlock(&cond_scope.base);
@@ -6990,6 +7003,9 @@ fn forExpr(
             _ = try addEnsureResult(&else_scope, else_result, else_node);
         }
         if (!else_scope.endsWithNoReturn()) {
+            if (!else_scope.is_comptime) {
+                _ = try else_scope.addRestoreErrRetIndex(.{ .block = loop_block }, .always, else_node);
+            }
             _ = try else_scope.addBreakWithSrcNode(break_tag, loop_block, else_result, else_node);
         }
     } else {
@@ -8405,9 +8421,10 @@ fn tunnelThroughClosure(
 
     // Otherwise we need a tunnel. First, figure out the path of namespaces we
     // are tunneling through. This is usually only going to be one or two, so
-    // use an SFBA to optimize for the common case.
-    var sfba = std.heap.stackFallback(@sizeOf(usize) * 2, astgen.arena);
-    var intermediate_tunnels = try sfba.get().alloc(*Scope.Namespace, num_tunnels - 1);
+    // use an BFA to optimize for the common case.
+    var bfa_buf: [2]usize = undefined;
+    var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), astgen.arena);
+    var intermediate_tunnels = try bfa.allocator().alloc(*Scope.Namespace, num_tunnels - 1);
 
     const root_ns = ns: {
         var i: usize = num_tunnels - 1;
@@ -8562,7 +8579,7 @@ fn numberLiteral(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index, source_node:
             big_int.setString(@intFromEnum(base), bytes[prefix_offset..]) 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,
             };
 
             const limbs = big_int.limbs[0..big_int.len()];
@@ -8955,7 +8972,6 @@ fn typeOf(
         var typeof_scope = gz.makeSubBlock(scope);
         typeof_scope.is_comptime = false;
         typeof_scope.is_typeof = true;
-        typeof_scope.c_import = false;
         defer typeof_scope.unstack();
 
         const ty_expr = try reachableExpr(&typeof_scope, &typeof_scope.base, .{ .rl = .none }, args[0], node);
@@ -9055,8 +9071,7 @@ fn builtinCall(
     const builtin_name = tree.tokenSlice(builtin_token);
 
     // We handle the different builtins manually because they have different semantics depending
-    // on the function. For example, `@as` and others participate in result location semantics,
-    // and `@cImport` creates a special scope that collects a .c source code text buffer.
+    // on the function. For example, `@as` and others participate in result location semantics.
     // Also, some builtins have a variable number of parameters.
 
     const info = BuiltinFn.list.get(builtin_name) orelse {
@@ -9175,7 +9190,6 @@ fn builtinCall(
         .bit_cast   => return bitCast(  gz, scope, ri, node, params[0]),
         .TypeOf     => return typeOf(   gz, scope, ri, node, params),
         .union_init => return unionInit(gz, scope, ri, node, params),
-        .c_import   => return cImport(  gz, scope,     node, params[0]),
         .min        => return minMax(   gz, scope, ri, node, params, .min),
         .max        => return minMax(   gz, scope, ri, node, params, .max),
         // zig fmt: on
@@ -9484,9 +9498,6 @@ fn builtinCall(
         .bit_offset_of => return offsetOf(gz, scope, ri, node, params[0], params[1], .bit_offset_of),
         .offset_of     => return offsetOf(gz, scope, ri, node, params[0], params[1], .offset_of),
 
-        .c_undef   => return simpleCBuiltin(gz, scope, ri, node, params[0], .c_undef),
-        .c_include => return simpleCBuiltin(gz, scope, ri, node, params[0], .c_include),
-
         .cmpxchg_strong => return cmpxchg(gz, scope, ri, node, params, 1),
         .cmpxchg_weak   => return cmpxchg(gz, scope, ri, node, params, 0),
         // zig fmt: on
@@ -9509,17 +9520,6 @@ fn builtinCall(
             });
             return rvalue(gz, ri, result, node);
         },
-        .c_define => {
-            if (!gz.c_import) return gz.astgen.failNode(node, "C define valid only inside C import block", .{});
-            const name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, params[0], .operand_cDefine_macro_name);
-            const value = try comptimeExpr(gz, scope, .{ .rl = .none }, params[1], .operand_cDefine_macro_value);
-            const result = try gz.addExtendedPayload(.c_define, Zir.Inst.BinNode{
-                .node = gz.nodeIndexToRelative(node),
-                .lhs = name,
-                .rhs = value,
-            });
-            return rvalue(gz, ri, result, node);
-        },
         .splat => {
             const result_type = try ri.rl.resultTypeForCast(gz, node, builtin_name);
             const elem_type = try gz.addUnNode(.splat_op_result_ty, result_type, node);
@@ -9951,30 +9951,6 @@ fn divBuiltin(
     return rvalue(gz, ri, result, node);
 }
 
-fn simpleCBuiltin(
-    gz: *GenZir,
-    scope: *Scope,
-    ri: ResultInfo,
-    node: Ast.Node.Index,
-    operand_node: Ast.Node.Index,
-    tag: Zir.Inst.Extended,
-) InnerError!Zir.Inst.Ref {
-    const name: []const u8 = if (tag == .c_undef) "C undef" else "C include";
-    if (!gz.c_import) return gz.astgen.failNode(node, "{s} valid only inside C import block", .{name});
-    const operand = try comptimeExpr(
-        gz,
-        scope,
-        .{ .rl = .{ .coerced_ty = .slice_const_u8_type } },
-        operand_node,
-        if (tag == .c_undef) .operand_cUndef_macro_name else .operand_cInclude_file_name,
-    );
-    _ = try gz.addExtendedPayload(tag, Zir.Inst.UnNode{
-        .node = gz.nodeIndexToRelative(node),
-        .operand = operand,
-    });
-    return rvalue(gz, ri, .void_value, node);
-}
-
 fn offsetOf(
     gz: *GenZir,
     scope: *Scope,
@@ -10024,35 +10000,6 @@ fn shiftOp(
     return rvalue(gz, ri, result, node);
 }
 
-fn cImport(
-    gz: *GenZir,
-    scope: *Scope,
-    node: Ast.Node.Index,
-    body_node: Ast.Node.Index,
-) InnerError!Zir.Inst.Ref {
-    const astgen = gz.astgen;
-    const gpa = astgen.gpa;
-
-    if (gz.c_import) return gz.astgen.failNode(node, "cannot nest @cImport", .{});
-
-    var block_scope = gz.makeSubBlock(scope);
-    block_scope.is_comptime = true;
-    block_scope.c_import = true;
-    defer block_scope.unstack();
-
-    const block_inst = try gz.makeBlockInst(.c_import, node);
-    const block_result = try fullBodyExpr(&block_scope, &block_scope.base, .{ .rl = .none }, body_node, .normal);
-    _ = try gz.addUnNode(.ensure_result_used, block_result, node);
-    if (!gz.refIsNoReturn(block_result)) {
-        _ = try block_scope.addBreak(.break_inline, block_inst, .void_value);
-    }
-    try block_scope.setBlockBody(block_inst);
-    // block_scope unstacked now, can add new instructions to gz
-    try gz.instructions.append(gpa, block_inst);
-
-    return block_inst.toRef();
-}
-
 fn overflowArithmetic(
     gz: *GenZir,
     scope: *Scope,
@@ -11339,7 +11286,6 @@ const GenZir = struct {
     /// This is set to true for a `GenZir` of a `block_inline`, indicating that
     /// exits from this block should use `break_inline` rather than `break`.
     is_inline: bool = false,
-    c_import: bool = false,
     /// The containing decl AST node.
     decl_node_index: Ast.Node.Index,
     /// The containing decl line index, absolute.
@@ -11427,7 +11373,6 @@ const GenZir = struct {
         return .{
             .is_comptime = gz.is_comptime,
             .is_typeof = gz.is_typeof,
-            .c_import = gz.c_import,
             .decl_node_index = gz.decl_node_index,
             .decl_line = gz.decl_line,
             .parent = scope,
@@ -12999,17 +12944,18 @@ fn scanContainer(
         next: ?*@This(),
     };
 
-    // The maps below are allocated into this SFBA to avoid using the GPA for small namespaces.
-    var sfba_state = std.heap.stackFallback(512, astgen.gpa);
-    const sfba = sfba_state.get();
+    // The maps below are allocated into this BFA to avoid using the GPA for small namespaces.
+    var bfa_buf: [512]u8 = undefined;
+    var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, astgen.gpa);
+    const bfa = bfa_state.allocator();
 
     var names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
     var test_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
     var decltest_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
     defer {
-        names.deinit(sfba);
-        test_names.deinit(sfba);
-        decltest_names.deinit(sfba);
+        names.deinit(bfa);
+        test_names.deinit(bfa);
+        decltest_names.deinit(bfa);
     }
 
     var any_duplicates = false;
@@ -13081,7 +13027,7 @@ fn scanContainer(
                     else => {}, // unnamed test
                     .string_literal => {
                         const name = try astgen.strLitAsString(test_name_token);
-                        const gop = try test_names.getOrPut(sfba, name.index);
+                        const gop = try test_names.getOrPut(bfa, name.index);
                         if (gop.found_existing) {
                             var e = gop.value_ptr;
                             while (e.next) |n| e = n;
@@ -13094,7 +13040,7 @@ fn scanContainer(
                     },
                     .identifier => {
                         const name = try astgen.identAsString(test_name_token);
-                        const gop = try decltest_names.getOrPut(sfba, name);
+                        const gop = try decltest_names.getOrPut(bfa, name);
                         if (gop.found_existing) {
                             var e = gop.value_ptr;
                             while (e.next) |n| e = n;
@@ -13121,7 +13067,7 @@ fn scanContainer(
         }
 
         {
-            const gop = try names.getOrPut(sfba, name_str_index);
+            const gop = try names.getOrPut(bfa, name_str_index);
             const new_ent: NameEntry = .{
                 .tok = name_token,
                 .next = null,

package/std/zig/AstRlAnnotate.zig

@@ -842,10 +842,6 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast.
             _ = try astrl.expr(args[2], block, ResultInfo.type_only);
             return false;
         },
-        .c_import => {
-            _ = try astrl.expr(args[0], block, ResultInfo.none);
-            return false;
-        },
         .min, .max => {
             for (args) |arg_node| {
                 _ = try astrl.expr(arg_node, block, ResultInfo.none);
@@ -907,8 +903,6 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast.
         .error_name,
         .set_runtime_safety,
         .Tuple,
-        .c_undef,
-        .c_include,
         .wasm_memory_size,
         .splat,
         .set_float_mode,
@@ -986,11 +980,6 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast.
             _ = try astrl.expr(args[1], block, ResultInfo.type_only);
             return false;
         },
-        .c_define => {
-            _ = try astrl.expr(args[0], block, ResultInfo.type_only);
-            _ = try astrl.expr(args[1], block, ResultInfo.none);
-            return false;
-        },
         .reduce => {
             _ = try astrl.expr(args[0], block, ResultInfo.type_only);
             _ = try astrl.expr(args[1], block, ResultInfo.none);

package/std/zig/BuiltinFn.zig

@@ -20,9 +20,6 @@ pub const Tag = enum {
     bit_reverse,
     offset_of,
     call,
-    c_define,
-    c_import,
-    c_include,
     clz,
     cmpxchg_strong,
     cmpxchg_weak,
@@ -30,7 +27,6 @@ pub const Tag = enum {
     compile_log,
     const_cast,
     ctz,
-    c_undef,
     c_va_arg,
     c_va_copy,
     c_va_end,
@@ -306,27 +302,6 @@ pub const list = list: {
                 .param_count = 3,
             },
         },
-        .{
-            "@cDefine",
-            .{
-                .tag = .c_define,
-                .param_count = 2,
-            },
-        },
-        .{
-            "@cImport",
-            .{
-                .tag = .c_import,
-                .param_count = 1,
-            },
-        },
-        .{
-            "@cInclude",
-            .{
-                .tag = .c_include,
-                .param_count = 1,
-            },
-        },
         .{
             "@clz",
             .{
@@ -376,13 +351,6 @@ pub const list = list: {
                 .param_count = 1,
             },
         },
-        .{
-            "@cUndef",
-            .{
-                .tag = .c_undef,
-                .param_count = 1,
-            },
-        },
         .{
             "@cVaArg",
             .{

package/std/zig/LibCInstallation.zig

@@ -196,7 +196,7 @@ pub fn findNative(gpa: Allocator, io: Io, args: FindNativeOptions) FindError!Lib
         const sdk = std.zig.WindowsSdk.find(gpa, io, args.target.cpu.arch, args.environ_map) catch |err| switch (err) {
             error.NotFound => return error.WindowsSdkNotFound,
             error.PathTooLong => return error.WindowsSdkNotFound,
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
         };
         defer sdk.free(gpa);
 
@@ -278,7 +278,7 @@ fn findNativeIncludeDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, ar
         // So we use the expandArg0 variant of ChildProcess to give them a helping hand.
         .expand_arg0 = .expand,
     }) catch |err| switch (err) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
         else => {
             printVerboseInvocation(argv.items, null, args.verbose, null);
             return error.UnableToSpawnCCompiler;
@@ -459,6 +459,7 @@ fn findNativeCrtDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, args:
 
 fn findNativeGccDirHaiku(self: *LibCInstallation, gpa: Allocator, io: Io, args: FindNativeOptions) FindError!void {
     self.gcc_dir = try ccPrintFileName(gpa, io, .{
+        .environ_map = args.environ_map,
         .search_basename = "crtbeginS.o",
         .want_dirname = .only_dir,
         .verbose = args.verbose,
@@ -595,7 +596,7 @@ fn ccPrintFileName(gpa: Allocator, io: Io, args: CCPrintFileNameOptions) ![]u8 {
         // So we use the expandArg0 variant of ChildProcess to give them a helping hand.
         .expand_arg0 = .expand,
     }) catch |err| switch (err) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
         else => return error.UnableToSpawnCCompiler,
     };
     defer {

package/std/zig/Parse.zig

@@ -278,7 +278,7 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
                     }
                     const comptime_token = p.nextToken();
                     const opt_block = p.parseBlock() catch |err| switch (err) {
-                        error.OutOfMemory => return error.OutOfMemory,
+                        error.OutOfMemory => |e| return e,
                         error.ParseError => blk: {
                             p.findNextContainerMember();
                             break :blk null;
@@ -301,7 +301,7 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
                     const identifier = p.tok_i;
                     defer last_field = identifier;
                     const container_field = p.expectContainerField() catch |err| switch (err) {
-                        error.OutOfMemory => return error.OutOfMemory,
+                        error.OutOfMemory => |e| return e,
                         error.ParseError => {
                             p.findNextContainerMember();
                             continue;
@@ -398,7 +398,7 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
             },
             else => {
                 const c_container = p.parseCStyleContainer() catch |err| switch (err) {
-                    error.OutOfMemory => return error.OutOfMemory,
+                    error.OutOfMemory => |e| return e,
                     error.ParseError => false,
                 };
                 if (c_container) continue;
@@ -406,7 +406,7 @@ fn parseContainerMembers(p: *Parse) Allocator.Error!Members {
                 const identifier = p.tok_i;
                 defer last_field = identifier;
                 const container_field = p.expectContainerField() catch |err| switch (err) {
-                    error.OutOfMemory => return error.OutOfMemory,
+                    error.OutOfMemory => |e| return e,
                     error.ParseError => {
                         p.findNextContainerMember();
                         continue;
@@ -589,7 +589,7 @@ fn expectTestDeclRecoverable(p: *Parse) error{OutOfMemory}!?Node.Index {
     if (p.expectTestDecl()) |node| {
         return node;
     } else |err| switch (err) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
         error.ParseError => {
             p.findNextContainerMember();
             return null;
@@ -668,7 +668,7 @@ fn expectTopLevelDecl(p: *Parse) !?Node.Index {
 
 fn expectTopLevelDeclRecoverable(p: *Parse) error{OutOfMemory}!?Node.Index {
     return p.expectTopLevelDecl() catch |err| switch (err) {
-        error.OutOfMemory => return error.OutOfMemory,
+        error.OutOfMemory => |e| return e,
         error.ParseError => {
             p.findNextContainerMember();
             return null;
@@ -1145,7 +1145,7 @@ fn expectVarDeclExprStatement(p: *Parse, comptime_token: ?TokenIndex) !Node.Inde
 fn expectStatementRecoverable(p: *Parse) Error!?Node.Index {
     while (true) {
         return p.expectStatement(true) catch |err| switch (err) {
-            error.OutOfMemory => return error.OutOfMemory,
+            error.OutOfMemory => |e| return e,
             error.ParseError => {
                 p.findNextStmt(); // Try to skip to the next statement.
                 switch (p.tokenTag(p.tok_i)) {