@zigc/lib 0.17.0-dev.644 → 0.17.0-dev.657

package/std/meta.zig

@@ -8,7 +8,7 @@ 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;
@@ -22,21 +22,21 @@ pub fn stringToEnum(comptime T: type, str: []const u8) ?T {
     // 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) {
+    if (@typeInfo(T).@"enum".field_names.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) };
+            var kvs_array: [@typeInfo(T).@"enum".field_names.len]EnumKV = undefined;
+            for (@typeInfo(T).@"enum".field_names, 0..) |name, i| {
+                kvs_array[i] = .{ name, @field(T, name) };
             }
             break :build_kvs kvs_array[0..];
         };
         const map = std.StaticStringMap(T).initComptime(kvs);
         return map.get(str);
     } 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, str, name)) {
+                return @field(T, name);
             }
         }
         return null;
@@ -63,7 +63,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 +171,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 +224,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 +254,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 +263,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 +325,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 +363,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 +448,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 +494,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 +580,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,8 +702,8 @@ 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;
@@ -782,12 +740,12 @@ 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;
     }
 
@@ -807,13 +765,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));
             }
         }
     }
@@ -943,7 +903,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,
             },
@@ -957,10 +917,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;