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

package/std/testing/Smith.zig

@@ -35,7 +35,12 @@ fn fromExcessK(T: type, x: Backing(T)) T {
     return @as(T, @bitCast(x)) +% std.math.minInt(T);
 }
 
-fn enumFieldLessThan(_: void, a: std.builtin.Type.EnumField, b: std.builtin.Type.EnumField) bool {
+const EnumField = struct {
+    name: [:0]const u8,
+    value: comptime_int,
+};
+
+fn enumFieldLessThan(_: void, a: EnumField, b: EnumField) bool {
     return a.value < b.value;
 }
 
@@ -67,17 +72,26 @@ pub inline fn baselineWeights(T: type) []const Weight {
             baselineWeights(Backing(T))
         else
             @compileError("non-packed unions cannot be weighted"),
-        .@"enum" => |e| if (!e.is_exhaustive)
+        .@"enum" => |e| if (e.mode == .nonexhaustive)
             baselineWeights(e.tag_type)
-        else if (e.fields.len == 0)
+        else if (e.field_names.len == 0)
             // Cannot be included in below branch due to `log2_int_ceil`
             @compileError("exhaustive zero-field enums cannot be weighted")
         else e: {
-            @setEvalBranchQuota(@intCast(4 * e.fields.len *
-                std.math.log2_int_ceil(usize, e.fields.len)));
-
-            var sorted_fields = e.fields[0..e.fields.len].*;
-            std.mem.sortUnstable(std.builtin.Type.EnumField, &sorted_fields, {}, enumFieldLessThan);
+            @setEvalBranchQuota(@intCast(4 * e.field_names.len *
+                std.math.log2_int_ceil(usize, e.field_names.len)));
+
+            var sorted_fields = blk: {
+                var fields: [e.field_names.len]EnumField = undefined;
+                for (e.field_names, e.field_values, &fields) |f_name, f_value, *field| {
+                    field.* = .{
+                        .name = f_name,
+                        .value = f_value,
+                    };
+                }
+                break :blk fields;
+            };
+            std.mem.sortUnstable(EnumField, &sorted_fields, {}, enumFieldLessThan);
 
             var weights: []const Weight = &.{};
             var seq_first: u64 = sorted_fields[0].value;
@@ -316,10 +330,10 @@ fn weightsContain(int: u64, weights: []const Weight) bool {
 inline fn allBitPatternsValid(T: type) bool {
     return comptime switch (@typeInfo(T)) {
         .void, .bool, .int, .float => true,
-        inline .@"struct", .@"union" => |c| c.layout == .@"packed" and for (c.fields) |f| {
-            if (!allBitPatternsValid(f.type)) break false;
+        inline .@"struct", .@"union" => |c| c.layout == .@"packed" and for (c.field_types) |f_type| {
+            if (!allBitPatternsValid(f_type)) break false;
         } else true,
-        .@"enum" => |e| !e.is_exhaustive,
+        .@"enum" => |e| e.mode == .nonexhaustive,
         else => unreachable,
     };
 }
@@ -346,16 +360,16 @@ fn UnionTagWithoutUninitializable(T: type) type {
     const u = @typeInfo(T).@"union";
     const Tag = u.tag_type orelse @compileError("union must have tag");
     const e = @typeInfo(Tag).@"enum";
-    var field_names: [e.fields.len][]const u8 = undefined;
-    var field_values: [e.fields.len]e.tag_type = undefined;
+    var field_names: [e.field_names.len][]const u8 = undefined;
+    var field_values: [e.field_names.len]e.tag_type = undefined;
     var n_fields = 0;
-    for (u.fields) |f| {
-        switch (f.type) {
+    for (u.field_names, u.field_types) |f_name, f_type| {
+        switch (f_type) {
             noreturn => continue,
             else => {},
         }
-        field_names[n_fields] = f.name;
-        field_values[n_fields] = @intFromEnum(@field(Tag, f.name));
+        field_names[n_fields] = f_name;
+        field_values[n_fields] = @intFromEnum(@field(Tag, f_name));
         n_fields += 1;
     }
     return @Enum(e.tag_type, .exhaustive, field_names[0..n_fields], field_values[0..n_fields]);
@@ -381,12 +395,12 @@ pub fn valueWithHash(s: *Smith, T: type, hash: u32) T {
             }
             break :full @bitCast(int);
         },
-        .@"enum" => |e| if (e.is_exhaustive) v: {
+        .@"enum" => |e| if (e.mode == .exhaustive) v: {
             if (@bitSizeOf(e.tag_type) <= 64) {
                 break :v s.valueWeightedWithHash(T, baselineWeights(T), hash);
             }
             break :v std.enums.fromInt(T, s.valueWithHash(e.tag_type, hash)) orelse
-                @enumFromInt(e.fields[0].value);
+                @enumFromInt(e.field_values[0]);
         } else @enumFromInt(s.valueWithHash(e.tag_type, hash)),
         .optional => |o| if (s.valueWithHash(bool, hash))
             null
@@ -406,11 +420,11 @@ pub fn valueWithHash(s: *Smith, T: type, hash: u32) T {
         .@"struct" => |st| if (!allBitPatternsValid(T)) v: {
             var v: T = undefined;
             var rhash = hash;
-            inline for (st.fields) |f| {
+            inline for (st.field_names, st.field_types) |f_name, f_type| {
                 // rhash is incremented in the call so our rhash state is not reused (e.g. with
                 // two nested structs. note that xor cannot work for this case as the bit would
                 // be flipped back here)
-                @field(v, f.name) = s.valueWithHash(f.type, rhash +% 1);
+                @field(v, f_name) = s.valueWithHash(f_type, rhash +% 1);
                 rhash = std.hash.int(rhash);
             }
             break :v v;

package/std/testing.zig

@@ -17,19 +17,11 @@ var failing_allocator_instance = FailingAllocator.init(base_allocator_instance.a
 });
 var base_allocator_instance = std.heap.FixedBufferAllocator.init("");
 
-/// This should only be used in temporary test programs.
-pub const allocator = allocator_instance.allocator();
-pub var allocator_instance: std.heap.DebugAllocator(.{
-    .stack_trace_frames = if (std.debug.sys_can_stack_trace) 10 else 0,
-    .resize_stack_traces = true,
-    // A unique value so that when a default-constructed
-    // DebugAllocator is incorrectly passed to testing allocator, or
-    // vice versa, panic occurs.
-    .canary = @truncate(0x2731e675c3a701ba),
-}) = b: {
-    if (!builtin.is_test) @compileError("testing allocator used when not testing");
-    break :b .init;
-};
+pub var allocator_instance: std.heap.SafeAllocator = undefined;
+pub const allocator = if (builtin.is_test)
+    allocator_instance.allocator()
+else
+    @compileError("not testing");
 
 pub var io_instance: Io.Threaded = undefined;
 pub const io = if (builtin.is_test) io_instance.io() else @compileError("not testing");
@@ -87,6 +79,7 @@ fn expectEqualInner(comptime T: type, expected: T, actual: T) !void {
     switch (@typeInfo(@TypeOf(actual))) {
         .noreturn,
         .@"opaque",
+        .spirv,
         .frame,
         .@"anyframe",
         => @compileError("value of type " ++ @typeName(@TypeOf(actual)) ++ " encountered"),
@@ -149,21 +142,21 @@ fn expectEqualInner(comptime T: type, expected: T, actual: T) !void {
         },
 
         .@"struct" => |structType| {
-            inline for (structType.fields) |field| {
-                try expectEqual(@field(expected, field.name), @field(actual, field.name));
+            inline for (structType.field_names) |field_name| {
+                try expectEqual(@field(expected, field_name), @field(actual, field_name));
             }
         },
 
         .@"union" => |union_info| {
             if (union_info.tag_type == null) {
-                const first_size = @bitSizeOf(union_info.fields[0].type);
-                inline for (union_info.fields) |field| {
-                    if (@bitSizeOf(field.type) != first_size) {
+                const first_size = @bitSizeOf(union_info.field_types[0]);
+                inline for (union_info.field_types) |field_type| {
+                    if (@bitSizeOf(field_type) != first_size) {
                         @compileError("Unable to compare untagged unions with varying field sizes for type " ++ @typeName(@TypeOf(actual)));
                     }
                 }
 
-                const BackingInt = std.meta.Int(.unsigned, @bitSizeOf(T));
+                const BackingInt = @Int(.unsigned, @bitSizeOf(T));
                 return expectEqual(
                     @as(BackingInt, @bitCast(expected)),
                     @as(BackingInt, @bitCast(actual)),
@@ -501,7 +494,7 @@ const BytesDiffer = struct {
         var row: usize = 0;
         while (expected_iterator.next()) |chunk| {
             // to avoid having to calculate diffs twice per chunk
-            var diffs: std.bit_set.IntegerBitSet(16) = .{ .mask = 0 };
+            var diffs: std.bit_set.Integer(16) = .{ .mask = 0 };
             for (chunk, 0..) |byte, col| {
                 const absolute_byte_index = col + row * 16;
                 const diff = if (absolute_byte_index < self.actual.len) self.actual[absolute_byte_index] != byte else true;
@@ -745,6 +738,7 @@ fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpe
     switch (@typeInfo(@TypeOf(actual))) {
         .noreturn,
         .@"opaque",
+        .spirv,
         .frame,
         .@"anyframe",
         => @compileError("value of type " ++ @typeName(@TypeOf(actual)) ++ " encountered"),
@@ -848,9 +842,9 @@ fn expectEqualDeepInner(comptime T: type, expected: T, actual: T) error{TestExpe
         },
 
         .@"struct" => |structType| {
-            inline for (structType.fields) |field| {
-                expectEqualDeep(@field(expected, field.name), @field(actual, field.name)) catch |e| {
-                    print("Field {s} incorrect. expected {any}, found {any}\n", .{ field.name, @field(expected, field.name), @field(actual, field.name) });
+            inline for (structType.field_names) |field_name| {
+                expectEqualDeep(@field(expected, field_name), @field(actual, field_name)) catch |e| {
+                    print("Field {s} incorrect. expected {any}, found {any}\n", .{ field_name, @field(expected, field_name), @field(actual, field_name) });
                     return e;
                 };
             }
@@ -1173,14 +1167,14 @@ fn CheckAllAllocationFailuresExtraArgs(comptime TestFn: type) type {
 
     const ArgsTuple = std.meta.ArgsTuple(TestFn);
 
-    const fields = @typeInfo(ArgsTuple).@"struct".fields;
-    if (fields.len == 0 or fields[0].type != std.mem.Allocator) {
+    const field_types = @typeInfo(ArgsTuple).@"struct".field_types;
+    if (field_types.len == 0 or field_types[0] != std.mem.Allocator) {
         @compileError("The provided function must have an " ++ @typeName(std.mem.Allocator) ++ " as its first argument");
     }
 
-    var extra_args: [fields.len - 1]type = undefined;
-    for (&extra_args, fields[1..]) |*arg, field| {
-        arg.* = field.type;
+    var extra_args: [field_types.len - 1]type = undefined;
+    for (&extra_args, field_types[1..]) |*arg, field_type| {
+        arg.* = field_type;
     }
 
     return @Tuple(&extra_args);
@@ -1212,8 +1206,8 @@ test "checkAllAllocationFailures provide result type to 'extra_args' argument" {
 /// Given a type, references all the declarations inside, so that the semantic analyzer sees them.
 pub fn refAllDecls(comptime T: type) void {
     if (!builtin.is_test) return;
-    inline for (comptime std.meta.declarations(T)) |decl| {
-        _ = &@field(T, decl.name);
+    inline for (comptime std.meta.declarations(T)) |decl_name| {
+        _ = &@field(T, decl_name);
     }
 }
 
@@ -1334,6 +1328,67 @@ pub const ReaderIndirect = struct {
     }
 };
 
+/// A `Io.Writer` that writes its data to another `Io.Writer`, and only
+/// writes new data to its own buffer during `drain`.
+pub const WriterIndirect = struct {
+    out: *Io.Writer,
+    interface: Io.Writer,
+
+    pub fn init(out: *Io.Writer, buffer: []u8) WriterIndirect {
+        return .{
+            .out = out,
+            .interface = .{
+                .vtable = &.{
+                    .drain = drain,
+                },
+                .buffer = buffer,
+                .end = 0,
+            },
+        };
+    }
+
+    fn drain(w: *Io.Writer, data: []const []const u8, splat: usize) std.Io.Writer.Error!usize {
+        const w_indirect: *WriterIndirect = @alignCast(@fieldParentPtr("interface", w));
+
+        // Write all data in the buffer to `out`
+        try w_indirect.out.writeAll(w.buffer[0..w.end]);
+        w.end = 0;
+
+        // Refill buffer using data
+        {
+            const end_before_fill = w.end;
+            for (data[0 .. data.len - 1]) |bytes| {
+                const dest = w.buffer[w.end..];
+                const len = @min(bytes.len, dest.len);
+                @memcpy(dest[0..len], bytes[0..len]);
+                w.end += len;
+            }
+            const pattern = data[data.len - 1];
+            switch (pattern.len) {
+                0 => {},
+                1 => {
+                    const len = @min(w.buffer[w.end..].len, splat);
+                    @memset(w.buffer[w.end..][0..len], pattern[0]);
+                    w.end += len;
+                },
+                else => {
+                    const dest = w.buffer[w.end..];
+                    for (0..splat) |i| {
+                        const start_i = i * pattern.len;
+                        if (start_i >= dest.len) break;
+                        const remaining = dest[start_i..];
+                        const len = @min(pattern.len, remaining.len);
+                        @memcpy(remaining[0..len], pattern[0..len]);
+                        w.end += len;
+                    }
+                },
+            }
+
+            return w.end - end_before_fill;
+        }
+    }
+};
+
 test {
     _ = &Smith;
 }

package/std/unicode.zig

@@ -275,11 +275,16 @@ fn utf8ValidateSliceImpl(input: []const u8, comptime surrogates: Surrogates) boo
     const s7 = 0x44; // accept 4, size 4
 
     // Information about the first byte in a UTF-8 sequence.
-    const first = comptime ([_]u8{as} ** 128) ++ ([_]u8{xx} ** 64) ++ [_]u8{
-        xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1,
-        s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1,
-        s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3,
-        s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx,
+    const first = comptime first: {
+        const a: [128]u8 = @splat(as);
+        const b: [64]u8 = @splat(xx);
+        const c: [64]u8 = .{
+            xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1,
+            s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1,
+            s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3,
+            s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx,
+        };
+        break :first a ++ b ++ c;
     };
 
     const n = remaining.len;
@@ -647,7 +652,7 @@ test "validate slice" {
 
     // We skip a variable (based on recommended vector size) chunks of
     // ASCII characters. Let's make sure we're chunking correctly.
-    const str = [_]u8{'a'} ** 550 ++ "\xc0";
+    const str = @as([550]u8, @splat('a')) ++ "\xc0";
     for (0..str.len - 3) |i| {
         try testing.expect(!utf8ValidateSlice(str[i..]));
     }
@@ -1394,7 +1399,7 @@ test "ArrayList functions on a re-used list" {
 fn utf8ToUtf16LeStringLiteralImpl(comptime utf8: []const u8, comptime surrogates: Surrogates) *const [calcUtf16LeLenImpl(utf8, surrogates) catch |err| @compileError(err):0]u16 {
     return comptime blk: {
         const len: usize = calcUtf16LeLenImpl(utf8, surrogates) catch unreachable;
-        var utf16le: [len:0]u16 = [_:0]u16{0} ** len;
+        var utf16le: [len:0]u16 = @splat(0);
         const utf16le_len = utf8ToUtf16LeImpl(&utf16le, utf8[0..], surrogates) catch |err| @compileError(err);
         assert(len == utf16le_len);
         const final = utf16le;
@@ -1640,7 +1645,7 @@ test "validate WTF-8 slice" {
 
     // We skip a variable (based on recommended vector size) chunks of
     // ASCII characters. Let's make sure we're chunking correctly.
-    const str = [_]u8{'a'} ** 550 ++ "\xc0";
+    const str = @as([550]u8, @splat('a')) ++ "\xc0";
     for (0..str.len - 3) |i| {
         try testing.expect(!wtf8ValidateSlice(str[i..]));
     }

package/std/zig/Ast/Render.zig

@@ -394,20 +394,8 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
             return renderBlock(r, node, statements, space);
         },
 
-        .@"errdefer" => {
-            const defer_token = tree.nodeMainToken(node);
-            const maybe_payload_token, const expr = tree.nodeData(node).opt_token_and_node;
-
-            try renderToken(r, defer_token, .maybe_space);
-            if (maybe_payload_token.unwrap()) |payload_token| {
-                try renderToken(r, payload_token - 1, .none); // |
-                try renderIdentifier(r, payload_token, .none, .preserve_when_shadowing); // identifier
-                try renderToken(r, payload_token + 1, .maybe_space); // |
-            }
-            return renderExpression(r, expr, space);
-        },
-
         .@"defer",
+        .@"errdefer",
         .@"comptime",
         .@"nosuspend",
         .@"suspend",
@@ -520,7 +508,6 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
         .add_wrap,
         .add_sat,
         .array_cat,
-        .array_mult,
         .bang_equal,
         .bit_and,
         .bit_or,
@@ -998,8 +985,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;
@@ -1040,16 +1027,6 @@ fn renderPtrType(r: *Render, ptr_type: Ast.full.PtrType, space: Space) Error!voi
 
     switch (ptr_type.size) {
         .one => {
-            // Since ** tokens exist and the same token is shared by two
-            // nested pointer types, we check to see if we are the parent
-            // in such a relationship. If so, skip rendering anything for
-            // this pointer type and rely on the child to render our asterisk
-            // as well when it renders the ** token.
-            if (tree.tokenTag(main_token) == .asterisk_asterisk and
-                main_token == tree.nodeMainToken(ptr_type.ast.child_type))
-            {
-                return renderExpression(r, ptr_type.ast.child_type, space);
-            }
             try renderToken(r, main_token, .none); // asterisk
         },
         .many => {
@@ -1685,7 +1662,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);
@@ -3235,7 +3212,6 @@ fn nodeCausesSliceOpSpace(tag: Ast.Node.Tag) bool {
         .add,
         .add_wrap,
         .array_cat,
-        .array_mult,
         .assign,
         .assign_bit_and,
         .assign_bit_or,
@@ -3466,7 +3442,7 @@ const AutoIndentingStream = struct {
     /// Sets current indentation level to be the same as that of the last pushSpace.
     pub fn enableSpaceMode(ais: *AutoIndentingStream, space: Space) void {
         if (ais.space_stack.items.len == 0) return;
-        const curr = ais.space_stack.getLast();
+        const curr = ais.space_stack.getLast().?;
         if (curr.space != space) return;
         ais.space_mode = curr.indent_count;
     }
@@ -3477,7 +3453,7 @@ const AutoIndentingStream = struct {
 
     pub fn lastSpaceModeIndent(ais: *AutoIndentingStream) usize {
         if (ais.space_stack.items.len == 0) return 0;
-        return ais.space_stack.getLast().indent_count * ais.indent_delta;
+        return ais.space_stack.getLast().?.indent_count * ais.indent_delta;
     }
 
     /// Push default indentation

package/std/zig/Ast.zig

@@ -196,19 +196,17 @@ pub fn parseTokens(
         .zon => try parser.parseZon(),
     }
 
-    const extra_data = try parser.extra_data.toOwnedSlice(gpa);
-    errdefer gpa.free(extra_data);
-    const errors = try parser.errors.toOwnedSlice(gpa);
-    errdefer gpa.free(errors);
+    try parser.extra_data.shrinkToLen(gpa);
+    try parser.errors.shrinkToLen(gpa);
 
     // TODO experiment with compacting the MultiArrayList slices here
-    return Ast{
+    return .{
         .source = source,
         .mode = mode,
         .tokens = tokens,
         .nodes = parser.nodes.toOwnedSlice(),
-        .extra_data = extra_data,
-        .errors = errors,
+        .extra_data = parser.extra_data.toOwnedSliceAssert(),
+        .errors = parser.errors.toOwnedSliceAssert(),
     };
 }
 
@@ -300,17 +298,17 @@ pub fn extraDataSliceWithLen(tree: Ast, start: ExtraIndex, len: u32, comptime T:
 }
 
 pub fn extraData(tree: Ast, index: ExtraIndex, comptime T: type) T {
-    const fields = std.meta.fields(T);
+    const info = @typeInfo(T).@"struct";
     var result: T = undefined;
-    inline for (fields, 0..) |field, i| {
-        @field(result, field.name) = switch (field.type) {
+    inline for (info.field_names, info.field_types, 0..) |field_name, field_type, i| {
+        @field(result, field_name) = switch (field_type) {
             Node.Index,
             Node.OptionalIndex,
             OptionalTokenIndex,
             ExtraIndex,
             => @enumFromInt(tree.extra_data[@intFromEnum(index) + i]),
             TokenIndex => tree.extra_data[@intFromEnum(index) + i],
-            else => @compileError("unexpected field type: " ++ @typeName(field.type)),
+            else => @compileError("unexpected field type: " ++ @typeName(field_type)),
         };
     }
     return result;
@@ -333,11 +331,6 @@ pub fn rootDecls(tree: Ast) []const Node.Index {
 
 pub fn renderError(tree: Ast, parse_error: Error, w: *Writer) Writer.Error!void {
     switch (parse_error.tag) {
-        .asterisk_after_ptr_deref => {
-            // Note that the token will point at the `.*` but ideally the source
-            // location would point to the `*` after the `.*`.
-            return w.writeAll("'.*' cannot be followed by '*'; are you missing a space?");
-        },
         .chained_comparison_operators => {
             return w.writeAll("comparison operators cannot be chained");
         },
@@ -689,7 +682,6 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex {
         .mul,
         .div,
         .mod,
-        .array_mult,
         .mul_wrap,
         .mul_sat,
         .add,
@@ -926,7 +918,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
         .mul,
         .div,
         .mod,
-        .array_mult,
         .mul_wrap,
         .mul_sat,
         .add,
@@ -954,8 +945,8 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
         .switch_range,
         => n = tree.nodeData(n).node_and_node[1],
 
-        .test_decl, .@"errdefer" => n = tree.nodeData(n).opt_token_and_node[1],
-        .@"defer" => n = tree.nodeData(n).node,
+        .test_decl => n = tree.nodeData(n).opt_token_and_node[1],
+        .@"defer", .@"errdefer" => n = tree.nodeData(n).node,
         .anyframe_type => n = tree.nodeData(n).token_and_node[1],
 
         .switch_case_one,
@@ -2112,10 +2103,8 @@ fn fullFnProtoComponents(tree: Ast, info: full.FnProto.Components) full.FnProto
 }
 
 fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType {
-    const size: std.builtin.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) {
-        .asterisk,
-        .asterisk_asterisk,
-        => .one,
+    const size: std.lang.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) {
+        .asterisk => .one,
         .l_bracket => switch (tree.tokenTag(info.main_token + 1)) {
             .asterisk => if (tree.tokenTag(info.main_token + 2) == .identifier) .c else .many,
             else => .slice,
@@ -2737,7 +2726,7 @@ pub const full = struct {
     };
 
     pub const PtrType = struct {
-        size: std.builtin.Type.Pointer.Size,
+        size: std.lang.Type.Pointer.Size,
         allowzero_token: ?TokenIndex,
         const_token: ?TokenIndex,
         volatile_token: ?TokenIndex,
@@ -2844,7 +2833,6 @@ pub const Error = struct {
     } = .{ .none = {} },
 
     pub const Tag = enum {
-        asterisk_after_ptr_deref,
         chained_comparison_operators,
         decl_between_fields,
         expected_block,
@@ -3061,11 +3049,8 @@ pub const Node = struct {
         /// a `assign_destructure` node or a parsing error occured.
         aligned_var_decl,
         /// `errdefer expr`,
-        /// `errdefer |payload| expr`.
         ///
-        /// The `data` field is a `.opt_token_and_node`:
-        ///   1. a `OptionalTokenIndex` to the payload identifier, if any.
-        ///   2. a `Node.Index` to the deferred expression.
+        /// The `data` field is a `.node` to the deferred expression.
         ///
         /// The `main_token` field is the `errdefer` token.
         @"errdefer",
@@ -3073,7 +3058,7 @@ pub const Node = struct {
         ///
         /// The `data` field is a `.node` to the deferred expression.
         ///
-        /// The `main_token` field is the `defer`.
+        /// The `main_token` field is the `defer` token.
         @"defer",
         /// `lhs catch rhs`,
         /// `lhs catch |err| rhs`.
@@ -3183,8 +3168,6 @@ pub const Node = struct {
         div,
         /// `lhs % rhs`. The `main_token` field is the `%` token.
         mod,
-        /// `lhs ** rhs`. The `main_token` field is the `**` token.
-        array_mult,
         /// `lhs *% rhs`. The `main_token` field is the `*%` token.
         mul_wrap,
         /// `lhs *| rhs`. The `main_token` field is the `*|` token.
@@ -3255,8 +3238,6 @@ pub const Node = struct {
         ///
         /// The `main_token` is the asterisk if a single item pointer or the
         /// lbracket if a slice, many-item pointer, or C-pointer.
-        /// The `main_token` might be a ** token, which is shared with a
-        /// parent/child pointer type and may require special handling.
         ptr_type_aligned,
         /// `[*:lhs]rhs`,
         /// `*rhs`,
@@ -3268,8 +3249,6 @@ pub const Node = struct {
         ///
         /// The `main_token` is the asterisk if a single item pointer or the
         /// lbracket if a slice, many-item pointer, or C-pointer.
-        /// The `main_token` might be a ** token, which is shared with a
-        /// parent/child pointer type and may require special handling.
         ptr_type_sentinel,
         /// The `data` field is a `.extra_and_node`:
         ///   1. a `ExtraIndex` to `PtrType`.
@@ -3277,8 +3256,6 @@ pub const Node = struct {
         ///
         /// The `main_token` is the asterisk if a single item pointer or the
         /// lbracket if a slice, many-item pointer, or C-pointer.
-        /// The `main_token` might be a ** token, which is shared with a
-        /// parent/child pointer type and may require special handling.
         ptr_type,
         /// The `data` field is a `.extra_and_node`:
         ///   1. a `ExtraIndex` to `PtrTypeBitRange`.
@@ -3286,8 +3263,6 @@ pub const Node = struct {
         ///
         /// The `main_token` is the asterisk if a single item pointer or the
         /// lbracket if a slice, many-item pointer, or C-pointer.
-        /// The `main_token` might be a ** token, which is shared with a
-        /// parent/child pointer type and may require special handling.
         ptr_type_bit_range,
         /// `lhs[rhs..]`
         ///