@zigc/lib 0.16.0-test.1 → 0.16.0

package/compiler/resinator/main.zig

@@ -143,7 +143,13 @@ pub fn main(init: std.process.Init.Minimal) !void {
                 if (!zig_integration) io.unlockStderr();
             }
 
-            var comp = aro.Compilation.init(aro_arena, aro_arena, io, &diagnostics, Io.Dir.cwd());
+            var comp = try aro.Compilation.init(.{
+                .gpa = aro_arena,
+                .arena = aro_arena,
+                .io = io,
+                .diagnostics = &diagnostics,
+                .environ_map = &environ_map,
+            });
             defer comp.deinit();
 
             var argv: std.ArrayList([]const u8) = .empty;

package/compiler/resinator/preprocess.zig

@@ -14,8 +14,6 @@ pub fn preprocess(
     argv: []const []const u8,
     maybe_dependencies: ?*Dependencies,
 ) PreprocessError!void {
-    try comp.addDefaultPragmaHandlers();
-
     var driver: aro.Driver = .{ .comp = comp, .diagnostics = comp.diagnostics, .aro_name = "arocc" };
     defer driver.deinit();
 
@@ -47,7 +45,7 @@ pub fn preprocess(
     if (hasAnyErrors(comp)) return error.GeneratedSourceError;
 
     comp.generated_buf.items.len = 0;
-    var pp = aro.Preprocessor.initDefault(comp) catch |err| switch (err) {
+    var pp = aro.Preprocessor.init(comp, .{ .base_file = source.id }) catch |err| switch (err) {
         error.FatalError => return error.GeneratedSourceError,
         error.OutOfMemory => |e| return e,
     };

package/compiler/std-docs.zig

@@ -423,7 +423,14 @@ fn buildWasmBinary(
             );
             return error.WasmCompilationFailed;
         },
-        .stopped, .unknown => {
+        .stopped => |sig| {
+            std.log.err(
+                "the following command stopped unexpectedly with signal {t}:\n{s}",
+                .{ sig, try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items) },
+            );
+            return error.WasmCompilationFailed;
+        },
+        .unknown => {
             std.log.err(
                 "the following command terminated unexpectedly:\n{s}",
                 .{try std.Build.Step.allocPrintCmd(arena, .inherit, null, argv.items)},

package/compiler/test_runner.zig

@@ -6,6 +6,7 @@ const Io = std.Io;
 const fatal = std.process.fatal;
 const testing = std.testing;
 const assert = std.debug.assert;
+const panic = std.debug.panic;
 const fuzz_abi = std.Build.abi.fuzz;
 
 pub const std_options: std.Options = .{
@@ -17,6 +18,8 @@ var fba: std.heap.FixedBufferAllocator = .init(&fba_buffer);
 var fba_buffer: [8192]u8 = undefined;
 var stdin_buffer: [4096]u8 = undefined;
 var stdout_buffer: [4096]u8 = undefined;
+var stdin_reader: Io.File.Reader = undefined;
+var stdout_writer: Io.File.Writer = undefined;
 const runner_threaded_io: Io = Io.Threaded.global_single_threaded.io();
 
 /// Keep in sync with logic in `std.Build.addRunArtifact` which decides whether
@@ -38,10 +41,10 @@ pub fn main(init: std.process.Init.Minimal) void {
     }
 
     if (need_simple) {
-        return mainSimple() catch |err| std.debug.panic("test failure: {t}", .{err});
+        return mainSimple() catch |err| panic("test failure: {t}", .{err});
     }
 
-    const args = init.args.toSlice(fba.allocator()) catch |err| std.debug.panic("unable to parse command line args: {t}", .{err});
+    const args = init.args.toSlice(fba.allocator()) catch |err| panic("unable to parse command line args: {t}", .{err});
 
     var listen = false;
     var opt_cache_dir: ?[]const u8 = null;
@@ -55,7 +58,7 @@ pub fn main(init: std.process.Init.Minimal) void {
         } else if (std.mem.startsWith(u8, arg, "--cache-dir")) {
             opt_cache_dir = arg["--cache-dir=".len..];
         } else {
-            std.debug.panic("unrecognized command line argument: {s}", .{arg});
+            panic("unrecognized command line argument: {s}", .{arg});
         }
     }
 
@@ -65,7 +68,7 @@ pub fn main(init: std.process.Init.Minimal) void {
     }
 
     if (listen) {
-        return mainServer(init) catch |err| std.debug.panic("internal test runner failure: {t}", .{err});
+        return mainServer(init) catch |err| panic("internal test runner failure: {t}", .{err});
     } else {
         return mainTerminal(init);
     }
@@ -73,24 +76,14 @@ pub fn main(init: std.process.Init.Minimal) void {
 
 fn mainServer(init: std.process.Init.Minimal) !void {
     @disableInstrumentation();
-    var stdin_reader = Io.File.stdin().readerStreaming(runner_threaded_io, &stdin_buffer);
-    var stdout_writer = Io.File.stdout().writerStreaming(runner_threaded_io, &stdout_buffer);
+    stdin_reader = .initStreaming(.stdin(), runner_threaded_io, &stdin_buffer);
+    stdout_writer = .initStreaming(.stdout(), runner_threaded_io, &stdout_buffer);
     var server = try std.zig.Server.init(.{
         .in = &stdin_reader.interface,
         .out = &stdout_writer.interface,
         .zig_version = builtin.zig_version_string,
     });
 
-    if (builtin.fuzz) {
-        const coverage = fuzz_abi.fuzzer_coverage();
-        try server.serveCoverageIdMessage(
-            coverage.id,
-            coverage.runs,
-            coverage.unique,
-            coverage.seen,
-        );
-    }
-
     while (true) {
         const hdr = try server.receiveMessage();
         switch (hdr.tag) {
@@ -151,7 +144,7 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                     error.SkipZigTest => .skip,
                     else => s: {
                         if (@errorReturnTrace()) |trace| {
-                            std.debug.dumpStackTrace(trace);
+                            std.debug.dumpErrorReturnTrace(trace);
                         }
                         break :s .fail;
                     },
@@ -180,48 +173,75 @@ fn mainServer(init: std.process.Init.Minimal) !void {
                 // since they are not present.
                 if (!builtin.fuzz) unreachable;
 
-                const index: u32 = @intCast(index: {
-                    testing.allocator_instance = .{};
-                    defer if (testing.allocator_instance.deinit() == .leak) {
-                        @panic("internal test runner memory leak");
-                    };
-
-                    const name_len = try server.receiveBody_u32();
-                    const name = try server.in.readAlloc(testing.allocator, @intCast(name_len));
-                    defer testing.allocator.free(name);
-                    for (0.., builtin.test_functions) |i, test_fn| {
-                        if (std.mem.eql(u8, name, test_fn.name)) {
-                            break :index i;
-                        }
-                    } else {
-                        std.debug.panic("fuzz test {s} no longer exists", .{name});
-                    }
+                var gpa_instance: std.heap.DebugAllocator(.{}) = .init;
+                defer if (gpa_instance.deinit() == .leak) {
+                    @panic("internal test runner memory leak");
+                };
+                const gpa = gpa_instance.allocator();
+                var io_instance: Io.Threaded = .init(gpa, .{
+                    .argv0 = .init(init.args),
+                    .environ = init.environ,
                 });
+                defer io_instance.deinit();
+                const io = io_instance.io();
+
                 const mode: fuzz_abi.LimitKind = @enumFromInt(try server.receiveBody_u8());
                 const amount_or_instance = try server.receiveBody_u64();
+                const main_instance = mode == .iterations or amount_or_instance == 0;
+
+                if (main_instance) {
+                    const coverage = fuzz_abi.fuzzer_coverage();
+                    try server.serveCoverageIdMessage(
+                        coverage.id,
+                        coverage.runs,
+                        coverage.unique,
+                        coverage.seen,
+                    );
+                }
 
-                const test_fn = builtin.test_functions[index];
-                const entry_addr = @intFromPtr(test_fn.func);
+                const n_tests: u32 = try server.receiveBody_u32();
+                const test_indexes = try gpa.alloc(u32, n_tests);
+                defer gpa.free(test_indexes);
+                fuzz_runner = .{
+                    .indexes = test_indexes,
+                    .server = &server,
+                    .gpa = gpa,
+                    .io = io,
+                    .input_poller = undefined,
+                };
 
-                try server.serveU64Message(.fuzz_start_addr, fuzz_abi.fuzzer_unslide_address(entry_addr));
-                defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
-                is_fuzz_test = false;
-                fuzz_test_index = index;
-                fuzz_mode = mode;
-                fuzz_amount_or_instance = amount_or_instance;
+                {
+                    var large_name_buf: std.ArrayList(u8) = .empty;
+                    defer large_name_buf.deinit(gpa);
+                    for (test_indexes) |*i| {
+                        const name_len = try server.receiveBody_u32();
+                        const name = if (name_len <= server.in.buffer.len)
+                            try server.in.take(name_len)
+                        else large_name: {
+                            try large_name_buf.resize(gpa, name_len);
+                            try server.in.readSliceAll(large_name_buf.items);
+                            break :large_name large_name_buf.items;
+                        };
+
+                        for (0.., builtin.test_functions) |test_i, test_fn| {
+                            if (std.mem.eql(u8, name, test_fn.name)) {
+                                i.* = @intCast(test_i);
+                                break;
+                            }
+                        } else {
+                            panic("fuzz test {s} no longer exists", .{name});
+                        }
 
-                test_fn.func() catch |err| switch (err) {
-                    error.SkipZigTest => return,
-                    else => {
-                        if (@errorReturnTrace()) |trace| {
-                            std.debug.dumpStackTrace(trace);
+                        if (main_instance) {
+                            const relocated_entry_addr = @intFromPtr(builtin.test_functions[i.*].func);
+                            const entry_addr = fuzz_abi.fuzzer_unslide_address(relocated_entry_addr);
+                            try server.serveU64Message(.fuzz_start_addr, entry_addr);
                         }
-                        std.debug.print("failed with error.{t}\n", .{err});
-                        std.process.exit(1);
-                    },
-                };
-                if (!is_fuzz_test) @panic("missed call to std.testing.fuzz");
-                if (log_err_count != 0) @panic("error logs detected");
+                    }
+                }
+
+                fuzz_abi.fuzzer_main(n_tests, testing.random_seed, mode, amount_or_instance);
+
                 assert(mode != .forever);
                 std.process.exit(0);
             },
@@ -292,7 +312,7 @@ fn mainTerminal(init: std.process.Init.Minimal) void {
                     std.debug.print("FAIL ({t})\n", .{err});
                 }
                 if (@errorReturnTrace()) |trace| {
-                    std.debug.dumpStackTrace(trace);
+                    std.debug.dumpErrorReturnTrace(trace);
                 }
                 test_node.end();
             },
@@ -382,16 +402,126 @@ pub fn mainSimple() anyerror!void {
         passed += 1;
     }
     if (enable_print) {
-        var stdout_writer = stdout.writer(runner_threaded_io, &.{});
-        stdout_writer.interface.print("{} passed, {} skipped, {} failed\n", .{ passed, skipped, failed }) catch {};
+        var unbuffered_stdout_writer = stdout.writer(runner_threaded_io, &.{});
+        unbuffered_stdout_writer.interface.print(
+            "{} passed, {} skipped, {} failed\n",
+            .{ passed, skipped, failed },
+        ) catch {};
     }
     if (failed != 0) std.process.exit(1);
 }
 
 var is_fuzz_test: bool = undefined;
-var fuzz_test_index: u32 = undefined;
-var fuzz_mode: fuzz_abi.LimitKind = undefined;
-var fuzz_amount_or_instance: u64 = undefined;
+var fuzz_runner: if (builtin.fuzz) struct {
+    indexes: []u32,
+    server: *std.zig.Server,
+    gpa: std.mem.Allocator,
+    io: Io,
+    input_poller: Io.Future(Io.Cancelable!void),
+
+    comptime {
+        assert(builtin.fuzz); // `fuzz_runner` was analyzed in non-fuzzing compilation
+    }
+
+    export fn runner_test_run(i: u32) void {
+        @disableInstrumentation();
+
+        fuzz_runner.server.serveU32Message(.fuzz_test_change, i) catch |e| switch (e) {
+            error.WriteFailed => panic("failed to write to stdout: {t}", .{stdout_writer.err.?}),
+        };
+
+        testing.allocator_instance = .{};
+        defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
+        is_fuzz_test = false;
+
+        builtin.test_functions[fuzz_runner.indexes[i]].func() catch |err| switch (err) {
+            error.SkipZigTest => return,
+            else => {
+                if (@errorReturnTrace()) |trace| {
+                    std.debug.dumpErrorReturnTrace(trace);
+                }
+                std.debug.print("failed with error.{t}\n", .{err});
+                std.process.exit(1);
+            },
+        };
+
+        if (!is_fuzz_test) @panic("missed call to std.testing.fuzz");
+        if (log_err_count != 0) @panic("error logs detected");
+    }
+
+    export fn runner_test_name(i: u32) fuzz_abi.Slice {
+        @disableInstrumentation();
+        return .fromSlice(builtin.test_functions[fuzz_runner.indexes[i]].name);
+    }
+
+    export fn runner_broadcast_input(test_i: u32, bytes_slice: fuzz_abi.Slice) void {
+        @disableInstrumentation();
+        const bytes = bytes_slice.toSlice();
+        fuzz_runner.server.serveBroadcastFuzzInputMessage(test_i, bytes) catch |e| switch (e) {
+            error.WriteFailed => panic("failed to write to stdout: {t}", .{stdout_writer.err.?}),
+        };
+    }
+
+    export fn runner_start_input_poller() void {
+        @disableInstrumentation();
+        const future = fuzz_runner.io.concurrent(inputPoller, .{}) catch |e| switch (e) {
+            error.ConcurrencyUnavailable => @panic("failed to spawn concurrent fuzz input poller"),
+        };
+        fuzz_runner.input_poller = future;
+    }
+
+    export fn runner_stop_input_poller() void {
+        @disableInstrumentation();
+        assert(fuzz_runner.input_poller.cancel(fuzz_runner.io) == error.Canceled);
+    }
+
+    export fn runner_futex_wait(ptr: *const u32, expected: u32) bool {
+        @disableInstrumentation();
+        return fuzz_runner.io.futexWait(u32, ptr, expected) == error.Canceled;
+    }
+
+    export fn runner_futex_wake(ptr: *const u32, waiters: u32) void {
+        @disableInstrumentation();
+        fuzz_runner.io.futexWake(u32, ptr, waiters);
+    }
+
+    fn inputPoller() Io.Cancelable!void {
+        @disableInstrumentation();
+        switch (inputPollerInner()) {
+            error.Canceled => return error.Canceled,
+            error.ReadFailed => {
+                if (stdin_reader.err.? == error.Canceled) return error.Canceled;
+                panic("failed to read from stdin: {t}", .{stdin_reader.err.?});
+            },
+            error.EndOfStream => @panic("unexpected end of stdin"),
+        }
+    }
+
+    fn inputPollerInner() (Io.Cancelable || Io.Reader.Error) {
+        @disableInstrumentation();
+        const server = fuzz_runner.server;
+        var large_bytes_list: std.ArrayList(u8) = .empty;
+        defer large_bytes_list.deinit(fuzz_runner.gpa);
+        while (true) {
+            const hdr = try server.receiveMessage();
+            if (hdr.tag != .new_fuzz_input) {
+                panic("unexpected message: {x}\n", .{@intFromEnum(hdr.tag)});
+            }
+            const test_i = try server.receiveBody_u32();
+            const input_len = hdr.bytes_len - 4;
+            const bytes = if (input_len <= server.in.buffer.len)
+                try server.in.take(input_len)
+            else bytes: {
+                large_bytes_list.resize(fuzz_runner.gpa, @intCast(input_len)) catch @panic("OOM");
+                try server.in.readSliceAll(large_bytes_list.items);
+                break :bytes large_bytes_list.items;
+            };
+            if (fuzz_abi.fuzzer_receive_input(test_i, .fromSlice(bytes))) {
+                return error.Canceled;
+            }
+        }
+    }
+} else void = undefined;
 
 pub fn fuzz(
     context: anytype,
@@ -448,16 +578,18 @@ pub fn fuzz(
             return false;
         }
     };
+
     if (builtin.fuzz) {
+        // Preserve the calling test's allocator state
         const prev_allocator_state = testing.allocator_instance;
         testing.allocator_instance = .{};
         defer testing.allocator_instance = prev_allocator_state;
-        global.ctx = context;
 
-        fuzz_abi.fuzzer_set_test(&global.test_one, .fromSlice(builtin.test_functions[fuzz_test_index].name));
+        global.ctx = context;
+        fuzz_abi.fuzzer_set_test(&global.test_one);
         for (options.corpus) |elem|
             fuzz_abi.fuzzer_new_input(.fromSlice(elem));
-        fuzz_abi.fuzzer_main(fuzz_mode, fuzz_amount_or_instance);
+        fuzz_abi.fuzzer_start_test();
         return;
     }
 

package/compiler/translate-c/MacroTranslator.zig

@@ -266,7 +266,8 @@ fn parseCNumLit(mt: *MacroTranslator) ParseError!ZigNode {
     const lit_bytes = mt.tokSlice();
     mt.i += 1;
 
-    var bytes = try std.ArrayList(u8).initCapacity(arena, lit_bytes.len + 3);
+    // +3 for prefix and +2 for suffix
+    var bytes = try std.ArrayList(u8).initCapacity(arena, lit_bytes.len + 3 + 2);
 
     const prefix = aro.Tree.Token.NumberPrefix.fromString(lit_bytes);
     switch (prefix) {
@@ -350,13 +351,21 @@ fn parseCNumLit(mt: *MacroTranslator) ParseError!ZigNode {
     if (is_float) {
         const type_node = try ZigTag.type.create(arena, switch (suffix) {
             .F16 => "f16",
-            .F => "f32",
-            .None => "f64",
-            .L => "c_longdouble",
+            .F, .F32 => "f32",
+            .None, .F32x, .F64 => "f64",
+            .L, .F64x => "c_longdouble",
             .W => "f80",
             .Q, .F128 => "f128",
-            else => unreachable,
+            else => {
+                try mt.fail("TODO: float literal suffix: '{s}'", .{suffix_str});
+                return error.ParseError;
+            },
         });
+        if (bytes.getLast() == '.') {
+            bytes.appendAssumeCapacity('0');
+        } else if (mem.findAny(u8, bytes.items, ".eEpP") == null) {
+            bytes.appendSliceAssumeCapacity(".0");
+        }
         const rhs = try ZigTag.float_literal.create(arena, bytes.items);
         return ZigTag.as.create(arena, .{ .lhs = type_node, .rhs = rhs });
     } else {
@@ -582,6 +591,7 @@ fn escapeUnprintables(mt: *MacroTranslator) ![]const u8 {
 
 fn parseCPrimaryExpr(mt: *MacroTranslator, scope: *Scope) ParseError!ZigNode {
     const arena = mt.t.arena;
+    const gpa = mt.t.gpa;
     const tok = mt.peek();
     switch (tok) {
         .char_literal,
@@ -646,6 +656,51 @@ fn parseCPrimaryExpr(mt: *MacroTranslator, scope: *Scope) ParseError!ZigNode {
             }
             return identifier;
         },
+        .keyword_generic => {
+            mt.i += 1;
+
+            try mt.expect(.l_paren);
+            const param = try mt.parseCCondExpr(scope);
+            const typeof_param = try ZigTag.typeof.create(arena, param);
+            try mt.expect(.comma);
+
+            var cases: std.ArrayList(ZigNode) = .empty;
+            defer cases.deinit(gpa);
+            var has_default = false;
+            while (true) {
+                const case = if (mt.eat(.keyword_default)) blk: {
+                    has_default = true;
+                    try mt.expect(.colon);
+                    const expr = try mt.parseCCondExpr(scope);
+                    break :blk try ZigTag.switch_else.create(arena, expr);
+                } else blk: {
+                    const case_type = try mt.parseCTypeName(scope) orelse {
+                        try mt.fail("unable to translate C expr: expected type instead got '{s}'", .{mt.peek().symbol()});
+                        return error.ParseError;
+                    };
+                    try mt.expect(.colon);
+                    const expr = try mt.parseCCondExpr(scope);
+                    break :blk try ZigTag.switch_prong.create(arena, .{
+                        .cases = try arena.dupe(ZigNode, &.{case_type}),
+                        .cond = expr,
+                    });
+                };
+                try cases.append(gpa, case);
+                if (!mt.eat(.comma)) break;
+            }
+            try mt.expect(.r_paren);
+
+            if (!has_default) try cases.append(gpa, try ZigTag.switch_else.create(
+                arena,
+                try ZigTag.@"comptime".create(arena, ZigTag.@"unreachable".init()),
+            ));
+
+            const sw = try ZigTag.@"switch".create(arena, .{
+                .cond = typeof_param,
+                .cases = try arena.dupe(ZigNode, cases.items),
+            });
+            return sw;
+        },
         else => {},
     }
 
@@ -678,8 +733,10 @@ fn macroIntToBool(mt: *MacroTranslator, node: ZigNode) !ZigNode {
 }
 
 fn parseCCondExpr(mt: *MacroTranslator, scope: *Scope) ParseError!ZigNode {
-    const node = try mt.parseCOrExpr(scope);
-    if (!mt.eat(.question_mark)) return node;
+    const condition = try mt.parseCOrExpr(scope);
+    if (!mt.eat(.question_mark)) return condition;
+    const bool_ty = try ZigTag.type.create(mt.t.arena, "bool");
+    const node = try mt.t.createHelperCallNode(.cast, &.{ bool_ty, condition });
 
     const then_body = try mt.parseCOrExpr(scope);
     try mt.expect(.colon);
@@ -1135,6 +1192,8 @@ fn parseCPostfixExpr(mt: *MacroTranslator, scope: *Scope, type_name: ?ZigNode) P
             .string_literal_utf_8,
             .string_literal_utf_32,
             .string_literal_wide,
+            .macro_param,
+            .macro_param_no_expand,
             => {},
             .identifier, .extended_identifier => {
                 if (mt.t.global_scope.blank_macros.contains(mt.tokSlice())) {
@@ -1160,8 +1219,13 @@ fn parseCPostfixExprInner(mt: *MacroTranslator, scope: *Scope, type_name: ?ZigNo
                 mt.i += 1;
                 const tok = mt.tokens[mt.i];
                 if (tok.id == .macro_param or tok.id == .macro_param_no_expand) {
-                    try mt.fail("unable to translate C expr: field access using macro parameter", .{});
-                    return error.ParseError;
+                    const param = mt.macro.params[tok.end];
+                    mt.i += 1;
+
+                    const mangled_name = scope.getAlias(param) orelse param;
+                    const field_name = try ZigTag.identifier.create(arena, mangled_name);
+                    node = try ZigTag.field_builtin.create(arena, .{ .lhs = node, .rhs = field_name });
+                    continue;
                 }
                 const field_name = mt.tokSlice();
                 try mt.expect(.identifier);
@@ -1172,8 +1236,13 @@ fn parseCPostfixExprInner(mt: *MacroTranslator, scope: *Scope, type_name: ?ZigNo
                 mt.i += 1;
                 const tok = mt.tokens[mt.i];
                 if (tok.id == .macro_param or tok.id == .macro_param_no_expand) {
-                    try mt.fail("unable to translate C expr: field access using macro parameter", .{});
-                    return error.ParseError;
+                    const param = mt.macro.params[tok.end];
+                    mt.i += 1;
+
+                    const mangled_name = scope.getAlias(param) orelse param;
+                    const field_name = try ZigTag.identifier.create(arena, mangled_name);
+                    node = try ZigTag.field_builtin.create(arena, .{ .lhs = node, .rhs = field_name });
+                    continue;
                 }
                 const field_name = mt.tokSlice();
                 try mt.expect(.identifier);

package/compiler/translate-c/PatternList.zig

@@ -65,10 +65,7 @@ const templates = [_]Template{
     .{ "CAST_OR_CALL(X, Y) ((X)(Y))", .CAST_OR_CALL },
 
     .{
-        \\wl_container_of(ptr, sample, member)                     \
-        \\(__typeof__(sample))((char *)(ptr) -                     \
-        \\     offsetof(__typeof__(*sample), member))
-        ,
+        "wl_container_of(ptr, sample, member) (__typeof__(sample))((char *)(ptr) - offsetof(__typeof__(*sample), member))",
         .WL_CONTAINER_OF,
     },
 
@@ -267,11 +264,6 @@ test "Macro matching" {
     try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## LL)", .LL_SUFFIX);
     try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## UL)", .UL_SUFFIX);
     try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## ULL)", .ULL_SUFFIX);
-    try helper.checkMacro(allocator, pattern_list,
-        \\container_of(a, b, c)                             \
-        \\(__typeof__(b))((char *)(a) -                     \
-        \\     offsetof(__typeof__(*b), c))
-    , .WL_CONTAINER_OF);
 
     try helper.checkMacro(allocator, pattern_list, "NO_MATCH(X, Y) (X + Y)", null);
     try helper.checkMacro(allocator, pattern_list, "CAST_OR_CALL(X, Y) (X)(Y)", .CAST_OR_CALL);

package/compiler/translate-c/Scope.zig

@@ -18,7 +18,22 @@ pub const ContainerMemberFns = struct {
     container_decl_ptr: *ast.Node,
     member_fns: std.ArrayList(*ast.Payload.Func) = .empty,
 };
-pub const ContainerMemberFnsHashMap = std.AutoArrayHashMapUnmanaged(aro.QualType, ContainerMemberFns);
+pub const ContainerMemberFnsHashMap = std.ArrayHashMapUnmanaged(
+    aro.QualType,
+    ContainerMemberFns,
+    struct {
+        pub fn hash(self: @This(), key: aro.QualType) u32 {
+            const auto_hash = std.array_hash_map.getAutoHashFn(aro.QualType, @This());
+            return auto_hash(self, key.unqualified());
+        }
+
+        pub fn eql(self: @This(), a: aro.QualType, b: aro.QualType, b_index: usize) bool {
+            const auto_eql = std.array_hash_map.getAutoEqlFn(aro.QualType, @This());
+            return auto_eql(self, a.unqualified(), b.unqualified(), b_index);
+        }
+    },
+    false,
+);
 
 id: Id,
 parent: ?*Scope,
@@ -254,7 +269,12 @@ pub const Root = struct {
 
         var member_names: std.StringArrayHashMapUnmanaged(void) = .empty;
         defer member_names.deinit(gpa);
-        for (root.container_member_fns_map.values()) |members| {
+        for (root.container_member_fns_map.keys(), root.container_member_fns_map.values()) |container_qt, members| {
+            // Get the container name
+            const container_name = root.translator.unnamed_typedefs.get(container_qt) orelse
+                container_qt.getRecord(root.translator.comp).?.name.lookup(root.translator.comp);
+            std.debug.assert(container_name.len > 0);
+
             member_names.clearRetainingCapacity();
             const decls_ptr = switch (members.container_decl_ptr.tag()) {
                 .@"struct", .@"union" => blk_record: {
@@ -274,7 +294,7 @@ pub const Root = struct {
                     members.container_decl_ptr.* = container_decl;
                     break :blk_opaque &container_decl.castTag(.@"opaque").?.data.decls;
                 },
-                else => return,
+                else => continue,
             };
 
             const old_decls = decls_ptr.*;
@@ -299,9 +319,26 @@ pub const Root = struct {
 
             for (members.member_fns.items) |func| {
                 const func_name = func.data.name.?;
-                const func_name_trimmed = std.mem.trimEnd(u8, func_name, "_");
-                const last_idx = std.mem.findLast(u8, func_name_trimmed, "_") orelse continue;
-                const func_name_alias = func_name[last_idx + 1 ..];
+                const func_name_alias = blk: {
+                    // Try multiple candidate prefixes to extract the alias
+                    // 1. typedef struct { ... } foo; -> foo_get_bar() extracts "get_bar"
+                    // 2. typedef struct _foo foo; -> foo_get_bar() extracts "get_bar"
+                    const container_name_trimmed = std.mem.trimStart(u8, container_name, "_");
+                    const suffix = std.mem.cutPrefix(u8, func_name, container_name_trimmed);
+                    // Check suffix starts with '_' to avoid invalid aliases like "1_get_bar" from foo1_get_bar()
+                    if (suffix) |alias| if (alias.len > 0 and alias[0] == '_') {
+                        const alias_trimmed = std.mem.trimStart(u8, alias, "_");
+                        if (alias_trimmed.len > 0) break :blk alias_trimmed;
+                    };
+
+                    // Doesn't match any prefix - fallback to trimming trailing underscores and using last segment
+                    const func_name_trimmed = std.mem.trimEnd(u8, func_name, "_");
+                    const last_idx = std.mem.findLast(u8, func_name_trimmed, "_") orelse continue;
+                    break :blk func_name[last_idx + 1 ..];
+                };
+
+                // Skip if the alias conflicts with an existing type
+                if (root.contains(func_name_alias)) continue;
                 const member_name_slot = try member_names.getOrPutValue(gpa, func_name_alias, {});
                 if (member_name_slot.found_existing) continue;
                 func_ref_vars[count] = try ast.Node.Tag.pub_var_simple.create(arena, .{