@zigc/lib 0.17.0-dev.56 → 0.17.0-dev.607

package/std/zig/AstRlAnnotate.zig

@@ -141,11 +141,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI
         .asm_input,
         => unreachable,
 
-        .@"errdefer" => {
-            _ = try astrl.expr(tree.nodeData(node).opt_token_and_node[1], block, ResultInfo.none);
-            return false;
-        },
-        .@"defer" => {
+        .@"defer", .@"errdefer" => {
             _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none);
             return false;
         },
@@ -273,12 +269,6 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI
             return false;
         },
 
-        .array_mult => {
-            const lhs, const rhs = tree.nodeData(node).node_and_node;
-            _ = try astrl.expr(lhs, block, ResultInfo.none);
-            _ = try astrl.expr(rhs, block, ResultInfo.type_only);
-            return false;
-        },
         .error_union, .merge_error_sets => {
             const lhs, const rhs = tree.nodeData(node).node_and_node;
             _ = try astrl.expr(lhs, block, ResultInfo.none);

package/std/zig/AstSmith.zig

@@ -18,7 +18,6 @@ token_tag_buf: [2048]Token.Tag,
 token_start_buf: [2048]std.zig.Ast.ByteOffset,
 tokens_len: usize,
 
-/// For `.asterisk`, this also includes `.asterisk2`
 not_token: ?Token.Tag,
 not_token_comptime: bool,
 /// ExprSuffix
@@ -196,7 +195,6 @@ fn preservePegEndOfWord(a: *AstSmith) SourceError!void {
 /// Assumes the token has not been written yet
 fn addTokenTag(a: *AstSmith, tag: Token.Tag) SourceError!void {
     assert(tag != a.not_token);
-    if (a.not_token == .asterisk) assert(tag != .asterisk_asterisk);
     a.not_token = null;
 
     if (a.not_token_comptime) assert(tag != .keyword_comptime);
@@ -240,9 +238,7 @@ fn pegToken(a: *AstSmith, tag: Token.Tag) SourceError!void {
 
     switch (lexeme[0]) {
         '_', 'a'...'z', 'A'...'Z', '0'...'9' => try a.preservePegEndOfWord(),
-        '*' => if (a.tokens_len > 0 and a.source_buf[a.source_len - 1] == '*' and
-            a.token_tag_buf[a.tokens_len - 1] != .asterisk_asterisk)
-        {
+        '*' => if (a.tokens_len > 0 and a.source_buf[a.source_len - 1] == '*') {
             try a.addSourceByte(' ');
         },
         '.' => if (a.tokens_len > 0 and switch (a.source_buf[a.source_len - 1]) {
@@ -486,7 +482,7 @@ fn pegContainerField(a: *AstSmith) SourceError!void {
 /// BlockStatement
 ///     <- Statement
 ///      / KEYWORD_defer BlockExprStatement
-///      / KEYWORD_errdefer Payload? BlockExprStatement
+///      / KEYWORD_errdefer BlockExprStatement
 ///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? VarAssignStatement
 fn pegBlockStatement(a: *AstSmith) SourceError!void {
     const Kind = enum {
@@ -1723,13 +1719,11 @@ fn pegAdditionOp(a: *AstSmith) SourceError!void {
 ///      / ASTERISK
 ///      / SLASH
 ///      / PERCENT
-///      / ASTERISK2
 ///      / ASTERISKPERCENT
 ///      / ASTERISKPIPE
 fn pegMultiplyOp(a: *AstSmith) SourceError!void {
     const tags = [_]Token.Tag{
         .asterisk,
-        .asterisk_asterisk,
         .pipe_pipe,
         .slash,
         .percent,
@@ -1865,9 +1859,9 @@ fn pegSliceTypeStart(a: *AstSmith) SourceError!void {
     try a.pegToken(.r_bracket);
 }
 
-/// SinglePtrTypeStart <- ASTERISK / ASTERISK2
+/// SinglePtrTypeStart <- ASTERISK
 fn pegSinglePtrTypeStart(a: *AstSmith) SourceError!void {
-    try a.pegToken(if (!a.smith.value(bool)) .asterisk else .asterisk_asterisk);
+    try a.pegToken(.asterisk);
 }
 
 /// ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
@@ -1889,7 +1883,7 @@ fn pegManyPtrTypeStart(a: *AstSmith) SourceError!void {
     try a.pegToken(.r_bracket);
 }
 
-/// ArrayTypeStart <- LBRACKET !(ASTERISK / ASTERISK2) Expr (COLON Expr)? RBRACKET
+/// ArrayTypeStart <- LBRACKET !ASTERISK Expr (COLON Expr)? RBRACKET
 fn pegArrayTypeStart(a: *AstSmith) SourceError!void {
     try a.pegToken(.l_bracket);
     a.not_token = .asterisk;

package/std/zig/ErrorBundle.zig

@@ -397,9 +397,13 @@ pub const Wip = struct {
         });
         try wip.extra.appendSlice(gpa, @as([]const u32, @ptrCast(wip.root_list.items)));
         wip.root_list.clearAndFree(gpa);
+
+        try wip.string_bytes.shrinkToLen(gpa);
+        try wip.extra.shrinkToLen(gpa);
+
         return .{
-            .string_bytes = try wip.string_bytes.toOwnedSlice(gpa),
-            .extra = try wip.extra.toOwnedSlice(gpa),
+            .string_bytes = wip.string_bytes.toOwnedSliceAssert(),
+            .extra = wip.extra.toOwnedSliceAssert(),
         };
     }
 

package/std/zig/LibCDirs.zig

@@ -132,14 +132,20 @@ fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *con
     }
     if (target.os.tag == .haiku) {
         const include_dir_path = lci.include_dir.?;
-        const os_dir = try std.fs.path.join(arena, &[_][]const u8{ include_dir_path, "os" });
-        list.appendAssumeCapacity(os_dir);
-        // Errors.h
-        const os_support_dir = try std.fs.path.join(arena, &[_][]const u8{ include_dir_path, "os/support" });
-        list.appendAssumeCapacity(os_support_dir);
 
-        const config_dir = try std.fs.path.join(arena, &[_][]const u8{ include_dir_path, "config" });
-        list.appendAssumeCapacity(config_dir);
+        const subdirs = &[_][]const u8{
+            "os",                   "os/app",                  "os/device",               "os/drivers",
+            "os/game",              "os/interface",            "os/kernel",               "os/locale",
+            "os/mail",              "os/media",                "os/midi",                 "os/midi2",
+            "os/net",               "os/opengl",               "os/storage",              "os/support",
+            "os/translation",       "os/add-ons/graphics",     "os/add-ons/input_server", "os/add-ons/mail_daemon",
+            "os/add-ons/registrar", "os/add-ons/screen_saver", "os/add-ons/tracker",      "os/be_apps/NetPositive",
+            "os/be_apps/Tracker",   "bsd",                     "glibc",                   "gnu",
+        };
+        for (subdirs) |subdir| {
+            const path = try std.fs.path.join(arena, &[_][]const u8{ include_dir_path, subdir });
+            try list.append(path);
+        }
     }
 
     var sysroot: ?[]const u8 = null;
@@ -282,6 +288,7 @@ fn libCGenericName(target: *const std.Target) [:0]const u8 {
         .msvc,
         .itanium,
         .simulator,
+        .call0,
         => unreachable,
     }
 }

package/std/zig/LibCInstallation.zig

@@ -5,6 +5,7 @@ const builtin = @import("builtin");
 const is_darwin = builtin.target.os.tag.isDarwin();
 const is_windows = builtin.target.os.tag == .windows;
 const is_haiku = builtin.target.os.tag == .haiku;
+const is_serenity = builtin.target.os.tag == .serenity;
 
 const std = @import("std");
 const Io = std.Io;
@@ -12,6 +13,7 @@ const Target = std.Target;
 const fs = std.fs;
 const Allocator = std.mem.Allocator;
 const Path = std.Build.Cache.Path;
+const Cache = std.Build.Cache;
 const log = std.log.scoped(.libc_installation);
 const Environ = std.process.Environ;
 
@@ -46,7 +48,7 @@ pub fn parse(allocator: Allocator, io: Io, libc_file: []const u8, target: *const
         found: bool,
         allocated: ?[:0]u8,
     };
-    var found_keys = [1]FoundKey{FoundKey{ .found = false, .allocated = null }} ** fields.len;
+    var found_keys: [fields.len]FoundKey = @splat(.{ .found = false, .allocated = null });
     errdefer {
         self = .{};
         for (found_keys) |found_key| {
@@ -69,7 +71,7 @@ pub fn parse(allocator: Allocator, io: Io, libc_file: []const u8, target: *const
                 if (value.len == 0) {
                     @field(self, field.name) = null;
                 } else {
-                    found_keys[i].allocated = try allocator.dupeZ(u8, value);
+                    found_keys[i].allocated = try allocator.dupeSentinel(u8, value, 0);
                     @field(self, field.name) = found_keys[i].allocated;
                 }
                 break;
@@ -112,7 +114,7 @@ pub fn parse(allocator: Allocator, io: Io, libc_file: []const u8, target: *const
         return error.ParseError;
     }
 
-    if (self.gcc_dir == null and os_tag == .haiku) {
+    if (self.gcc_dir == null and (os_tag == .haiku or os_tag == .serenity)) {
         log.err("gcc_dir may not be empty for {s}", .{@tagName(os_tag)});
         return error.ParseError;
     }
@@ -196,7 +198,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);
 
@@ -207,8 +209,12 @@ pub fn findNative(gpa: Allocator, io: Io, args: FindNativeOptions) FindError!Lib
         try self.findNativeCrtDirWindows(gpa, io, args.target, sdk);
     } else if (is_haiku) {
         try self.findNativeIncludeDirPosix(gpa, io, args);
-        try self.findNativeGccDirHaiku(gpa, io, args);
+        try self.findNativeGccDirPosix(gpa, io, args);
         self.crt_dir = try gpa.dupe(u8, "/system/develop/lib");
+    } else if (is_serenity) {
+        try self.findNativeIncludeDirPosix(gpa, io, args);
+        try self.findNativeGccDirPosix(gpa, io, args);
+        self.crt_dir = try gpa.dupe(u8, "/usr/lib");
     } else if (builtin.target.os.tag == .illumos) {
         // There is only one libc, and its headers/libraries are always in the same spot.
         self.include_dir = try gpa.dupe(u8, "/usr/include");
@@ -278,7 +284,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;
@@ -314,7 +320,7 @@ fn findNativeIncludeDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, ar
     const include_dir_example_file = if (is_haiku) "posix/stdlib.h" else "stdlib.h";
     const sys_include_dir_example_file = if (is_windows)
         "sys\\types.h"
-    else if (is_haiku)
+    else if (is_haiku or is_serenity)
         "errno.h"
     else
         "sys/errno.h";
@@ -457,7 +463,7 @@ fn findNativeCrtDirPosix(self: *LibCInstallation, gpa: Allocator, io: Io, args:
     });
 }
 
-fn findNativeGccDirHaiku(self: *LibCInstallation, gpa: Allocator, io: Io, args: FindNativeOptions) FindError!void {
+fn findNativeGccDirPosix(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",
@@ -596,7 +602,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 {
@@ -703,8 +709,8 @@ pub const CrtBasenames = struct {
     pub const GetArgs = struct {
         target: *const std.Target,
         link_libc: bool,
-        output_mode: std.builtin.OutputMode,
-        link_mode: std.builtin.LinkMode,
+        output_mode: std.lang.OutputMode,
+        link_mode: std.lang.LinkMode,
         pie: bool,
     };
 
@@ -949,6 +955,22 @@ pub const CrtBasenames = struct {
                 },
                 .static_exe, .static_pie => .{},
             },
+            .serenity => switch (mode) {
+                .dynamic_lib => .{
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                },
+                .dynamic_exe, .static_exe => .{
+                    .crt0 = "crt0.o",
+                    .crtbegin = "crtbegin.o",
+                    .crtend = "crtend.o",
+                },
+                .dynamic_pie, .static_pie => .{
+                    .crt0 = "crt0.o",
+                    .crtbegin = "crtbeginS.o",
+                    .crtend = "crtendS.o",
+                },
+            },
             else => .{},
         };
     }
@@ -969,7 +991,7 @@ pub fn resolveCrtPaths(
     target: *const std.Target,
 ) error{ OutOfMemory, LibCInstallationMissingCrtDir }!CrtPaths {
     const crt_dir_path: Path = .{
-        .root_dir = std.Build.Cache.Directory.cwd(),
+        .root_dir = Cache.Directory.cwd(),
         .sub_path = lci.crt_dir orelse return error.LibCInstallationMissingCrtDir,
     };
     switch (target.os.tag) {
@@ -993,9 +1015,9 @@ pub fn resolveCrtPaths(
                 .crtn = if (crt_basenames.crtn) |basename| try crt_dir_path.join(arena, basename) else null,
             };
         },
-        .haiku => {
+        .haiku, .serenity => {
             const gcc_dir_path: Path = .{
-                .root_dir = std.Build.Cache.Directory.cwd(),
+                .root_dir = Cache.Directory.cwd(),
                 .sub_path = lci.gcc_dir orelse return error.LibCInstallationMissingCrtDir,
             };
             return .{
@@ -1017,3 +1039,16 @@ pub fn resolveCrtPaths(
         },
     }
 }
+
+pub fn addToHash(opt_lci: ?*const LibCInstallation, hh: *Cache.HashHelper, abi: std.Target.Abi) void {
+    const lci = opt_lci orelse return hh.add(false);
+    hh.add(true);
+    hh.addOptionalBytes(lci.crt_dir);
+    switch (abi) {
+        .msvc, .itanium => {
+            hh.addOptionalBytes(lci.msvc_lib_dir);
+            hh.addOptionalBytes(lci.kernel32_lib_dir);
+        },
+        else => {},
+    }
+}

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;
@@ -909,7 +909,7 @@ fn expectContainerField(p: *Parse) !Node.Index {
 /// BlockStatement
 ///     <- Statement
 ///      / KEYWORD_defer BlockExprStatement
-///      / KEYWORD_errdefer Payload? BlockExprStatement
+///      / KEYWORD_errdefer BlockExprStatement
 ///      / !ExprStatement (KEYWORD_comptime !BlockExpr)? VarAssignStatement
 ///
 /// Statement
@@ -975,10 +975,7 @@ fn expectStatement(p: *Parse, is_block_level: bool) Error!Node.Index {
         .keyword_errdefer => if (is_block_level) return p.addNode(.{
             .tag = .@"errdefer",
             .main_token = p.nextToken(),
-            .data = .{ .opt_token_and_node = .{
-                try p.parsePayload(),
-                try p.expectBlockExprStatement(),
-            } },
+            .data = .{ .node = try p.expectBlockExprStatement() },
         }),
         .keyword_if => return p.expectIfStatement(),
         .keyword_enum, .keyword_struct, .keyword_union => {
@@ -1145,7 +1142,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)) {
@@ -1612,7 +1609,6 @@ const operTable = std.enums.directEnumArrayDefault(Token.Tag, OperInfo, .{ .prec
     .asterisk = .{ .prec = 70, .tag = .mul },
     .slash = .{ .prec = 70, .tag = .div },
     .percent = .{ .prec = 70, .tag = .mod },
-    .asterisk_asterisk = .{ .prec = 70, .tag = .array_mult },
     .asterisk_percent = .{ .prec = 70, .tag = .mul_wrap },
     .asterisk_pipe = .{ .prec = 70, .tag = .mul_sat },
 });
@@ -1712,11 +1708,11 @@ fn expectPrefixExpr(p: *Parse) Error!Node.Index {
 ///
 /// SliceTypeStart <- LBRACKET (COLON Expr)? RBRACKET
 ///
-/// SinglePtrTypeStart <- ASTERISK / ASTERISK2
+/// SinglePtrTypeStart <- ASTERISK
 ///
 /// ManyPtrTypeStart <- LBRACKET ASTERISK (LETTERC / COLON Expr)? RBRACKET
 ///
-/// ArrayTypeStart <- LBRACKET Expr !(ASTERISK / ASTERISK2) (COLON Expr)? RBRACKET
+/// ArrayTypeStart <- LBRACKET Expr !ASTERISK (COLON Expr)? RBRACKET
 ///
 /// BitAlign <- KEYWORD_align LPAREN Expr (COLON Expr COLON Expr)? RPAREN
 fn parseTypeExpr(p: *Parse) Error!?Node.Index {
@@ -1780,59 +1776,6 @@ fn parseTypeExpr(p: *Parse) Error!?Node.Index {
                 });
             }
         },
-        .asterisk_asterisk => {
-            const asterisk = p.nextToken();
-            const mods = try p.parsePtrModifiers();
-            const elem_type = try p.expectTypeExpr();
-            const inner: Node.Index = inner: {
-                if (mods.bit_range_start != .none) {
-                    break :inner try p.addNode(.{
-                        .tag = .ptr_type_bit_range,
-                        .main_token = asterisk,
-                        .data = .{ .extra_and_node = .{
-                            try p.addExtra(Node.PtrTypeBitRange{
-                                .sentinel = .none,
-                                .align_node = mods.align_node.unwrap().?,
-                                .addrspace_node = mods.addrspace_node,
-                                .bit_range_start = mods.bit_range_start.unwrap().?,
-                                .bit_range_end = mods.bit_range_end.unwrap().?,
-                            }),
-                            elem_type,
-                        } },
-                    });
-                } else if (mods.addrspace_node != .none) {
-                    break :inner try p.addNode(.{
-                        .tag = .ptr_type,
-                        .main_token = asterisk,
-                        .data = .{ .extra_and_node = .{
-                            try p.addExtra(Node.PtrType{
-                                .sentinel = .none,
-                                .align_node = mods.align_node,
-                                .addrspace_node = mods.addrspace_node,
-                            }),
-                            elem_type,
-                        } },
-                    });
-                } else {
-                    break :inner try p.addNode(.{
-                        .tag = .ptr_type_aligned,
-                        .main_token = asterisk,
-                        .data = .{ .opt_node_and_node = .{
-                            mods.align_node,
-                            elem_type,
-                        } },
-                    });
-                }
-            };
-            return try p.addNode(.{
-                .tag = .ptr_type_aligned,
-                .main_token = asterisk,
-                .data = .{ .opt_node_and_node = .{
-                    .none,
-                    inner,
-                } },
-            });
-        },
         .l_bracket => switch (p.tokenTag(p.tok_i + 1)) {
             .asterisk => {
                 const l_bracket = p.nextToken();
@@ -3260,14 +3203,6 @@ fn parseSuffixOp(p: *Parse, lhs: Node.Index) !?Node.Index {
             .main_token = p.nextToken(),
             .data = .{ .node = lhs },
         }),
-        .invalid_periodasterisks => {
-            try p.warn(.asterisk_after_ptr_deref);
-            return try p.addNode(.{
-                .tag = .deref,
-                .main_token = p.nextToken(),
-                .data = .{ .node = lhs },
-            });
-        },
         .period => switch (p.tokenTag(p.tok_i + 1)) {
             .identifier => return try p.addNode(.{
                 .tag = .field_access,

package/std/zig/PkgConfig.zig

@@ -0,0 +1,146 @@
+//! The more reusable pieces of the build system's pkg-config integration logic.
+const PkgConfig = @This();
+
+const std = @import("../std.zig");
+const mem = std.mem;
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+
+all: []const Pkg,
+
+pub const Pkg = struct {
+    name: []const u8,
+    desc: []const u8,
+};
+
+pub const InitError = Allocator.Error || error{InvalidPkgConfigOutput};
+
+pub const Diagnostic = struct {
+    invalid_line_index: usize,
+    invalid_line: []const u8,
+};
+
+/// Parses the output of `pkg-config --list-all`.
+pub fn init(arena: Allocator, stdout: []const u8, diagnostic: ?*Diagnostic) InitError!PkgConfig {
+    var list: std.ArrayList(Pkg) = .empty;
+    var line_it = mem.tokenizeAny(u8, stdout, "\r\n");
+    var line_index: usize = 0;
+    while (line_it.next()) |line| : (line_index += 1) {
+        if (mem.trim(u8, line, " \t").len == 0) continue;
+        var tok_it = mem.tokenizeAny(u8, line, " \t");
+        try list.append(arena, .{
+            .name = tok_it.next() orelse {
+                if (diagnostic) |d| d.* = .{
+                    .invalid_line_index = line_index,
+                    .invalid_line = line,
+                };
+                return error.InvalidPkgConfigOutput;
+            },
+            .desc = tok_it.rest(),
+        });
+    }
+    try list.shrinkToLen(arena);
+    return .{ .all = list.toOwnedSliceAssert() };
+}
+
+// Maps the library name to pkg config name. Unfortunately, there are several
+// examples where this is not straightforward:
+// * -lSDL2 -> pkg-config sdl2
+// * -lgdk-3 -> pkg-config gdk-3.0
+// * -latk-1.0 -> pkg-config atk
+// * -lpulse -> pkg-config libpulse
+pub fn find(pc: *const PkgConfig, lib_name: []const u8) ?usize {
+    const all = pc.all;
+
+    // Exact match means instant winner.
+    for (all, 0..) |pkg, i| {
+        if (mem.eql(u8, pkg.name, lib_name))
+            return i;
+    }
+
+    // Next we'll try ignoring case.
+    for (all, 0..) |pkg, i| {
+        if (std.ascii.eqlIgnoreCase(pkg.name, lib_name))
+            return i;
+    }
+
+    // Prefixed "lib" or suffixed ".0".
+    for (all, 0..) |pkg, i| {
+        if (std.ascii.findIgnoreCase(pkg.name, lib_name)) |pos| {
+            const prefix = pkg.name[0..pos];
+            const suffix = pkg.name[pos + lib_name.len ..];
+            if (prefix.len > 0 and !mem.eql(u8, prefix, "lib")) continue;
+            if (suffix.len > 0 and !mem.eql(u8, suffix, ".0")) continue;
+            return i;
+        }
+    }
+
+    // Trimming "-1.0".
+    if (mem.cutSuffix(u8, lib_name, "-1.0")) |trimmed| {
+        for (all, 0..) |pkg, i| {
+            if (std.ascii.eqlIgnoreCase(pkg.name, trimmed)) {
+                return i;
+            }
+        }
+    }
+
+    return null;
+}
+
+pub fn exe(environ_map: *const std.process.Environ.Map) []const u8 {
+    return std.zig.EnvVar.PKG_CONFIG.get(environ_map) orelse "pkg-config";
+}
+
+pub const Parsed = struct {
+    cflags: []const []const u8,
+    libs: []const []const u8,
+    unknown_flags: []const []const u8,
+};
+
+pub const ParseError = Allocator.Error || error{InvalidPkgConfigOutput};
+
+/// Parses the output of `pkg-config [name] --cflags --libs`.
+pub fn parse(arena: Allocator, stdout: []const u8) ParseError!Parsed {
+    var zig_cflags: std.ArrayList([]const u8) = .empty;
+    var zig_libs: std.ArrayList([]const u8) = .empty;
+    var unknown_flags: std.ArrayList([]const u8) = .empty;
+    var arg_it = mem.tokenizeAny(u8, stdout, " \r\n\t");
+
+    while (arg_it.next()) |arg| {
+        if (mem.eql(u8, arg, "-I")) {
+            const dir = arg_it.next() orelse return error.InvalidPkgConfigOutput;
+            try zig_cflags.appendSlice(arena, &.{ "-I", dir });
+        } else if (mem.startsWith(u8, arg, "-I")) {
+            try zig_cflags.append(arena, arg);
+        } else if (mem.eql(u8, arg, "-L")) {
+            const dir = arg_it.next() orelse return error.InvalidPkgConfigOutput;
+            try zig_libs.appendSlice(arena, &.{ "-L", dir });
+        } else if (mem.startsWith(u8, arg, "-L")) {
+            try zig_libs.append(arena, arg);
+        } else if (mem.eql(u8, arg, "-l")) {
+            const lib = arg_it.next() orelse return error.InvalidPkgConfigOutput;
+            try zig_libs.appendSlice(arena, &.{ "-l", lib });
+        } else if (mem.startsWith(u8, arg, "-l")) {
+            try zig_libs.append(arena, arg);
+        } else if (mem.eql(u8, arg, "-D")) {
+            const macro = arg_it.next() orelse return error.InvalidPkgConfigOutput;
+            try zig_cflags.appendSlice(arena, &.{ "-D", macro });
+        } else if (mem.startsWith(u8, arg, "-D")) {
+            try zig_cflags.append(arena, arg);
+        } else if (mem.cutPrefix(u8, arg, "-Wl,-rpath,")) |rest| {
+            try zig_cflags.appendSlice(arena, &.{ "-rpath", rest });
+        } else {
+            try unknown_flags.append(arena, arg);
+        }
+    }
+
+    try zig_cflags.shrinkToLen(arena);
+    try zig_libs.shrinkToLen(arena);
+    try unknown_flags.shrinkToLen(arena);
+
+    return .{
+        .cflags = zig_cflags.toOwnedSliceAssert(),
+        .libs = zig_libs.toOwnedSliceAssert(),
+        .unknown_flags = unknown_flags.toOwnedSliceAssert(),
+    };
+}

package/std/zig/TokenSmith.zig

@@ -57,12 +57,6 @@ pub fn gen(smith: *Smith) TokenSmith {
             @memcpy(t.source_buf[t.source_len..][0..lexeme.len], lexeme);
             t.source_len += @intCast(lexeme.len);
 
-            if (tag == .invalid_periodasterisks) {
-                t.tag_buf[t.tags_len] = .asterisk;
-                t.start_buf[t.tags_len] = t.source_len - 1;
-                t.tags_len += 1;
-            }
-
             t.source_buf[t.source_len] = '\n';
             t.source_len += 1;
         } else sw: switch (tag) {