@zigc/lib 0.17.0-dev.76 → 0.17.0-dev.813

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

@@ -117,7 +117,7 @@ pub fn getSourceLocation(eb: ErrorBundle, index: SourceLocationIndex) SourceLoca
 
 pub fn getNotes(eb: ErrorBundle, index: MessageIndex) []const MessageIndex {
     const notes_len = eb.getErrorMessage(index).notes_len;
-    const start = @intFromEnum(index) + @typeInfo(ErrorMessage).@"struct".fields.len;
+    const start = @intFromEnum(index) + @typeInfo(ErrorMessage).@"struct".field_names.len;
     return @as([]const MessageIndex, @ptrCast(eb.extra[start..][0..notes_len]));
 }
 
@@ -128,11 +128,12 @@ pub fn getCompileLogOutput(eb: ErrorBundle) [:0]const u8 {
 /// Returns the requested data, as well as the new index which is at the start of the
 /// trailers for the object.
 fn extraData(eb: ErrorBundle, comptime T: type, index: usize) struct { data: T, end: usize } {
-    const fields = @typeInfo(T).@"struct".fields;
+    const field_names = @typeInfo(T).@"struct".field_names;
+    const field_types = @typeInfo(T).@"struct".field_types;
     var i: usize = index;
     var result: T = undefined;
-    inline for (fields) |field| {
-        @field(result, field.name) = switch (field.type) {
+    inline for (field_names, field_types) |field_name, field_type| {
+        @field(result, field_name) = switch (field_type) {
             u32 => eb.extra[i],
             MessageIndex => @as(MessageIndex, @enumFromInt(eb.extra[i])),
             SourceLocationIndex => @as(SourceLocationIndex, @enumFromInt(eb.extra[i])),
@@ -397,9 +398,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(),
         };
     }
 
@@ -494,7 +499,7 @@ pub const Wip = struct {
 
     pub fn reserveNotes(wip: *Wip, notes_len: u32) !u32 {
         try wip.extra.ensureUnusedCapacity(wip.gpa, notes_len +
-            notes_len * @typeInfo(ErrorBundle.ErrorMessage).@"struct".fields.len);
+            notes_len * @typeInfo(ErrorBundle.ErrorMessage).@"struct".field_names.len);
         wip.extra.items.len += notes_len;
         return @intCast(wip.extra.items.len - notes_len);
     }
@@ -727,13 +732,13 @@ pub const Wip = struct {
 
     fn addExtra(wip: *Wip, extra: anytype) Allocator.Error!u32 {
         const gpa = wip.gpa;
-        const fields = @typeInfo(@TypeOf(extra)).@"struct".fields;
+        const fields = @typeInfo(@TypeOf(extra)).@"struct".field_names;
         try wip.extra.ensureUnusedCapacity(gpa, fields.len);
         return addExtraAssumeCapacity(wip, extra);
     }
 
     fn addExtraAssumeCapacity(wip: *Wip, extra: anytype) u32 {
-        const fields = @typeInfo(@TypeOf(extra)).@"struct".fields;
+        const fields = @typeInfo(@TypeOf(extra)).@"struct".field_names;
         const result: u32 = @intCast(wip.extra.items.len);
         wip.extra.items.len += fields.len;
         setExtra(wip, result, extra);
@@ -741,13 +746,15 @@ pub const Wip = struct {
     }
 
     fn setExtra(wip: *Wip, index: usize, extra: anytype) void {
-        const fields = @typeInfo(@TypeOf(extra)).@"struct".fields;
+        const extra_info = @typeInfo(@TypeOf(extra)).@"struct";
+        const field_names = extra_info.field_names;
+        const field_types = extra_info.field_types;
         var i = index;
-        inline for (fields) |field| {
-            wip.extra.items[i] = switch (field.type) {
-                u32 => @field(extra, field.name),
-                MessageIndex => @intFromEnum(@field(extra, field.name)),
-                SourceLocationIndex => @intFromEnum(@field(extra, field.name)),
+        inline for (field_names, field_types) |field_name, field_type| {
+            wip.extra.items[i] = switch (field_type) {
+                u32 => @field(extra, field_name),
+                MessageIndex => @intFromEnum(@field(extra, field_name)),
+                SourceLocationIndex => @intFromEnum(@field(extra, field_name)),
                 else => @compileError("bad field type"),
             };
             i += 1;

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;
 
@@ -41,12 +43,13 @@ pub const FindError = error{
 pub fn parse(allocator: Allocator, io: Io, libc_file: []const u8, target: *const std.Target) !LibCInstallation {
     var self: LibCInstallation = .{};
 
-    const fields = std.meta.fields(LibCInstallation);
+    const field_names = comptime std.meta.fieldNames(LibCInstallation);
     const FoundKey = struct {
         found: bool,
         allocated: ?[:0]u8,
     };
-    var found_keys = [1]FoundKey{FoundKey{ .found = false, .allocated = null }} ** fields.len;
+
+    var found_keys: [field_names.len]FoundKey = @splat(.{ .found = false, .allocated = null });
     errdefer {
         self = .{};
         for (found_keys) |found_key| {
@@ -63,22 +66,22 @@ pub fn parse(allocator: Allocator, io: Io, libc_file: []const u8, target: *const
         var line_it = std.mem.splitScalar(u8, line, '=');
         const name = line_it.first();
         const value = line_it.rest();
-        inline for (fields, 0..) |field, i| {
-            if (std.mem.eql(u8, name, field.name)) {
+        inline for (field_names, 0..) |field_name, i| {
+            if (std.mem.eql(u8, name, field_name)) {
                 found_keys[i].found = true;
                 if (value.len == 0) {
-                    @field(self, field.name) = null;
+                    @field(self, field_name) = null;
                 } else {
-                    found_keys[i].allocated = try allocator.dupeZ(u8, value);
-                    @field(self, field.name) = found_keys[i].allocated;
+                    found_keys[i].allocated = try allocator.dupeSentinel(u8, value, 0);
+                    @field(self, field_name) = found_keys[i].allocated;
                 }
                 break;
             }
         }
     }
-    inline for (fields, 0..) |field, i| {
+    inline for (field_names, 0..) |field_name, i| {
         if (!found_keys[i].found) {
-            log.err("missing field: {s}", .{field.name});
+            log.err("missing field: {s}", .{field_name});
             return error.ParseError;
         }
     }
@@ -112,7 +115,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 +199,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 +210,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");
@@ -229,9 +236,8 @@ pub fn findNative(gpa: Allocator, io: Io, args: FindNativeOptions) FindError!Lib
 
 /// Must be the same allocator passed to `parse` or `findNative`.
 pub fn deinit(self: *LibCInstallation, allocator: Allocator) void {
-    const fields = std.meta.fields(LibCInstallation);
-    inline for (fields) |field| {
-        if (@field(self, field.name)) |payload| {
+    inline for (@typeInfo(LibCInstallation).@"struct".field_names) |field_name| {
+        if (@field(self, field_name)) |payload| {
             allocator.free(payload);
         }
     }
@@ -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";
@@ -415,7 +421,7 @@ fn findNativeCrtDirWindows(
     const arch_sub_dir = switch (target.cpu.arch) {
         .x86 => "x86",
         .x86_64 => "x64",
-        .arm, .armeb => "arm",
+        .thumb => "arm",
         .aarch64 => "arm64",
         else => return error.UnsupportedArchitecture,
     };
@@ -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",
@@ -482,7 +488,7 @@ fn findNativeKernel32LibDir(
     const arch_sub_dir = switch (args.target.cpu.arch) {
         .x86 => "x86",
         .x86_64 => "x64",
-        .arm, .armeb => "arm",
+        .thumb => "arm",
         .aarch64 => "arm64",
         else => return error.UnsupportedArchitecture,
     };
@@ -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

@@ -89,18 +89,18 @@ fn unreserveNode(p: *Parse, node_index: usize) void {
 }
 
 fn addExtra(p: *Parse, extra: anytype) Allocator.Error!ExtraIndex {
-    const fields = std.meta.fields(@TypeOf(extra));
-    try p.extra_data.ensureUnusedCapacity(p.gpa, fields.len);
+    const info = @typeInfo(@TypeOf(extra)).@"struct";
+    try p.extra_data.ensureUnusedCapacity(p.gpa, info.field_names.len);
     const result: ExtraIndex = @enumFromInt(p.extra_data.items.len);
-    inline for (fields) |field| {
-        const data: u32 = switch (field.type) {
+    inline for (info.field_names, info.field_types) |field_name, field_type| {
+        const data: u32 = switch (field_type) {
             Node.Index,
             Node.OptionalIndex,
             OptionalTokenIndex,
             ExtraIndex,
-            => @intFromEnum(@field(extra, field.name)),
+            => @intFromEnum(@field(extra, field_name)),
             TokenIndex,
-            => @field(extra, field.name),
+            => @field(extra, field_name),
             else => @compileError("unexpected field type"),
         };
         p.extra_data.appendAssumeCapacity(data);
@@ -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();
@@ -3004,7 +2947,7 @@ fn parseAddrSpace(p: *Parse) !?Node.Index {
 /// such as in the case of anytype and `...`. Caller must look for rparen to find
 /// out when there are no more param decls left.
 ///
-/// ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime / !KEYWORD_comptime) (IDENTIFIER COLON / !(IDENTIFIER_COLON)) ParamType
+/// ParamDecl <- doc_comment? (KEYWORD_noalias / KEYWORD_comptime / !KEYWORD_comptime) (IDENTIFIER COLON / !(IDENTIFIER COLON)) ParamType
 ///
 /// ParamType
 ///     <- KEYWORD_anytype
@@ -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,