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

package/std/meta/trailer_flags.zig

@@ -13,8 +13,8 @@ pub fn TrailerFlags(comptime Fields: type) type {
     return struct {
         bits: Int,
 
-        pub const Int = meta.Int(.unsigned, bit_count);
-        pub const bit_count = @typeInfo(Fields).@"struct".fields.len;
+        pub const Int = @Int(.unsigned, bit_count);
+        pub const bit_count = @typeInfo(Fields).@"struct".field_names.len;
 
         pub const FieldEnum = std.meta.FieldEnum(Fields);
 
@@ -22,11 +22,18 @@ pub fn TrailerFlags(comptime Fields: type) type {
         pub const FieldValues = blk: {
             var field_names: [bit_count][]const u8 = undefined;
             var field_types: [bit_count]type = undefined;
-            var field_attrs: [bit_count]std.builtin.Type.StructField.Attributes = undefined;
-            for (@typeInfo(Fields).@"struct".fields, &field_names, &field_types, &field_attrs) |field, *new_name, *NewType, *new_attrs| {
-                new_name.* = field.name;
-                NewType.* = ?field.type;
-                const default: ?field.type = null;
+            var field_attrs: [bit_count]std.builtin.Type.Struct.FieldAttributes = undefined;
+            const fields_info = @typeInfo(Fields).@"struct";
+            for (
+                fields_info.field_names,
+                fields_info.field_types,
+                &field_names,
+                &field_types,
+                &field_attrs,
+            ) |field_name, field_type, *new_name, *NewType, *new_attrs| {
+                new_name.* = field_name;
+                NewType.* = ?field_type;
+                const default: ?field_type = null;
                 new_attrs.* = .{ .default_value_ptr = &default };
             }
             break :blk @Struct(.auto, null, &field_names, &field_types, &field_attrs);
@@ -53,8 +60,8 @@ pub fn TrailerFlags(comptime Fields: type) type {
         /// `fields` is a boolean struct where each active field is set to `true`
         pub fn init(fields: ActiveFields) Self {
             var self: Self = .{ .bits = 0 };
-            inline for (@typeInfo(Fields).@"struct".fields, 0..) |field, i| {
-                if (@field(fields, field.name))
+            inline for (@typeInfo(Fields).@"struct".field_names, 0..) |field_name, i| {
+                if (@field(fields, field_name))
                     self.bits |= 1 << i;
             }
             return self;
@@ -62,8 +69,8 @@ pub fn TrailerFlags(comptime Fields: type) type {
 
         /// `fields` is a struct with each field set to an optional value
         pub fn setMany(self: Self, p: [*]align(@alignOf(Fields)) u8, fields: FieldValues) void {
-            inline for (@typeInfo(Fields).@"struct".fields, 0..) |field, i| {
-                if (@field(fields, field.name)) |value|
+            inline for (@typeInfo(Fields).@"struct".field_names, 0..) |field_name, i| {
+                if (@field(fields, field_name)) |value|
                     self.set(p, @as(FieldEnum, @enumFromInt(i)), value);
             }
         }
@@ -93,30 +100,30 @@ pub fn TrailerFlags(comptime Fields: type) type {
 
         pub fn offset(self: Self, comptime field: FieldEnum) usize {
             var off: usize = 0;
-            inline for (@typeInfo(Fields).@"struct".fields, 0..) |field_info, i| {
+            inline for (@typeInfo(Fields).@"struct".field_types, 0..) |field_type, i| {
                 const active = (self.bits & (1 << i)) != 0;
                 if (i == @intFromEnum(field)) {
                     assert(active);
-                    return mem.alignForward(usize, off, @alignOf(field_info.type));
+                    return mem.alignForward(usize, off, @alignOf(field_type));
                 } else if (active) {
-                    off = mem.alignForward(usize, off, @alignOf(field_info.type));
-                    off += @sizeOf(field_info.type);
+                    off = mem.alignForward(usize, off, @alignOf(field_type));
+                    off += @sizeOf(field_type);
                 }
             }
         }
 
         pub fn Field(comptime field: FieldEnum) type {
-            return @typeInfo(Fields).@"struct".fields[@intFromEnum(field)].type;
+            return @typeInfo(Fields).@"struct".field_types[@intFromEnum(field)];
         }
 
         pub fn sizeInBytes(self: Self) usize {
             var off: usize = 0;
-            inline for (@typeInfo(Fields).@"struct".fields, 0..) |field, i| {
-                if (@sizeOf(field.type) == 0)
+            inline for (@typeInfo(Fields).@"struct".field_types, 0..) |field_type, i| {
+                if (@sizeOf(field_type) == 0)
                     continue;
                 if ((self.bits & (1 << i)) != 0) {
-                    off = mem.alignForward(usize, off, @alignOf(field.type));
-                    off += @sizeOf(field.type);
+                    off = mem.alignForward(usize, off, @alignOf(field_type));
+                    off += @sizeOf(field_type);
                 }
             }
             return off;

package/std/meta.zig

@@ -8,35 +8,26 @@ const root = @import("root");
 
 pub const TrailerFlags = @import("meta/trailer_flags.zig").TrailerFlags;
 
-const Type = std.builtin.Type;
+const Type = std.lang.Type;
 
 test {
     _ = TrailerFlags;
 }
 
 /// Returns the variant of an enum type, `T`, which is named `str`, or `null` if no such variant exists.
-pub fn stringToEnum(comptime T: type, str: []const u8) ?T {
+pub fn stringToEnum(comptime T: type, tag_name: []const u8) ?T {
     // Using StaticStringMap here is more performant, but it will start to take too
     // long to compile if the enum is large enough, due to the current limits of comptime
     // performance when doing things like constructing lookup maps at comptime.
     // TODO The '100' here is arbitrary and should be increased when possible:
     // - https://github.com/ziglang/zig/issues/4055
     // - https://github.com/ziglang/zig/issues/3863
-    if (@typeInfo(T).@"enum".fields.len <= 100) {
-        const kvs = comptime build_kvs: {
-            const EnumKV = struct { []const u8, T };
-            var kvs_array: [@typeInfo(T).@"enum".fields.len]EnumKV = undefined;
-            for (@typeInfo(T).@"enum".fields, 0..) |enumField, i| {
-                kvs_array[i] = .{ enumField.name, @field(T, enumField.name) };
-            }
-            break :build_kvs kvs_array[0..];
-        };
-        const map = std.StaticStringMap(T).initComptime(kvs);
-        return map.get(str);
+    if (@typeInfo(T).@"enum".field_names.len <= 100) {
+        return std.StaticStringMap(T).initEnum().get(tag_name);
     } else {
-        inline for (@typeInfo(T).@"enum".fields) |enumField| {
-            if (mem.eql(u8, str, enumField.name)) {
-                return @field(T, enumField.name);
+        inline for (@typeInfo(T).@"enum".field_names) |name| {
+            if (mem.eql(u8, tag_name, name)) {
+                return @field(T, name);
             }
         }
         return null;
@@ -63,7 +54,7 @@ pub fn alignment(comptime T: type) comptime_int {
             .pointer, .@"fn" => alignment(info.child),
             else => @alignOf(T),
         },
-        .pointer => |info| info.alignment orelse @alignOf(info.child),
+        .pointer => |info| info.attrs.@"align" orelse @alignOf(info.child),
         else => @alignOf(T),
     };
 }
@@ -171,34 +162,20 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
     switch (@typeInfo(T)) {
         .pointer => |info| switch (info.size) {
             .one => switch (@typeInfo(info.child)) {
-                .array => |array_info| return @Pointer(.one, .{
-                    .@"const" = info.is_const,
-                    .@"volatile" = info.is_volatile,
-                    .@"allowzero" = info.is_allowzero,
-                    .@"align" = info.alignment,
-                    .@"addrspace" = info.address_space,
-                }, [array_info.len:sentinel_val]array_info.child, null),
+                .array => |array_info| return @Pointer(
+                    .one,
+                    info.attrs,
+                    [array_info.len:sentinel_val]array_info.child,
+                    null,
+                ),
                 else => {},
             },
-            .many, .slice => |size| return @Pointer(size, .{
-                .@"const" = info.is_const,
-                .@"volatile" = info.is_volatile,
-                .@"allowzero" = info.is_allowzero,
-                .@"align" = info.alignment,
-                .@"addrspace" = info.address_space,
-            }, info.child, sentinel_val),
+            .many, .slice => |size| return @Pointer(size, info.attrs, info.child, sentinel_val),
             else => {},
         },
         .optional => |info| switch (@typeInfo(info.child)) {
             .pointer => |ptr_info| switch (ptr_info.size) {
-                .many => return ?@Pointer(.many, .{
-                    .@"const" = ptr_info.is_const,
-                    .@"volatile" = ptr_info.is_volatile,
-                    .@"allowzero" = ptr_info.is_allowzero,
-                    .@"align" = ptr_info.alignment,
-                    .@"addrspace" = ptr_info.address_space,
-                    .child = ptr_info.child,
-                }, ptr_info.child, sentinel_val),
+                .many => return ?@Pointer(.many, ptr_info.attrs, ptr_info.child, sentinel_val),
                 else => {},
             },
             else => {},
@@ -238,14 +215,14 @@ test containerLayout {
     try testing.expect(containerLayout(U3) == .@"extern");
 }
 
-/// Instead of this function, prefer to use e.g. `@typeInfo(foo).@"struct".decls`
+/// Instead of this function, prefer to use e.g. `@typeInfo(foo).@"struct".decl_names`
 /// directly when you know what kind of type it is.
-pub fn declarations(comptime T: type) []const Type.Declaration {
+pub fn declarations(comptime T: type) []const [:0]const u8 {
     return switch (@typeInfo(T)) {
-        .@"struct" => |info| info.decls,
-        .@"enum" => |info| info.decls,
-        .@"union" => |info| info.decls,
-        .@"opaque" => |info| info.decls,
+        .@"struct" => |info| info.decl_names,
+        .@"enum" => |info| info.decl_names,
+        .@"union" => |info| info.decl_names,
+        .@"opaque" => |info| info.decl_names,
         else => @compileError("Expected struct, enum, union, or opaque type, found '" ++ @typeName(T) ++ "'"),
     };
 }
@@ -268,7 +245,7 @@ test declarations {
         pub fn a() void {}
     };
 
-    const decls = comptime [_][]const Type.Declaration{
+    const decls = comptime [_][]const [:0]const u8{
         declarations(E1),
         declarations(S1),
         declarations(U1),
@@ -277,99 +254,43 @@ test declarations {
 
     inline for (decls) |decl| {
         try testing.expect(decl.len == 1);
-        try testing.expect(comptime mem.eql(u8, decl[0].name, "a"));
+        try testing.expect(comptime mem.eql(u8, decl[0], "a"));
     }
 }
 
-pub fn declarationInfo(comptime T: type, comptime decl_name: []const u8) Type.Declaration {
-    inline for (comptime declarations(T)) |decl| {
-        if (comptime mem.eql(u8, decl.name, decl_name))
-            return decl;
-    }
-
-    @compileError("'" ++ @typeName(T) ++ "' has no declaration '" ++ decl_name ++ "'");
-}
-
-test declarationInfo {
-    const E1 = enum {
-        A,
-
-        pub fn a() void {}
-    };
-    const S1 = struct {
-        pub fn a() void {}
-    };
-    const U1 = union {
-        b: u8,
-
-        pub fn a() void {}
-    };
-
-    const infos = comptime [_]Type.Declaration{
-        declarationInfo(E1, "a"),
-        declarationInfo(S1, "a"),
-        declarationInfo(U1, "a"),
-    };
+/// To be removed after Zig 0.17.0 is tagged.
+pub const declarationInfo = @compileError("Deprecated; use '@hasDecl' instead");
+/// To be removed after Zig 0.17.0 is tagged.
+pub const fields = @compileError("Deprecated; use 'fieldNames' and 'fieldTypes' instead");
 
-    inline for (infos) |info| {
-        try testing.expect(comptime mem.eql(u8, info.name, "a"));
-    }
-}
-pub inline fn fields(comptime T: type) switch (@typeInfo(T)) {
-    .@"struct" => []const Type.StructField,
-    .@"union" => []const Type.UnionField,
-    .@"enum" => []const Type.EnumField,
-    .error_set => []const Type.Error,
+pub fn fieldInfo(comptime T: type, comptime field: FieldEnum(T)) switch (@typeInfo(T)) {
+    .@"struct" => struct { name: [:0]const u8, type: type, attrs: Type.Struct.FieldAttributes },
+    .@"union" => struct { name: [:0]const u8, type: type, attrs: Type.Union.FieldAttributes },
+    .@"enum" => struct { name: [:0]const u8, value: comptime_int },
+    .error_set => struct { name: [:0]const u8 },
     else => @compileError("Expected struct, union, error set or enum type, found '" ++ @typeName(T) ++ "'"),
 } {
+    const idx = @intFromEnum(field);
     return switch (@typeInfo(T)) {
-        .@"struct" => |info| info.fields,
-        .@"union" => |info| info.fields,
-        .@"enum" => |info| info.fields,
-        .error_set => |errors| errors.?, // must be non global error set
+        .@"struct" => |info| .{
+            .name = info.field_names[idx],
+            .type = info.field_types[idx],
+            .attrs = info.field_attrs[idx],
+        },
+        .@"union" => |info| .{
+            .name = info.field_names[idx],
+            .type = info.field_types[idx],
+            .attrs = info.field_attrs[idx],
+        },
+        .@"enum" => |info| .{
+            .name = info.field_names[idx],
+            .value = info.field_values[idx],
+        },
+        .error_set => |info| .{ .name = info.error_names.?[idx] },
         else => @compileError("Expected struct, union, error set or enum type, found '" ++ @typeName(T) ++ "'"),
     };
 }
 
-test fields {
-    const E1 = enum {
-        A,
-    };
-    const E2 = error{A};
-    const S1 = struct {
-        a: u8,
-    };
-    const U1 = union {
-        a: u8,
-    };
-
-    const e1f = comptime fields(E1);
-    const e2f = comptime fields(E2);
-    const sf = comptime fields(S1);
-    const uf = comptime fields(U1);
-
-    try testing.expect(e1f.len == 1);
-    try testing.expect(e2f.len == 1);
-    try testing.expect(sf.len == 1);
-    try testing.expect(uf.len == 1);
-    try testing.expect(mem.eql(u8, e1f[0].name, "A"));
-    try testing.expect(mem.eql(u8, e2f[0].name, "A"));
-    try testing.expect(mem.eql(u8, sf[0].name, "a"));
-    try testing.expect(mem.eql(u8, uf[0].name, "a"));
-    try testing.expect(comptime sf[0].type == u8);
-    try testing.expect(comptime uf[0].type == u8);
-}
-
-pub fn fieldInfo(comptime T: type, comptime field: FieldEnum(T)) switch (@typeInfo(T)) {
-    .@"struct" => Type.StructField,
-    .@"union" => Type.UnionField,
-    .@"enum" => Type.EnumField,
-    .error_set => Type.Error,
-    else => @compileError("Expected struct, union, error set or enum type, found '" ++ @typeName(T) ++ "'"),
-} {
-    return fields(T)[@intFromEnum(field)];
-}
-
 test fieldInfo {
     const E1 = enum {
         A,
@@ -395,13 +316,13 @@ test fieldInfo {
     try testing.expect(comptime uf.type == u8);
 }
 
-pub fn fieldNames(comptime T: type) *const [fields(T).len][:0]const u8 {
-    return comptime blk: {
-        const fieldInfos = fields(T);
-        var names: [fieldInfos.len][:0]const u8 = undefined;
-        for (&names, fieldInfos) |*name, field| name.* = field.name;
-        const final = names;
-        break :blk &final;
+pub fn fieldNames(comptime T: type) []const [:0]const u8 {
+    return switch (@typeInfo(T)) {
+        .@"struct" => |s| s.field_names,
+        .@"union" => |u| u.field_names,
+        .@"enum" => |e| e.field_names,
+        .error_set => |es| es.error_names.?,
+        else => @compileError("Expected struct, union, error set or enum type, found '" ++ @typeName(T) ++ "'"),
     };
 }
 
@@ -433,14 +354,41 @@ test fieldNames {
     try testing.expectEqualSlices(u8, u1names[1], "b");
 }
 
+pub fn fieldTypes(comptime T: type) []const type {
+    return switch (@typeInfo(T)) {
+        .@"struct" => |s| s.field_types,
+        .@"union" => |u| u.field_types,
+        else => @compileError("Expected struct or union type, found '" ++ @typeName(T) ++ "'"),
+    };
+}
+
+test fieldTypes {
+    const S1 = struct {
+        a: u8,
+    };
+    const U1 = union {
+        a: u8,
+        b: void,
+    };
+
+    const s1types = comptime fieldTypes(S1);
+    const u1types = comptime fieldTypes(U1);
+
+    try testing.expect(s1types.len == 1);
+    try testing.expect(s1types[0] == u8);
+    try testing.expect(u1types.len == 2);
+    try testing.expect(u1types[0] == u8);
+    try testing.expect(u1types[1] == void);
+}
+
 /// Given an enum or error set type, returns a pointer to an array containing all tags for that
 /// enum or error set.
-pub fn tags(comptime T: type) *const [fields(T).len]T {
+pub fn tags(comptime T: type) *const [fieldNames(T).len]T {
     return comptime blk: {
-        const fieldInfos = fields(T);
-        var res: [fieldInfos.len]T = undefined;
-        for (fieldInfos, 0..) |field, i| {
-            res[i] = @field(T, field.name);
+        const field_names = fieldNames(T);
+        var res: [field_names.len]T = undefined;
+        for (field_names, 0..) |field_name, i| {
+            res[i] = @field(T, field_name);
         }
         const final = res;
         break :blk &final;
@@ -491,27 +439,30 @@ fn expectEqualEnum(expected: anytype, actual: @TypeOf(expected)) !void {
     // because the language does not guarantee that the slice pointers for field names
     // and decl names will be the same.
     comptime {
-        const expected_fields = @typeInfo(expected).@"enum".fields;
-        const actual_fields = @typeInfo(actual).@"enum".fields;
-        if (expected_fields.len != actual_fields.len) return error.FailedTest;
-        for (expected_fields, 0..) |expected_field, i| {
-            const actual_field = actual_fields[i];
-            try testing.expectEqual(expected_field.value, actual_field.value);
-            try testing.expectEqualStrings(expected_field.name, actual_field.name);
+        const expected_field_names = @typeInfo(expected).@"enum".field_names;
+        const expected_field_values = @typeInfo(expected).@"enum".field_values;
+        const actual_field_names = @typeInfo(actual).@"enum".field_names;
+        const actual_field_values = @typeInfo(actual).@"enum".field_values;
+        if (expected_field_names.len != actual_field_names.len) return error.FailedTest;
+        for (expected_field_names, expected_field_values, 0..) |expected_field_name, expected_field_value, i| {
+            const actual_field_name = actual_field_names[i];
+            const actual_field_value = actual_field_values[i];
+            try testing.expectEqual(expected_field_value, actual_field_value);
+            try testing.expectEqualStrings(expected_field_name, actual_field_name);
         }
     }
     comptime {
-        const expected_decls = @typeInfo(expected).@"enum".decls;
-        const actual_decls = @typeInfo(actual).@"enum".decls;
-        if (expected_decls.len != actual_decls.len) return error.FailedTest;
-        for (expected_decls, 0..) |expected_decl, i| {
-            const actual_decl = actual_decls[i];
-            try testing.expectEqualStrings(expected_decl.name, actual_decl.name);
+        const expected_decl_names = @typeInfo(expected).@"enum".decl_names;
+        const actual_decl_names = @typeInfo(actual).@"enum".decl_names;
+        if (expected_decl_names.len != actual_decl_names.len) return error.FailedTest;
+        for (expected_decl_names, 0..) |expected_decl_name, i| {
+            const actual_decl_name = actual_decl_names[i];
+            try testing.expectEqualStrings(expected_decl_name, actual_decl_name);
         }
     }
     try testing.expectEqual(
-        @typeInfo(expected).@"enum".is_exhaustive,
-        @typeInfo(actual).@"enum".is_exhaustive,
+        @typeInfo(expected).@"enum".mode,
+        @typeInfo(actual).@"enum".mode,
     );
 }
 
@@ -534,11 +485,9 @@ test FieldEnum {
 }
 
 pub fn DeclEnum(comptime T: type) type {
-    const decls = declarations(T);
-    var names: [decls.len][]const u8 = undefined;
-    for (&names, decls) |*name, decl| name.* = decl.name;
-    const IntTag = std.math.IntFittingRange(0, decls.len -| 1);
-    return @Enum(IntTag, .exhaustive, &names, &std.simd.iota(IntTag, decls.len));
+    const decl_names = declarations(T);
+    const IntTag = std.math.IntFittingRange(0, decl_names.len -| 1);
+    return @Enum(IntTag, .exhaustive, decl_names, &std.simd.iota(IntTag, decl_names.len));
 }
 
 test DeclEnum {
@@ -622,8 +571,8 @@ pub fn eql(a: anytype, b: @TypeOf(a)) bool {
         .@"struct" => |info| {
             if (info.layout == .@"packed") return a == b;
 
-            inline for (info.fields) |field_info| {
-                if (!eql(@field(a, field_info.name), @field(b, field_info.name))) return false;
+            inline for (info.field_names) |field_name| {
+                if (!eql(@field(a, field_name), @field(b, field_name))) return false;
             }
             return true;
         },
@@ -744,18 +693,13 @@ test eql {
 /// Given a type and a name, return the field index according to source order.
 /// Returns `null` if the field is not found.
 pub fn fieldIndex(comptime T: type, comptime name: []const u8) ?comptime_int {
-    inline for (fields(T), 0..) |field, i| {
-        if (mem.eql(u8, field.name, name))
+    inline for (fieldNames(T), 0..) |field_name, i| {
+        if (mem.eql(u8, field_name, name))
             return i;
     }
     return null;
 }
 
-/// Deprecated: use @Int
-pub fn Int(comptime signedness: std.builtin.Signedness, comptime bit_count: u16) type {
-    return @Int(signedness, bit_count);
-}
-
 pub fn Float(comptime bit_count: u8) type {
     return switch (bit_count) {
         16 => f16,
@@ -787,23 +731,16 @@ pub fn ArgsTuple(comptime Function: type) type {
         @compileError("ArgsTuple expects a function type");
 
     const function_info = info.@"fn";
-    if (function_info.is_var_args)
+    if (function_info.attrs.varargs)
         @compileError("Cannot create ArgsTuple for variadic function");
 
-    var argument_field_list: [function_info.params.len]type = undefined;
-    inline for (function_info.params, 0..) |arg, i| {
-        const T = arg.type orelse @compileError("cannot create ArgsTuple for function with an 'anytype' parameter");
+    var argument_field_list: [function_info.param_types.len]type = undefined;
+    inline for (function_info.param_types, 0..) |arg_type, i| {
+        const T = arg_type orelse @compileError("cannot create ArgsTuple for function with an 'anytype' parameter");
         argument_field_list[i] = T;
     }
 
-    return Tuple(&argument_field_list);
-}
-
-/// Deprecated; use `@Tuple` instead.
-///
-/// To be removed after Zig 0.16.0 releases.
-pub fn Tuple(comptime types: []const type) type {
-    return @Tuple(types);
+    return @Tuple(&argument_field_list);
 }
 
 const TupleTester = struct {
@@ -819,13 +756,15 @@ const TupleTester = struct {
         if (!info.@"struct".is_tuple)
             @compileError("Struct type must be a tuple type");
 
-        const fields_list = std.meta.fields(Actual);
-        if (expected.len != fields_list.len)
-            @compileError("Argument count mismatch");
+        const field_names = info.@"struct".field_names;
+        if (expected.len != field_names.len) {
+            const msg = std.fmt.comptimePrint("Argument count mismatch: expected {d}, got {d}", .{ expected.len, field_names.len });
+            @compileError(msg);
+        }
 
-        inline for (fields_list, 0..) |fld, i| {
-            if (expected[i] != fld.type) {
-                @compileError("Field " ++ fld.name ++ " expected to be type " ++ @typeName(expected[i]) ++ ", but was type " ++ @typeName(fld.type));
+        inline for (field_names, info.@"struct".field_types, 0..) |fld_name, fld_type, i| {
+            if (expected[i] != fld_type) {
+                @compileError("Field " ++ fld_name ++ " expected to be type " ++ @typeName(expected[i]) ++ ", but was type " ++ @typeName(fld_type));
             }
         }
     }
@@ -839,33 +778,13 @@ test ArgsTuple {
     TupleTester.assertTuple(.{u32}, ArgsTuple(fn (comptime a: u32) []const u8));
 }
 
-test Tuple {
-    TupleTester.assertTuple(.{}, Tuple(&[_]type{}));
-    TupleTester.assertTuple(.{u32}, Tuple(&[_]type{u32}));
-    TupleTester.assertTuple(.{ u32, f16 }, Tuple(&[_]type{ u32, f16 }));
-    TupleTester.assertTuple(.{ u32, f16, []const u8, void }, Tuple(&[_]type{ u32, f16, []const u8, void }));
-}
-
-test "Tuple deduplication" {
-    const T1 = std.meta.Tuple(&.{ u32, f32, i8 });
-    const T2 = std.meta.Tuple(&.{ u32, f32, i8 });
-    const T3 = std.meta.Tuple(&.{ u32, f32, i7 });
-
-    if (T1 != T2) {
-        @compileError("std.meta.Tuple doesn't deduplicate tuple types.");
-    }
-    if (T1 == T3) {
-        @compileError("std.meta.Tuple fails to generate different types.");
-    }
-}
-
 test "ArgsTuple forwarding" {
-    const T1 = std.meta.Tuple(&.{ u32, f32, i8 });
+    const T1 = @Tuple(&.{ u32, f32, i8 });
     const T2 = std.meta.ArgsTuple(fn (u32, f32, i8) void);
     const T3 = std.meta.ArgsTuple(fn (u32, f32, i8) callconv(.c) noreturn);
 
     if (T1 != T2) {
-        @compileError("std.meta.ArgsTuple produces different types than std.meta.Tuple");
+        @compileError("std.meta.ArgsTuple produces different types than @Tuple");
     }
     if (T1 != T3) {
         @compileError("std.meta.ArgsTuple produces different types for the same argument lists.");
@@ -975,7 +894,7 @@ pub inline fn hasUniqueRepresentation(comptime T: type) bool {
         .pointer => |info| info.size != .slice,
 
         .optional => |info| switch (@typeInfo(info.child)) {
-            .pointer => |ptr| !ptr.is_allowzero and switch (ptr.size) {
+            .pointer => |ptr| !ptr.attrs.@"allowzero" and switch (ptr.size) {
                 .slice, .c => false,
                 .one, .many => true,
             },
@@ -989,10 +908,10 @@ pub inline fn hasUniqueRepresentation(comptime T: type) bool {
 
             var sum_size = @as(usize, 0);
 
-            inline for (info.fields) |field| {
-                if (field.is_comptime) continue;
-                if (!hasUniqueRepresentation(field.type)) return false;
-                sum_size += @sizeOf(field.type);
+            inline for (info.field_attrs, info.field_types) |field_attr, field_type| {
+                if (field_attr.@"comptime") continue;
+                if (!hasUniqueRepresentation(field_type)) return false;
+                sum_size += @sizeOf(field_type);
             }
 
             return @sizeOf(T) == sum_size;
@@ -1067,7 +986,7 @@ test hasUniqueRepresentation {
 
     try testing.expect(!hasUniqueRepresentation(TestUnion4));
 
-    inline for ([_]type{ i0, u8, i16, u32, i64 }) |T| {
+    inline for ([_]type{ u8, i16, u32, i64 }) |T| {
         try testing.expect(hasUniqueRepresentation(T));
         try testing.expect(hasUniqueRepresentation(enum(T) { _ }));
     }