Commit dec1163fbb
Changed files (108)
doc
lib
build-web
compiler
docs
wasm
std
crypto
fmt
hash
zig
c_translation
llvm
src
codegen
aarch64
x86_64
test
behavior
cases
compile_errors
standalone
doc/langref/std_options.zig
@@ -11,7 +11,7 @@ pub const std_options: std.Options = .{
fn myLogFn(
comptime level: std.log.Level,
- comptime scope: @Type(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
doc/langref/test_coerce_unions_enums.zig
@@ -41,7 +41,7 @@ test "coercion between unions and enums" {
try expect(u_4.tag() == 1);
// The following example is invalid.
- // error: coercion from enum '@TypeOf(.enum_literal)' to union 'test_coerce_unions_enum.U2' must initialize 'f32' field 'b'
+ // error: coercion from enum '@EnumLiteral()' to union 'test_coerce_unions_enum.U2' must initialize 'f32' field 'b'
//var u_5: U2 = .b;
//try expect(u_5.tag() == 2);
}
lib/build-web/main.zig
@@ -49,7 +49,7 @@ pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noretu
fn logFn(
comptime message_level: log.Level,
- comptime scope: @TypeOf(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
lib/compiler/aro/aro/Attribute.zig
@@ -717,23 +717,13 @@ pub const Tag = std.meta.DeclEnum(attributes);
pub const Arguments = blk: {
const decls = @typeInfo(attributes).@"struct".decls;
- var union_fields: [decls.len]ZigType.UnionField = undefined;
- for (decls, &union_fields) |decl, *field| {
- field.* = .{
- .name = decl.name,
- .type = @field(attributes, decl.name),
- .alignment = @alignOf(@field(attributes, decl.name)),
- };
+ var names: [decls.len][]const u8 = undefined;
+ var types: [decls.len]type = undefined;
+ for (decls, &names, &types) |decl, *name, *T| {
+ name.* = decl.name;
+ T.* = @field(attributes, decl.name);
}
-
- break :blk @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = null,
- .fields = &union_fields,
- .decls = &.{},
- },
- });
+ break :blk @Union(.auto, null, &names, &types, &@splat(.{}));
};
pub fn ArgumentsForTag(comptime tag: Tag) type {
lib/compiler/aro/assembly_backend/x86_64.zig
@@ -59,7 +59,7 @@ fn serializeFloat(comptime T: type, value: T, w: *std.Io.Writer) !void {
else => {
const size = @bitSizeOf(T);
const storage_unit = std.meta.intToEnum(StorageUnit, size) catch unreachable;
- const IntTy = @Type(.{ .int = .{ .signedness = .unsigned, .bits = size } });
+ const IntTy = @Int(.unsigned, size);
const int_val: IntTy = @bitCast(value);
return serializeInt(int_val, storage_unit, w);
},
lib/compiler/resinator/code_pages.zig
@@ -179,12 +179,13 @@ pub const UnsupportedCodePage = enum(u16) {
pub const CodePage = blk: {
const fields = @typeInfo(SupportedCodePage).@"enum".fields ++ @typeInfo(UnsupportedCodePage).@"enum".fields;
- break :blk @Type(.{ .@"enum" = .{
- .tag_type = u16,
- .decls = &.{},
- .fields = fields,
- .is_exhaustive = true,
- } });
+ var field_names: [fields.len][]const u8 = undefined;
+ var field_values: [fields.len]u16 = undefined;
+ for (fields, &field_names, &field_values) |field, *name, *val| {
+ name.* = field.name;
+ val.* = field.value;
+ }
+ break :blk @Enum(u16, .exhaustive, &field_names, &field_values);
};
pub fn isSupported(code_page: CodePage) bool {
lib/compiler/resinator/errors.zig
@@ -862,20 +862,23 @@ pub const ErrorDetails = struct {
pub const ErrorDetailsWithoutCodePage = blk: {
const details_info = @typeInfo(ErrorDetails);
const fields = details_info.@"struct".fields;
- var fields_without_codepage: [fields.len - 1]std.builtin.Type.StructField = undefined;
+ var field_names: [fields.len - 1][]const u8 = undefined;
+ var field_types: [fields.len - 1]type = undefined;
+ var field_attrs: [fields.len - 1]std.builtin.Type.StructField.Attributes = undefined;
var i: usize = 0;
for (fields) |field| {
if (std.mem.eql(u8, field.name, "code_page")) continue;
- fields_without_codepage[i] = field;
+ field_names[i] = field.name;
+ field_types[i] = field.type;
+ field_attrs[i] = .{
+ .@"comptime" = field.is_comptime,
+ .@"align" = field.alignment,
+ .default_value_ptr = field.default_value_ptr,
+ };
i += 1;
}
- std.debug.assert(i == fields_without_codepage.len);
- break :blk @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &fields_without_codepage,
- .decls = &.{},
- .is_tuple = false,
- } });
+ std.debug.assert(i == fields.len - 1);
+ break :blk @Struct(.auto, null, &field_names, &field_types, &field_attrs);
};
fn cellCount(code_page: SupportedCodePage, source: []const u8, start_index: usize, end_index: usize) usize {
lib/compiler/test_runner.zig
@@ -298,7 +298,7 @@ fn mainTerminal() void {
pub fn log(
comptime message_level: std.log.Level,
- comptime scope: @Type(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
lib/compiler_rt/common.zig
@@ -290,10 +290,7 @@ pub fn normalize(comptime T: type, significand: *std.meta.Int(.unsigned, @typeIn
pub inline fn fneg(a: anytype) @TypeOf(a) {
const F = @TypeOf(a);
const bits = @typeInfo(F).float.bits;
- const U = @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = bits,
- } });
+ const U = @Int(.unsigned, bits);
const sign_bit_mask = @as(U, 1) << (bits - 1);
const negated = @as(U, @bitCast(a)) ^ sign_bit_mask;
return @bitCast(negated);
lib/compiler_rt/float_from_int.zig
@@ -66,17 +66,17 @@ pub inline fn floatFromBigInt(comptime T: type, comptime signedness: std.builtin
switch (x.len) {
0 => return 0,
inline 1...4 => |limbs_len| return @floatFromInt(@as(
- @Type(.{ .int = .{ .signedness = signedness, .bits = 32 * limbs_len } }),
+ @Int(signedness, 32 * limbs_len),
@bitCast(x[0..limbs_len].*),
)),
else => {},
}
// sign implicit fraction round sticky
- const I = comptime @Type(.{ .int = .{
- .signedness = signedness,
- .bits = @as(u16, @intFromBool(signedness == .signed)) + 1 + math.floatFractionalBits(T) + 1 + 1,
- } });
+ const I = comptime @Int(
+ signedness,
+ @as(u16, @intFromBool(signedness == .signed)) + 1 + math.floatFractionalBits(T) + 1 + 1,
+ );
const clrsb = clrsb: {
var clsb: usize = 0;
lib/compiler_rt/int_from_float.zig
@@ -56,7 +56,7 @@ pub inline fn bigIntFromFloat(comptime signedness: std.builtin.Signedness, resul
0 => return,
inline 1...4 => |limbs_len| {
result[0..limbs_len].* = @bitCast(@as(
- @Type(.{ .int = .{ .signedness = signedness, .bits = 32 * limbs_len } }),
+ @Int(signedness, 32 * limbs_len),
@intFromFloat(a),
));
return;
@@ -66,10 +66,7 @@ pub inline fn bigIntFromFloat(comptime signedness: std.builtin.Signedness, resul
// sign implicit fraction
const significand_bits = 1 + math.floatFractionalBits(@TypeOf(a));
- const I = @Type(comptime .{ .int = .{
- .signedness = signedness,
- .bits = @as(u16, @intFromBool(signedness == .signed)) + significand_bits,
- } });
+ const I = @Int(signedness, @as(u16, @intFromBool(signedness == .signed)) + significand_bits);
const parts = math.frexp(a);
const significand_bits_adjusted_to_handle_smin = @as(i32, significand_bits) +
lib/compiler_rt/memcpy.zig
@@ -159,7 +159,7 @@ inline fn copyFixedLength(
else if (len > @sizeOf(usize))
@Vector(len, u8)
else
- @Type(.{ .int = .{ .signedness = .unsigned, .bits = len * 8 } });
+ @Int(.unsigned, len * 8);
const loop_count = @divExact(len, @sizeOf(T));
lib/docs/wasm/main.zig
@@ -41,7 +41,7 @@ pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noretu
fn logFn(
comptime message_level: log.Level,
- comptime scope: @TypeOf(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
lib/std/crypto/phc_encoding.zig
@@ -94,12 +94,12 @@ pub fn deserialize(comptime HashResult: type, str: []const u8) Error!HashResult
if (kvSplit(field)) |opt_version| {
if (mem.eql(u8, opt_version.key, version_param_name)) {
if (@hasField(HashResult, "alg_version")) {
- const value_type_info = switch (@typeInfo(@TypeOf(out.alg_version))) {
- .optional => |opt| @typeInfo(opt.child),
- else => |t| t,
+ const ValueType = switch (@typeInfo(@TypeOf(out.alg_version))) {
+ .optional => |opt| opt.child,
+ else => @TypeOf(out.alg_version),
};
out.alg_version = fmt.parseUnsigned(
- @Type(value_type_info),
+ ValueType,
opt_version.value,
10,
) catch return Error.InvalidEncoding;
lib/std/crypto/tls.zig
@@ -606,7 +606,7 @@ pub fn array(
const elem_size = @divExact(@bitSizeOf(Elem), 8);
var arr: [len_size + elem_size * elems.len]u8 = undefined;
std.mem.writeInt(Len, arr[0..len_size], @intCast(elem_size * elems.len), .big);
- const ElemInt = @Type(.{ .int = .{ .signedness = .unsigned, .bits = @bitSizeOf(Elem) } });
+ const ElemInt = @Int(.unsigned, @bitSizeOf(Elem));
for (0.., @as([elems.len]Elem, elems)) |index, elem| {
std.mem.writeInt(
ElemInt,
lib/std/fmt/float.zig
@@ -61,7 +61,7 @@ pub fn render(buf: []u8, value: anytype, options: Options) Error![]const u8 {
const T = @TypeOf(v);
comptime std.debug.assert(@typeInfo(T) == .float);
- const I = @Type(.{ .int = .{ .signedness = .unsigned, .bits = @bitSizeOf(T) } });
+ const I = @Int(.unsigned, @bitSizeOf(T));
const DT = if (@bitSizeOf(T) <= 64) u64 else u128;
const tables = switch (DT) {
@@ -1516,7 +1516,7 @@ const FLOAT128_POW5_INV_ERRORS: [154]u64 = .{
const builtin = @import("builtin");
fn check(comptime T: type, value: T, comptime expected: []const u8) !void {
- const I = @Type(.{ .int = .{ .signedness = .unsigned, .bits = @bitSizeOf(T) } });
+ const I = @Int(.unsigned, @bitSizeOf(T));
var buf: [6000]u8 = undefined;
const value_bits: I = @bitCast(value);
lib/std/hash/auto_hash.zig
@@ -91,10 +91,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
// Help the optimizer see that hashing an int is easy by inlining!
// TODO Check if the situation is better after #561 is resolved.
.int => |int| switch (int.signedness) {
- .signed => hash(hasher, @as(@Type(.{ .int = .{
- .bits = int.bits,
- .signedness = .unsigned,
- } }), @bitCast(key)), strat),
+ .signed => hash(hasher, @as(@Int(.unsigned, int.bits), @bitCast(key)), strat),
.unsigned => {
if (std.meta.hasUniqueRepresentation(Key)) {
@call(.always_inline, Hasher.update, .{ hasher, std.mem.asBytes(&key) });
lib/std/Io/Reader.zig
@@ -1273,20 +1273,17 @@ pub const TakeLeb128Error = Error || error{Overflow};
/// Read a single LEB128 value as type T, or `error.Overflow` if the value cannot fit.
pub fn takeLeb128(r: *Reader, comptime Result: type) TakeLeb128Error!Result {
const result_info = @typeInfo(Result).int;
- return std.math.cast(Result, try r.takeMultipleOf7Leb128(@Type(.{ .int = .{
- .signedness = result_info.signedness,
- .bits = std.mem.alignForwardAnyAlign(u16, result_info.bits, 7),
- } }))) orelse error.Overflow;
+ return std.math.cast(Result, try r.takeMultipleOf7Leb128(@Int(
+ result_info.signedness,
+ std.mem.alignForwardAnyAlign(u16, result_info.bits, 7),
+ ))) orelse error.Overflow;
}
fn takeMultipleOf7Leb128(r: *Reader, comptime Result: type) TakeLeb128Error!Result {
const result_info = @typeInfo(Result).int;
comptime assert(result_info.bits % 7 == 0);
var remaining_bits: std.math.Log2IntCeil(Result) = result_info.bits;
- const UnsignedResult = @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = result_info.bits,
- } });
+ const UnsignedResult = @Int(.unsigned, result_info.bits);
var result: UnsignedResult = 0;
var fits = true;
while (true) {
lib/std/Io/Writer.zig
@@ -1890,7 +1890,7 @@ pub fn writeUleb128(w: *Writer, value: anytype) Error!void {
try w.writeLeb128(switch (@typeInfo(@TypeOf(value))) {
.comptime_int => @as(std.math.IntFittingRange(0, @abs(value)), value),
.int => |value_info| switch (value_info.signedness) {
- .signed => @as(@Type(.{ .int = .{ .signedness = .unsigned, .bits = value_info.bits -| 1 } }), @intCast(value)),
+ .signed => @as(@Int(.unsigned, value_info.bits -| 1), @intCast(value)),
.unsigned => value,
},
else => comptime unreachable,
@@ -1903,7 +1903,7 @@ pub fn writeSleb128(w: *Writer, value: anytype) Error!void {
.comptime_int => @as(std.math.IntFittingRange(@min(value, -1), @max(0, value)), value),
.int => |value_info| switch (value_info.signedness) {
.signed => value,
- .unsigned => @as(@Type(.{ .int = .{ .signedness = .signed, .bits = value_info.bits + 1 } }), value),
+ .unsigned => @as(@Int(.signed, value_info.bits + 1), value),
},
else => comptime unreachable,
});
@@ -1912,10 +1912,10 @@ pub fn writeSleb128(w: *Writer, value: anytype) Error!void {
/// Write a single integer as LEB128 to the given writer.
pub fn writeLeb128(w: *Writer, value: anytype) Error!void {
const value_info = @typeInfo(@TypeOf(value)).int;
- try w.writeMultipleOf7Leb128(@as(@Type(.{ .int = .{
- .signedness = value_info.signedness,
- .bits = @max(std.mem.alignForwardAnyAlign(u16, value_info.bits, 7), 7),
- } }), value));
+ try w.writeMultipleOf7Leb128(@as(@Int(
+ value_info.signedness,
+ @max(std.mem.alignForwardAnyAlign(u16, value_info.bits, 7), 7),
+ ), value));
}
fn writeMultipleOf7Leb128(w: *Writer, value: anytype) Error!void {
@@ -1929,10 +1929,10 @@ fn writeMultipleOf7Leb128(w: *Writer, value: anytype) Error!void {
.unsigned => remaining > std.math.maxInt(u7),
};
byte.* = .{
- .bits = @bitCast(@as(@Type(.{ .int = .{
- .signedness = value_info.signedness,
- .bits = 7,
- } }), @truncate(remaining))),
+ .bits = @bitCast(@as(
+ @Int(value_info.signedness, 7),
+ @truncate(remaining),
+ )),
.more = more,
};
if (value_info.bits > 7) remaining >>= 7;
lib/std/math/big/int_test.zig
@@ -2787,11 +2787,11 @@ test "bitNotWrap more than two limbs" {
const bits = @bitSizeOf(Limb) * 4 + 2;
try res.bitNotWrap(&a, .unsigned, bits);
- const Unsigned = @Type(.{ .int = .{ .signedness = .unsigned, .bits = bits } });
+ const Unsigned = @Int(.unsigned, bits);
try testing.expectEqual((try res.toInt(Unsigned)), ~@as(Unsigned, maxInt(Limb)));
try res.bitNotWrap(&a, .signed, bits);
- const Signed = @Type(.{ .int = .{ .signedness = .signed, .bits = bits } });
+ const Signed = @Int(.signed, bits);
try testing.expectEqual((try res.toInt(Signed)), ~@as(Signed, maxInt(Limb)));
}
lib/std/math/float.zig
@@ -14,22 +14,10 @@ pub fn FloatRepr(comptime Float: type) type {
exponent: BiasedExponent,
sign: std.math.Sign,
- pub const StoredMantissa = @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = floatMantissaBits(Float),
- } });
- pub const Mantissa = @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = 1 + fractional_bits,
- } });
- pub const Exponent = @Type(.{ .int = .{
- .signedness = .signed,
- .bits = exponent_bits,
- } });
- pub const BiasedExponent = enum(@Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = exponent_bits,
- } })) {
+ pub const StoredMantissa = @Int(.unsigned, floatMantissaBits(Float));
+ pub const Mantissa = @Int(.unsigned, 1 + fractional_bits);
+ pub const Exponent = @Int(.signed, exponent_bits);
+ pub const BiasedExponent = enum(@Int(.unsigned, exponent_bits)) {
denormal = 0,
min_normal = 1,
zero = (1 << (exponent_bits - 1)) - 1,
@@ -56,14 +44,8 @@ pub fn FloatRepr(comptime Float: type) type {
fraction: Fraction,
exponent: Normalized.Exponent,
- pub const Fraction = @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = fractional_bits,
- } });
- pub const Exponent = @Type(.{ .int = .{
- .signedness = .signed,
- .bits = 1 + exponent_bits,
- } });
+ pub const Fraction = @Int(.unsigned, fractional_bits);
+ pub const Exponent = @Int(.signed, 1 + exponent_bits);
/// This currently truncates denormal values, which needs to be fixed before this can be used to
/// produce a rounded value.
@@ -122,7 +104,7 @@ inline fn mantissaOne(comptime T: type) comptime_int {
/// Creates floating point type T from an unbiased exponent and raw mantissa.
inline fn reconstructFloat(comptime T: type, comptime exponent: comptime_int, comptime mantissa: comptime_int) T {
- const TBits = @Type(.{ .int = .{ .signedness = .unsigned, .bits = @bitSizeOf(T) } });
+ const TBits = @Int(.unsigned, @bitSizeOf(T));
const biased_exponent = @as(TBits, exponent + floatExponentMax(T));
return @as(T, @bitCast((biased_exponent << floatMantissaBits(T)) | @as(TBits, mantissa)));
}
@@ -209,7 +191,7 @@ pub inline fn floatEps(comptime T: type) T {
pub inline fn floatEpsAt(comptime T: type, x: T) T {
switch (@typeInfo(T)) {
.float => |F| {
- const U: type = @Type(.{ .int = .{ .signedness = .unsigned, .bits = F.bits } });
+ const U: type = @Int(.unsigned, F.bits);
const u: U = @bitCast(x);
const y: T = @bitCast(u ^ 1);
return @abs(x - y);
lib/std/math/log2.zig
@@ -33,10 +33,7 @@ pub fn log2(x: anytype) @TypeOf(x) {
return result;
},
.int => |int_info| math.log2_int(switch (int_info.signedness) {
- .signed => @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = int_info.bits -| 1,
- } }),
+ .signed => @Int(.unsigned, int_info.bits -| 1),
.unsigned => T,
}, @intCast(x)),
else => @compileError("log2 not implemented for " ++ @typeName(T)),
lib/std/math/log_int.zig
@@ -65,7 +65,7 @@ test "log_int" {
// Test all unsigned integers with 2, 3, ..., 64 bits.
// We cannot test 0 or 1 bits since base must be > 1.
inline for (2..64 + 1) |bits| {
- const T = @Type(.{ .int = .{ .signedness = .unsigned, .bits = @intCast(bits) } });
+ const T = @Int(.unsigned, @intCast(bits));
// for base = 2, 3, ..., min(maxInt(T),1024)
var base: T = 1;
lib/std/math/signbit.zig
@@ -6,10 +6,7 @@ const expect = std.testing.expect;
pub fn signbit(x: anytype) bool {
return switch (@typeInfo(@TypeOf(x))) {
.int, .comptime_int => x,
- .float => |float| @as(@Type(.{ .int = .{
- .signedness = .signed,
- .bits = float.bits,
- } }), @bitCast(x)),
+ .float => |float| @as(@Int(.signed, float.bits), @bitCast(x)),
.comptime_float => @as(i128, @bitCast(@as(f128, x))), // any float type will do
else => @compileError("std.math.signbit does not support " ++ @typeName(@TypeOf(x))),
} < 0;
lib/std/math/sqrt.zig
@@ -80,7 +80,7 @@ test sqrt_int {
/// Returns the return type `sqrt` will return given an operand of type `T`.
pub fn Sqrt(comptime T: type) type {
return switch (@typeInfo(T)) {
- .int => |int| @Type(.{ .int = .{ .signedness = .unsigned, .bits = (int.bits + 1) / 2 } }),
+ .int => |int| @Int(.unsigned, (int.bits + 1) / 2),
else => T,
};
}
lib/std/meta/trailer_flags.zig
@@ -20,24 +20,16 @@ pub fn TrailerFlags(comptime Fields: type) type {
pub const ActiveFields = std.enums.EnumFieldStruct(FieldEnum, bool, false);
pub const FieldValues = blk: {
- var fields: [bit_count]Type.StructField = undefined;
- for (@typeInfo(Fields).@"struct".fields, 0..) |struct_field, i| {
- fields[i] = Type.StructField{
- .name = struct_field.name,
- .type = ?struct_field.type,
- .default_value_ptr = &@as(?struct_field.type, null),
- .is_comptime = false,
- .alignment = @alignOf(?struct_field.type),
- };
+ 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;
+ new_attrs.* = .{ .default_value_ptr = &default };
}
- break :blk @Type(.{
- .@"struct" = .{
- .layout = .auto,
- .fields = &fields,
- .decls = &.{},
- .is_tuple = false,
- },
- });
+ break :blk @Struct(.auto, null, &field_names, &field_types, &field_attrs);
};
pub const Self = @This();
lib/std/zig/c_translation/helpers.zig
@@ -81,23 +81,15 @@ fn ToUnsigned(comptime T: type) type {
}
/// Constructs a [*c] pointer with the const and volatile annotations
-/// from SelfType for pointing to a C flexible array of ElementType.
-pub fn FlexibleArrayType(comptime SelfType: type, comptime ElementType: type) type {
- switch (@typeInfo(SelfType)) {
- .pointer => |ptr| {
- return @Type(.{ .pointer = .{
- .size = .c,
- .is_const = ptr.is_const,
- .is_volatile = ptr.is_volatile,
- .alignment = @alignOf(ElementType),
- .address_space = .generic,
- .child = ElementType,
- .is_allowzero = true,
- .sentinel_ptr = null,
- } });
- },
- else => |info| @compileError("Invalid self type \"" ++ @tagName(info) ++ "\" for flexible array getter: " ++ @typeName(SelfType)),
- }
+/// from Self for pointing to a C flexible array of Element.
+pub fn FlexibleArrayType(comptime Self: type, comptime Element: type) type {
+ return switch (@typeInfo(Self)) {
+ .pointer => |ptr| @Pointer(.c, .{
+ .@"const" = ptr.is_const,
+ .@"volatile" = ptr.is_volatile,
+ }, Element, null),
+ else => |info| @compileError("Invalid self type \"" ++ @tagName(info) ++ "\" for flexible array getter: " ++ @typeName(Self)),
+ };
}
/// Promote the type of an integer literal until it fits as C would.
@@ -219,7 +211,7 @@ fn castInt(comptime DestType: type, target: anytype) DestType {
const dest = @typeInfo(DestType).int;
const source = @typeInfo(@TypeOf(target)).int;
- const Int = @Type(.{ .int = .{ .bits = dest.bits, .signedness = source.signedness } });
+ const Int = @Int(source.signedness, dest.bits);
if (dest.bits < source.bits)
return @as(DestType, @bitCast(@as(Int, @truncate(target))))
lib/std/zig/llvm/Builder.zig
@@ -8614,39 +8614,18 @@ pub const Metadata = packed struct(u32) {
nodes: anytype,
w: *Writer,
) !void {
- comptime var fmt_str: []const u8 = "";
const names = comptime std.meta.fieldNames(@TypeOf(nodes));
- comptime var fields: [2 + names.len]std.builtin.Type.StructField = undefined;
- inline for (fields[0..2], .{ "distinct", "node" }) |*field, name| {
- fmt_str = fmt_str ++ "{[" ++ name ++ "]s}";
- field.* = .{
- .name = name,
- .type = []const u8,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf([]const u8),
- };
- }
- fmt_str = fmt_str ++ "(";
- inline for (fields[2..], names) |*field, name| {
- fmt_str = fmt_str ++ "{[" ++ name ++ "]f}";
- const T = std.fmt.Alt(FormatData, format);
- field.* = .{
- .name = name,
- .type = T,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(T),
- };
- }
+
+ comptime var fmt_str: []const u8 = "{[distinct]s}{[node]s}(";
+ inline for (names) |name| fmt_str = fmt_str ++ "{[" ++ name ++ "]f}";
fmt_str = fmt_str ++ ")\n";
- var fmt_args: @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &fields,
- .decls = &.{},
- .is_tuple = false,
- } }) = undefined;
+ const field_names = @as([]const []const u8, &.{ "distinct", "node" }) ++ names;
+ comptime var field_types: [2 + names.len]type = undefined;
+ @memset(field_types[0..2], []const u8);
+ @memset(field_types[2..], std.fmt.Alt(FormatData, format));
+
+ var fmt_args: @Struct(.auto, null, field_names, &field_types, &@splat(.{})) = undefined;
fmt_args.distinct = @tagName(distinct);
fmt_args.node = @tagName(node);
inline for (names) |name| @field(fmt_args, name) = try formatter.fmt(
lib/std/Build.zig
@@ -416,7 +416,7 @@ fn createChildOnly(
fn userInputOptionsFromArgs(arena: Allocator, args: anytype) UserInputOptionsMap {
var map = UserInputOptionsMap.init(arena);
inline for (@typeInfo(@TypeOf(args)).@"struct".fields) |field| {
- if (field.type == @Type(.null)) continue;
+ if (field.type == @TypeOf(null)) continue;
addUserInputOptionFromArg(arena, &map, field, field.type, @field(args, field.name));
}
return map;
@@ -526,16 +526,11 @@ fn addUserInputOptionFromArg(
.pointer => |ptr_info| switch (ptr_info.size) {
.one => switch (@typeInfo(ptr_info.child)) {
.array => |array_info| {
- comptime var slice_info = ptr_info;
- slice_info.size = .slice;
- slice_info.is_const = true;
- slice_info.child = array_info.child;
- slice_info.sentinel_ptr = null;
addUserInputOptionFromArg(
arena,
map,
field,
- @Type(.{ .pointer = slice_info }),
+ @Pointer(.slice, .{ .@"const" = true }, array_info.child, null),
maybe_value orelse null,
);
return;
@@ -553,14 +548,11 @@ fn addUserInputOptionFromArg(
}) catch @panic("OOM");
},
else => {
- comptime var slice_info = ptr_info;
- slice_info.is_const = true;
- slice_info.sentinel_ptr = null;
addUserInputOptionFromArg(
arena,
map,
field,
- @Type(.{ .pointer = slice_info }),
+ @Pointer(ptr_info.size, .{ .@"const" = true }, ptr_info.child, null),
maybe_value orelse null,
);
return;
lib/std/enums.zig
@@ -33,22 +33,8 @@ pub fn fromInt(comptime E: type, integer: anytype) ?E {
/// default, which may be undefined.
pub fn EnumFieldStruct(comptime E: type, comptime Data: type, comptime field_default: ?Data) type {
@setEvalBranchQuota(@typeInfo(E).@"enum".fields.len + eval_branch_quota_cushion);
- var struct_fields: [@typeInfo(E).@"enum".fields.len]std.builtin.Type.StructField = undefined;
- for (&struct_fields, @typeInfo(E).@"enum".fields) |*struct_field, enum_field| {
- struct_field.* = .{
- .name = enum_field.name,
- .type = Data,
- .default_value_ptr = if (field_default) |d| @as(?*const anyopaque, @ptrCast(&d)) else null,
- .is_comptime = false,
- .alignment = if (@sizeOf(Data) > 0) @alignOf(Data) else 0,
- };
- }
- return @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &struct_fields,
- .decls = &.{},
- .is_tuple = false,
- } });
+ const default_ptr: ?*const anyopaque = if (field_default) |d| @ptrCast(&d) else null;
+ return @Struct(.auto, null, std.meta.fieldNames(E), &@splat(Data), &@splat(.{ .default_value_ptr = default_ptr }));
}
/// Looks up the supplied fields in the given enum type.
@@ -1532,19 +1518,15 @@ test "EnumIndexer empty" {
test "EnumIndexer large dense unsorted" {
@setEvalBranchQuota(500_000); // many `comptimePrint`s
// Make an enum with 500 fields with values in *descending* order.
- const E = @Type(.{ .@"enum" = .{
- .tag_type = u32,
- .fields = comptime fields: {
- var fields: [500]EnumField = undefined;
- for (&fields, 0..) |*f, i| f.* = .{
- .name = std.fmt.comptimePrint("f{d}", .{i}),
- .value = 500 - i,
- };
- break :fields &fields;
- },
- .decls = &.{},
- .is_exhaustive = true,
- } });
+ const E = @Enum(u32, .exhaustive, names: {
+ var names: [500][]const u8 = undefined;
+ for (&names, 0..) |*name, i| name.* = std.fmt.comptimePrint("f{d}", .{i});
+ break :names &names;
+ }, vals: {
+ var vals: [500]u32 = undefined;
+ for (&vals, 0..) |*val, i| val.* = 500 - i;
+ break :vals &vals;
+ });
const Indexer = EnumIndexer(E);
try testing.expectEqual(E.f0, Indexer.keyForIndex(499));
try testing.expectEqual(E.f499, Indexer.keyForIndex(0));
lib/std/fmt.zig
@@ -279,7 +279,7 @@ pub fn Alt(
/// Helper for calling alternate format methods besides one named "format".
pub fn alt(
context: anytype,
- comptime func_name: @TypeOf(.enum_literal),
+ comptime func_name: @EnumLiteral(),
) Alt(@TypeOf(context), @field(@TypeOf(context), @tagName(func_name))) {
return .{ .data = context };
}
lib/std/hash.zig
@@ -42,7 +42,7 @@ pub fn int(input: anytype) @TypeOf(input) {
const info = @typeInfo(@TypeOf(input)).int;
const bits = info.bits;
// Convert input to unsigned integer (easier to deal with)
- const Uint = @Type(.{ .int = .{ .bits = bits, .signedness = .unsigned } });
+ const Uint = @Int(.unsigned, bits);
const u_input: Uint = @bitCast(input);
if (bits > 256) @compileError("bit widths > 256 are unsupported, use std.hash.autoHash functionality.");
// For bit widths that don't have a dedicated function, use a heuristic
lib/std/Io.zig
@@ -528,23 +528,7 @@ pub fn Poller(comptime StreamEnum: type) type {
/// Given an enum, returns a struct with fields of that enum, each field
/// representing an I/O stream for polling.
pub fn PollFiles(comptime StreamEnum: type) type {
- const enum_fields = @typeInfo(StreamEnum).@"enum".fields;
- var struct_fields: [enum_fields.len]std.builtin.Type.StructField = undefined;
- for (&struct_fields, enum_fields) |*struct_field, enum_field| {
- struct_field.* = .{
- .name = enum_field.name,
- .type = std.fs.File,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(std.fs.File),
- };
- }
- return @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &struct_fields,
- .decls = &.{},
- .is_tuple = false,
- } });
+ return @Struct(.auto, null, std.meta.fieldNames(StreamEnum), &@splat(std.fs.File), &@splat(.{}));
}
test {
@@ -1625,22 +1609,14 @@ pub fn sleep(io: Io, duration: Duration, clock: Clock) SleepError!void {
/// fields, each field type the future's result.
pub fn SelectUnion(S: type) type {
const struct_fields = @typeInfo(S).@"struct".fields;
- var fields: [struct_fields.len]std.builtin.Type.UnionField = undefined;
- for (&fields, struct_fields) |*union_field, struct_field| {
- const F = @typeInfo(struct_field.type).pointer.child;
- const Result = @TypeOf(@as(F, undefined).result);
- union_field.* = .{
- .name = struct_field.name,
- .type = Result,
- .alignment = struct_field.alignment,
- };
+ var names: [struct_fields.len][]const u8 = undefined;
+ var types: [struct_fields.len]type = undefined;
+ for (struct_fields, &names, &types) |struct_field, *union_field_name, *UnionFieldType| {
+ const FieldFuture = @typeInfo(struct_field.type).pointer.child;
+ union_field_name.* = struct_field.name;
+ UnionFieldType.* = @FieldType(FieldFuture, "result");
}
- return @Type(.{ .@"union" = .{
- .layout = .auto,
- .tag_type = std.meta.FieldEnum(S),
- .fields = &fields,
- .decls = &.{},
- } });
+ return @Union(.auto, std.meta.FieldEnum(S), &names, &types, &@splat(.{}));
}
/// `s` is a struct with every field a `*Future(T)`, where `T` can be any type,
lib/std/log.zig
@@ -57,13 +57,13 @@ pub const default_level: Level = switch (builtin.mode) {
};
pub const ScopeLevel = struct {
- scope: @Type(.enum_literal),
+ scope: @EnumLiteral(),
level: Level,
};
fn log(
comptime level: Level,
- comptime scope: @Type(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
@@ -73,7 +73,7 @@ fn log(
}
/// Determine if a specific log message level and scope combination are enabled for logging.
-pub fn logEnabled(comptime level: Level, comptime scope: @Type(.enum_literal)) bool {
+pub fn logEnabled(comptime level: Level, comptime scope: @EnumLiteral()) bool {
inline for (std.options.log_scope_levels) |scope_level| {
if (scope_level.scope == scope) return @intFromEnum(level) <= @intFromEnum(scope_level.level);
}
@@ -87,7 +87,7 @@ pub fn logEnabled(comptime level: Level, comptime scope: @Type(.enum_literal)) b
/// function returns.
pub fn defaultLog(
comptime level: Level,
- comptime scope: @Type(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
@@ -115,7 +115,7 @@ pub fn defaultLog(
/// Returns a scoped logging namespace that logs all messages using the scope
/// provided here.
-pub fn scoped(comptime scope: @Type(.enum_literal)) type {
+pub fn scoped(comptime scope: @EnumLiteral()) type {
return struct {
/// Log an error message. This log level is intended to be used
/// when something has gone wrong. This might be recoverable or might
lib/std/math.zig
@@ -450,12 +450,7 @@ pub fn wrap(x: anytype, r: anytype) @TypeOf(x) {
// in the rare usecase of r not being comptime_int or float,
// take the penalty of having an intermediary type conversion,
// otherwise the alternative is to unwind iteratively to avoid overflow
- const R = comptime do: {
- var info = info_r;
- info.int.bits += 1;
- info.int.signedness = .signed;
- break :do @Type(info);
- };
+ const R = @Int(.signed, info_r.int.bits + 1);
const radius: if (info_r.int.signedness == .signed) @TypeOf(r) else R = r;
return @intCast(@mod(x - radius, 2 * @as(R, r)) - r); // provably impossible to overflow
},
@@ -799,14 +794,14 @@ pub fn Log2IntCeil(comptime T: type) type {
pub fn IntFittingRange(comptime from: comptime_int, comptime to: comptime_int) type {
assert(from <= to);
const signedness: std.builtin.Signedness = if (from < 0) .signed else .unsigned;
- return @Type(.{ .int = .{
- .signedness = signedness,
- .bits = @as(u16, @intFromBool(signedness == .signed)) +
+ return @Int(
+ signedness,
+ @as(u16, @intFromBool(signedness == .signed)) +
switch (if (from < 0) @max(@abs(from) - 1, to) else to) {
0 => 0,
else => |pos_max| 1 + log2(pos_max),
},
- } });
+ );
}
test IntFittingRange {
@@ -1107,9 +1102,14 @@ test cast {
pub const AlignCastError = error{UnalignedMemory};
fn AlignCastResult(comptime alignment: Alignment, comptime Ptr: type) type {
- var ptr_info = @typeInfo(Ptr);
- ptr_info.pointer.alignment = alignment.toByteUnits();
- return @Type(ptr_info);
+ const orig = @typeInfo(Ptr).pointer;
+ return @Pointer(orig.size, .{
+ .@"const" = orig.is_const,
+ .@"volatile" = orig.is_volatile,
+ .@"allowzero" = orig.is_allowzero,
+ .@"align" = alignment.toByteUnits(),
+ .@"addrspace" = orig.address_space,
+ }, orig.child, orig.sentinel());
}
/// Align cast a pointer but return an error if it's the wrong alignment
lib/std/mem.zig
@@ -846,17 +846,18 @@ fn Span(comptime T: type) type {
return ?Span(optional_info.child);
},
.pointer => |ptr_info| {
- var new_ptr_info = ptr_info;
- switch (ptr_info.size) {
- .c => {
- new_ptr_info.sentinel_ptr = &@as(ptr_info.child, 0);
- new_ptr_info.is_allowzero = false;
- },
- .many => if (ptr_info.sentinel() == null) @compileError("invalid type given to std.mem.span: " ++ @typeName(T)),
+ const new_sentinel: ?ptr_info.child = switch (ptr_info.size) {
.one, .slice => @compileError("invalid type given to std.mem.span: " ++ @typeName(T)),
- }
- new_ptr_info.size = .slice;
- return @Type(.{ .pointer = new_ptr_info });
+ .many => ptr_info.sentinel() orelse @compileError("invalid type given to std.mem.span: " ++ @typeName(T)),
+ .c => 0,
+ };
+ return @Pointer(.slice, .{
+ .@"const" = ptr_info.is_const,
+ .@"volatile" = ptr_info.is_volatile,
+ .@"allowzero" = ptr_info.is_allowzero and ptr_info.size != .c,
+ .@"align" = ptr_info.alignment,
+ .@"addrspace" = ptr_info.address_space,
+ }, ptr_info.child, new_sentinel);
},
else => {},
}
@@ -910,45 +911,18 @@ fn SliceTo(comptime T: type, comptime end: std.meta.Elem(T)) type {
return ?SliceTo(optional_info.child, end);
},
.pointer => |ptr_info| {
- var new_ptr_info = ptr_info;
- new_ptr_info.size = .slice;
- switch (ptr_info.size) {
- .one => switch (@typeInfo(ptr_info.child)) {
- .array => |array_info| {
- new_ptr_info.child = array_info.child;
- // The return type must only be sentinel terminated if we are guaranteed
- // to find the value searched for, which is only the case if it matches
- // the sentinel of the type passed.
- if (array_info.sentinel()) |s| {
- if (end == s) {
- new_ptr_info.sentinel_ptr = &end;
- } else {
- new_ptr_info.sentinel_ptr = null;
- }
- }
- },
- else => {},
- },
- .many, .slice => {
- // The return type must only be sentinel terminated if we are guaranteed
- // to find the value searched for, which is only the case if it matches
- // the sentinel of the type passed.
- if (ptr_info.sentinel()) |s| {
- if (end == s) {
- new_ptr_info.sentinel_ptr = &end;
- } else {
- new_ptr_info.sentinel_ptr = null;
- }
- }
- },
- .c => {
- new_ptr_info.sentinel_ptr = &end;
- // C pointers are always allowzero, but we don't want the return type to be.
- assert(new_ptr_info.is_allowzero);
- new_ptr_info.is_allowzero = false;
- },
- }
- return @Type(.{ .pointer = new_ptr_info });
+ const Elem = std.meta.Elem(T);
+ const have_sentinel: bool = switch (ptr_info.size) {
+ .one, .slice, .many => if (std.meta.sentinel(T)) |s| s == end else false,
+ .c => false,
+ };
+ return @Pointer(.slice, .{
+ .@"const" = ptr_info.is_const,
+ .@"volatile" = ptr_info.is_volatile,
+ .@"allowzero" = ptr_info.is_allowzero and ptr_info.size != .c,
+ .@"align" = ptr_info.alignment,
+ .@"addrspace" = ptr_info.address_space,
+ }, Elem, if (have_sentinel) end else null);
},
else => {},
}
@@ -3951,38 +3925,25 @@ test reverse {
}
}
fn ReverseIterator(comptime T: type) type {
- const Pointer = blk: {
- switch (@typeInfo(T)) {
- .pointer => |ptr_info| switch (ptr_info.size) {
- .one => switch (@typeInfo(ptr_info.child)) {
- .array => |array_info| {
- var new_ptr_info = ptr_info;
- new_ptr_info.size = .many;
- new_ptr_info.child = array_info.child;
- new_ptr_info.sentinel_ptr = array_info.sentinel_ptr;
- break :blk @Type(.{ .pointer = new_ptr_info });
- },
- else => {},
- },
- .slice => {
- var new_ptr_info = ptr_info;
- new_ptr_info.size = .many;
- break :blk @Type(.{ .pointer = new_ptr_info });
- },
- else => {},
- },
- else => {},
- }
- @compileError("expected slice or pointer to array, found '" ++ @typeName(T) ++ "'");
+ const ptr = switch (@typeInfo(T)) {
+ .pointer => |ptr| ptr,
+ else => @compileError("expected slice or pointer to array, found '" ++ @typeName(T) ++ "'"),
};
- const Element = std.meta.Elem(Pointer);
- const ElementPointer = @Type(.{ .pointer = ptr: {
- var ptr = @typeInfo(Pointer).pointer;
- ptr.size = .one;
- ptr.child = Element;
- ptr.sentinel_ptr = null;
- break :ptr ptr;
- } });
+ switch (ptr.size) {
+ .slice => {},
+ .one => if (@typeInfo(ptr.child) != .array) @compileError("expected slice or pointer to array, found '" ++ @typeName(T) ++ "'"),
+ .many, .c => @compileError("expected slice or pointer to array, found '" ++ @typeName(T) ++ "'"),
+ }
+ const Element = std.meta.Elem(T);
+ const attrs: std.builtin.Type.Pointer.Attributes = .{
+ .@"const" = ptr.is_const,
+ .@"volatile" = ptr.is_volatile,
+ .@"allowzero" = ptr.is_allowzero,
+ .@"align" = ptr.alignment,
+ .@"addrspace" = ptr.address_space,
+ };
+ const Pointer = @Pointer(.many, attrs, Element, std.meta.sentinel(T));
+ const ElementPointer = @Pointer(.one, attrs, Element, null);
return struct {
ptr: Pointer,
index: usize,
@@ -4342,19 +4303,14 @@ fn CopyPtrAttrs(
comptime size: std.builtin.Type.Pointer.Size,
comptime child: type,
) type {
- const info = @typeInfo(source).pointer;
- return @Type(.{
- .pointer = .{
- .size = size,
- .is_const = info.is_const,
- .is_volatile = info.is_volatile,
- .is_allowzero = info.is_allowzero,
- .alignment = info.alignment,
- .address_space = info.address_space,
- .child = child,
- .sentinel_ptr = null,
- },
- });
+ const ptr = @typeInfo(source).pointer;
+ return @Pointer(size, .{
+ .@"const" = ptr.is_const,
+ .@"volatile" = ptr.is_volatile,
+ .@"allowzero" = ptr.is_allowzero,
+ .@"align" = ptr.alignment,
+ .@"addrspace" = ptr.address_space,
+ }, child, null);
}
fn AsBytesReturnType(comptime P: type) type {
@@ -4936,19 +4892,14 @@ test "freeing empty string with null-terminated sentinel" {
/// Returns a slice with the given new alignment,
/// all other pointer attributes copied from `AttributeSource`.
fn AlignedSlice(comptime AttributeSource: type, comptime new_alignment: usize) type {
- const info = @typeInfo(AttributeSource).pointer;
- return @Type(.{
- .pointer = .{
- .size = .slice,
- .is_const = info.is_const,
- .is_volatile = info.is_volatile,
- .is_allowzero = info.is_allowzero,
- .alignment = new_alignment,
- .address_space = info.address_space,
- .child = info.child,
- .sentinel_ptr = null,
- },
- });
+ const ptr = @typeInfo(AttributeSource).pointer;
+ return @Pointer(.slice, .{
+ .@"const" = ptr.is_const,
+ .@"volatile" = ptr.is_volatile,
+ .@"allowzero" = ptr.is_allowzero,
+ .@"align" = new_alignment,
+ .@"addrspace" = ptr.address_space,
+ }, ptr.child, null);
}
/// Returns the largest slice in the given bytes that conforms to the new alignment,
lib/std/meta.zig
@@ -171,58 +171,34 @@ 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 @Type(.{
- .pointer = .{
- .size = info.size,
- .is_const = info.is_const,
- .is_volatile = info.is_volatile,
- .alignment = info.alignment,
- .address_space = info.address_space,
- .child = @Type(.{
- .array = .{
- .len = array_info.len,
- .child = array_info.child,
- .sentinel_ptr = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
- },
- }),
- .is_allowzero = info.is_allowzero,
- .sentinel_ptr = info.sentinel_ptr,
- },
- }),
+ .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),
else => {},
},
- .many, .slice => return @Type(.{
- .pointer = .{
- .size = info.size,
- .is_const = info.is_const,
- .is_volatile = info.is_volatile,
- .alignment = info.alignment,
- .address_space = info.address_space,
- .child = info.child,
- .is_allowzero = info.is_allowzero,
- .sentinel_ptr = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
- },
- }),
+ .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),
else => {},
},
.optional => |info| switch (@typeInfo(info.child)) {
.pointer => |ptr_info| switch (ptr_info.size) {
- .many => return @Type(.{
- .optional = .{
- .child = @Type(.{
- .pointer = .{
- .size = ptr_info.size,
- .is_const = ptr_info.is_const,
- .is_volatile = ptr_info.is_volatile,
- .alignment = ptr_info.alignment,
- .address_space = ptr_info.address_space,
- .child = ptr_info.child,
- .is_allowzero = ptr_info.is_allowzero,
- .sentinel_ptr = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
- },
- }),
- },
- }),
+ .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),
else => {},
},
else => {},
@@ -487,46 +463,22 @@ test tags {
/// Returns an enum with a variant named after each field of `T`.
pub fn FieldEnum(comptime T: type) type {
- const field_infos = fields(T);
-
- if (field_infos.len == 0) {
- return @Type(.{
- .@"enum" = .{
- .tag_type = u0,
- .fields = &.{},
- .decls = &.{},
- .is_exhaustive = true,
- },
- });
- }
+ const field_names = fieldNames(T);
- if (@typeInfo(T) == .@"union") {
- if (@typeInfo(T).@"union".tag_type) |tag_type| {
- for (std.enums.values(tag_type), 0..) |v, i| {
+ switch (@typeInfo(T)) {
+ .@"union" => |@"union"| if (@"union".tag_type) |EnumTag| {
+ for (std.enums.values(EnumTag), 0..) |v, i| {
if (@intFromEnum(v) != i) break; // enum values not consecutive
- if (!std.mem.eql(u8, @tagName(v), field_infos[i].name)) break; // fields out of order
+ if (!std.mem.eql(u8, @tagName(v), field_names[i])) break; // fields out of order
} else {
- return tag_type;
+ return EnumTag;
}
- }
+ },
+ else => {},
}
- var enumFields: [field_infos.len]std.builtin.Type.EnumField = undefined;
- var decls = [_]std.builtin.Type.Declaration{};
- inline for (field_infos, 0..) |field, i| {
- enumFields[i] = .{
- .name = field.name,
- .value = i,
- };
- }
- return @Type(.{
- .@"enum" = .{
- .tag_type = std.math.IntFittingRange(0, field_infos.len - 1),
- .fields = &enumFields,
- .decls = &decls,
- .is_exhaustive = true,
- },
- });
+ const IntTag = std.math.IntFittingRange(0, field_names.len -| 1);
+ return @Enum(IntTag, .exhaustive, field_names, &std.simd.iota(IntTag, field_names.len));
}
fn expectEqualEnum(expected: anytype, actual: @TypeOf(expected)) !void {
@@ -583,20 +535,11 @@ test FieldEnum {
}
pub fn DeclEnum(comptime T: type) type {
- const fieldInfos = std.meta.declarations(T);
- var enumDecls: [fieldInfos.len]std.builtin.Type.EnumField = undefined;
- var decls = [_]std.builtin.Type.Declaration{};
- inline for (fieldInfos, 0..) |field, i| {
- enumDecls[i] = .{ .name = field.name, .value = i };
- }
- return @Type(.{
- .@"enum" = .{
- .tag_type = std.math.IntFittingRange(0, if (fieldInfos.len == 0) 0 else fieldInfos.len - 1),
- .fields = &enumDecls,
- .decls = &decls,
- .is_exhaustive = true,
- },
- });
+ 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));
}
test DeclEnum {
@@ -868,25 +811,26 @@ pub fn declList(comptime Namespace: type, comptime Decl: type) []const *const De
}
}
+/// Deprecated: use @Int
pub fn Int(comptime signedness: std.builtin.Signedness, comptime bit_count: u16) type {
- return @Type(.{
- .int = .{
- .signedness = signedness,
- .bits = bit_count,
- },
- });
+ return @Int(signedness, bit_count);
}
pub fn Float(comptime bit_count: u8) type {
- return @Type(.{
- .float = .{ .bits = bit_count },
- });
+ return switch (bit_count) {
+ 16 => f16,
+ 32 => f32,
+ 64 => f64,
+ 80 => f80,
+ 128 => f128,
+ else => @compileError("invalid float bit count"),
+ };
}
-
test Float {
try testing.expectEqual(f16, Float(16));
try testing.expectEqual(f32, Float(32));
try testing.expectEqual(f64, Float(64));
+ try testing.expectEqual(f80, Float(80));
try testing.expectEqual(f128, Float(128));
}
@@ -912,42 +856,14 @@ pub fn ArgsTuple(comptime Function: type) type {
argument_field_list[i] = T;
}
- return CreateUniqueTuple(argument_field_list.len, argument_field_list);
+ return Tuple(&argument_field_list);
}
-/// For a given anonymous list of types, returns a new tuple type
-/// with those types as fields.
+/// Deprecated; use `@Tuple` instead.
///
-/// Examples:
-/// - `Tuple(&[_]type {})` ⇒ `tuple { }`
-/// - `Tuple(&[_]type {f32})` ⇒ `tuple { f32 }`
-/// - `Tuple(&[_]type {f32,u32})` ⇒ `tuple { f32, u32 }`
+/// To be removed after Zig 0.16.0 releases.
pub fn Tuple(comptime types: []const type) type {
- return CreateUniqueTuple(types.len, types[0..types.len].*);
-}
-
-fn CreateUniqueTuple(comptime N: comptime_int, comptime types: [N]type) type {
- var tuple_fields: [types.len]std.builtin.Type.StructField = undefined;
- inline for (types, 0..) |T, i| {
- @setEvalBranchQuota(10_000);
- var num_buf: [128]u8 = undefined;
- tuple_fields[i] = .{
- .name = std.fmt.bufPrintSentinel(&num_buf, "{d}", .{i}, 0) catch unreachable,
- .type = T,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(T),
- };
- }
-
- return @Type(.{
- .@"struct" = .{
- .is_tuple = true,
- .layout = .auto,
- .decls = &.{},
- .fields = &tuple_fields,
- },
- });
+ return @Tuple(types);
}
const TupleTester = struct {
lib/std/multi_array_list.zig
@@ -32,12 +32,17 @@ pub fn MultiArrayList(comptime T: type) type {
const Elem = switch (@typeInfo(T)) {
.@"struct" => T,
.@"union" => |u| struct {
- pub const Bare = @Type(.{ .@"union" = .{
- .layout = u.layout,
- .tag_type = null,
- .fields = u.fields,
- .decls = &.{},
- } });
+ pub const Bare = Bare: {
+ var field_names: [u.fields.len][]const u8 = undefined;
+ var field_types: [u.fields.len]type = undefined;
+ var field_attrs: [u.fields.len]std.builtin.Type.UnionField.Attributes = undefined;
+ for (u.fields, &field_names, &field_types, &field_attrs) |field, *name, *Type, *attrs| {
+ name.* = field.name;
+ Type.* = field.type;
+ attrs.* = .{ .@"align" = field.alignment };
+ }
+ break :Bare @Union(u.layout, null, &field_names, &field_types, &field_attrs);
+ };
pub const Tag =
u.tag_type orelse @compileError("MultiArrayList does not support untagged unions");
tags: Tag,
@@ -609,20 +614,18 @@ pub fn MultiArrayList(comptime T: type) type {
}
const Entry = entry: {
- var entry_fields: [fields.len]std.builtin.Type.StructField = undefined;
- for (&entry_fields, sizes.fields) |*entry_field, i| entry_field.* = .{
- .name = fields[i].name ++ "_ptr",
- .type = *fields[i].type,
- .default_value_ptr = null,
- .is_comptime = fields[i].is_comptime,
- .alignment = fields[i].alignment,
- };
- break :entry @Type(.{ .@"struct" = .{
- .layout = .@"extern",
- .fields = &entry_fields,
- .decls = &.{},
- .is_tuple = false,
- } });
+ var field_names: [fields.len][]const u8 = undefined;
+ var field_types: [fields.len]type = undefined;
+ var field_attrs: [fields.len]std.builtin.Type.StructField.Attributes = undefined;
+ for (sizes.fields, &field_names, &field_types, &field_attrs) |i, *name, *Type, *attrs| {
+ name.* = fields[i].name ++ "_ptr";
+ Type.* = *fields[i].type;
+ attrs.* = .{
+ .@"comptime" = fields[i].is_comptime,
+ .@"align" = fields[i].alignment,
+ };
+ }
+ break :entry @Struct(.@"extern", null, &field_names, &field_types, &field_attrs);
};
/// This function is used in the debugger pretty formatters in tools/ to fetch the
/// child field order and entry type to facilitate fancy debug printing for this type.
@@ -1023,23 +1026,9 @@ test "struct with many fields" {
const ManyFields = struct {
fn Type(count: comptime_int) type {
@setEvalBranchQuota(50000);
- var fields: [count]std.builtin.Type.StructField = undefined;
- for (0..count) |i| {
- fields[i] = .{
- .name = std.fmt.comptimePrint("a{}", .{i}),
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(u32),
- };
- }
- const info: std.builtin.Type = .{ .@"struct" = .{
- .layout = .auto,
- .fields = &fields,
- .decls = &.{},
- .is_tuple = false,
- } };
- return @Type(info);
+ var field_names: [count][]const u8 = undefined;
+ for (&field_names, 0..) |*n, i| n.* = std.fmt.comptimePrint("a{d}", .{i});
+ return @Struct(.@"extern", null, &field_names, &@splat(u32), &@splat(.{}));
}
fn doTest(ally: std.mem.Allocator, count: comptime_int) !void {
lib/std/std.zig
@@ -124,7 +124,7 @@ pub const Options = struct {
logFn: fn (
comptime message_level: log.Level,
- comptime scope: @TypeOf(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void = log.defaultLog,
lib/fuzzer.zig
@@ -15,7 +15,7 @@ pub const std_options = std.Options{
fn logOverride(
comptime level: std.log.Level,
- comptime scope: @Type(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
src/codegen/aarch64/Assemble.zig
@@ -120,23 +120,13 @@ const matchers = matchers: {
);
var symbols: Symbols: {
const symbols = @typeInfo(@TypeOf(instruction.symbols)).@"struct".fields;
- var symbol_fields: [symbols.len]std.builtin.Type.StructField = undefined;
- for (&symbol_fields, symbols) |*symbol_field, symbol| {
- const Storage = zonCast(SymbolSpec, @field(instruction.symbols, symbol.name), .{}).Storage();
- symbol_field.* = .{
- .name = symbol.name,
- .type = Storage,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(Storage),
- };
+ var field_names: [symbols.len][]const u8 = undefined;
+ var field_types: [symbols.len]type = undefined;
+ for (symbols, &field_names, &field_types) |symbol, *field_name, *FieldType| {
+ field_name.* = symbol.name;
+ FieldType.* = zonCast(SymbolSpec, @field(instruction.symbols, symbol.name), .{}).Storage();
}
- break :Symbols @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &symbol_fields,
- .decls = &.{},
- .is_tuple = false,
- } });
+ break :Symbols @Struct(.auto, null, &field_names, &field_types, &@splat(.{}));
} = undefined;
const Symbol = std.meta.FieldEnum(@TypeOf(instruction.symbols));
comptime var unused_symbols: std.enums.EnumSet(Symbol) = .initFull();
@@ -334,7 +324,7 @@ const SymbolSpec = union(enum) {
.reg => aarch64.encoding.Register,
.arrangement => aarch64.encoding.Register.Arrangement,
.systemreg => aarch64.encoding.Register.System,
- .imm => |imm_spec| @Type(.{ .int = imm_spec.type }),
+ .imm => |imm_spec| @Int(imm_spec.type.signedness, imm_spec.type.bits),
.fimm => f16,
.extend => Instruction.DataProcessingRegister.AddSubtractExtendedRegister.Option,
.shift => Instruction.DataProcessingRegister.Shift.Op,
@@ -413,13 +403,13 @@ const SymbolSpec = union(enum) {
return systemreg;
},
.imm => |imm_spec| {
- const imm = std.fmt.parseInt(@Type(.{ .int = .{
- .signedness = imm_spec.type.signedness,
- .bits = switch (imm_spec.adjust) {
+ const imm = std.fmt.parseInt(@Int(
+ imm_spec.type.signedness,
+ switch (imm_spec.adjust) {
.none, .neg_wrap => imm_spec.type.bits,
.dec => imm_spec.type.bits + 1,
},
- } }), token, 0) catch {
+ ), token, 0) catch {
log.debug("invalid immediate: \"{f}\"", .{std.zig.fmtString(token)});
return null;
};
src/codegen/aarch64/Select.zig
@@ -8928,12 +8928,16 @@ pub const Value = struct {
constant: Constant,
pub const Tag = @typeInfo(Parent).@"union".tag_type.?;
- pub const Payload = @Type(.{ .@"union" = .{
- .layout = .auto,
- .tag_type = null,
- .fields = @typeInfo(Parent).@"union".fields,
- .decls = &.{},
- } });
+ pub const Payload = Payload: {
+ const fields = @typeInfo(Parent).@"union".fields;
+ var types: [fields.len]type = undefined;
+ var names: [fields.len][]const u8 = undefined;
+ for (fields, &types, &names) |f, *ty, *name| {
+ ty.* = f.type;
+ name.* = f.name;
+ }
+ break :Payload @Union(.auto, null, &names, &types, &@splat(.{}));
+ };
};
pub const Location = union(enum(u1)) {
@@ -8949,12 +8953,16 @@ pub const Value = struct {
},
pub const Tag = @typeInfo(Location).@"union".tag_type.?;
- pub const Payload = @Type(.{ .@"union" = .{
- .layout = .auto,
- .tag_type = null,
- .fields = @typeInfo(Location).@"union".fields,
- .decls = &.{},
- } });
+ pub const Payload = Payload: {
+ const fields = @typeInfo(Location).@"union".fields;
+ var types: [fields.len]type = undefined;
+ var names: [fields.len][]const u8 = undefined;
+ for (fields, &types, &names) |f, *ty, *name| {
+ ty.* = f.type;
+ name.* = f.name;
+ }
+ break :Payload @Union(.auto, null, &names, &types, &@splat(.{}));
+ };
};
pub const Indirect = packed struct(u32) {
@@ -11210,7 +11218,7 @@ pub const Value = struct {
.storage = .{ .u64 = switch (size) {
else => unreachable,
inline 1...8 => |ct_size| std.mem.readInt(
- @Type(.{ .int = .{ .signedness = .unsigned, .bits = 8 * ct_size } }),
+ @Int(.unsigned, 8 * ct_size),
buffer[@intCast(offset)..][0..ct_size],
isel.target.cpu.arch.endian(),
),
@@ -11438,7 +11446,7 @@ fn writeKeyToMemory(isel: *Select, constant_key: InternPool.Key, buffer: []u8) e
switch (buffer.len) {
else => unreachable,
inline 1...4 => |size| std.mem.writeInt(
- @Type(.{ .int = .{ .signedness = .unsigned, .bits = 8 * size } }),
+ @Int(.unsigned, 8 * size),
buffer[0..size],
@intCast(error_int),
isel.target.cpu.arch.endian(),
src/codegen/x86_64/CodeGen.zig
@@ -189867,9 +189867,7 @@ const Select = struct {
}
fn adjustedImm(op: Select.Operand, comptime SignedImm: type, s: *const Select) SignedImm {
- const UnsignedImm = @Type(.{
- .int = .{ .signedness = .unsigned, .bits = @typeInfo(SignedImm).int.bits },
- });
+ const UnsignedImm = @Int(.unsigned, @typeInfo(SignedImm).int.bits);
const lhs: SignedImm = lhs: switch (op.flags.adjust.lhs) {
.none => 0,
.ptr_size => @divExact(s.cg.target.ptrBitWidth(), 8),
@@ -189934,10 +189932,10 @@ const Select = struct {
const RefImm = switch (size) {
else => comptime unreachable,
.none => Imm,
- .byte, .word, .dword, .qword => @Type(comptime .{ .int = .{
- .signedness = @typeInfo(Imm).int.signedness,
- .bits = size.bitSize(undefined),
- } }),
+ .byte, .word, .dword, .qword => @Int(
+ @typeInfo(Imm).int.signedness,
+ size.bitSize(undefined),
+ ),
};
break :lhs @bitCast(@as(Imm, @intCast(@as(RefImm, switch (adjust) {
else => comptime unreachable,
src/codegen/x86_64/Emit.zig
@@ -708,7 +708,7 @@ pub fn emitMir(emit: *Emit) Error!void {
switch (reloc.source_length) {
else => unreachable,
inline 1, 4 => |source_length| std.mem.writeInt(
- @Type(.{ .int = .{ .signedness = .signed, .bits = @as(u16, 8) * source_length } }),
+ @Int(.signed, @as(u16, 8) * source_length),
inst_bytes[reloc.source_offset..][0..source_length],
@intCast(disp),
.little,
src/link/Dwarf.zig
@@ -5130,25 +5130,23 @@ pub fn resolveRelocs(dwarf: *Dwarf) RelocError!void {
fn DeclValEnum(comptime T: type) type {
const decls = @typeInfo(T).@"struct".decls;
- @setEvalBranchQuota(7 * decls.len);
- var fields: [decls.len]std.builtin.Type.EnumField = undefined;
+ @setEvalBranchQuota(10 * decls.len);
+ var field_names: [decls.len][]const u8 = undefined;
var fields_len = 0;
var min_value: ?comptime_int = null;
var max_value: ?comptime_int = null;
for (decls) |decl| {
if (std.mem.startsWith(u8, decl.name, "HP_") or std.mem.endsWith(u8, decl.name, "_user")) continue;
const value = @field(T, decl.name);
- fields[fields_len] = .{ .name = decl.name, .value = value };
+ field_names[fields_len] = decl.name;
fields_len += 1;
if (min_value == null or min_value.? > value) min_value = value;
if (max_value == null or max_value.? < value) max_value = value;
}
- return @Type(.{ .@"enum" = .{
- .tag_type = std.math.IntFittingRange(min_value orelse 0, max_value orelse 0),
- .fields = fields[0..fields_len],
- .decls = &.{},
- .is_exhaustive = true,
- } });
+ const TagInt = std.math.IntFittingRange(min_value orelse 0, max_value orelse 0);
+ var field_vals: [fields_len]TagInt = undefined;
+ for (field_names[0..fields_len], &field_vals) |name, *val| val.* = @field(T, name);
+ return @Enum(TagInt, .exhaustive, field_names[0..fields_len], &field_vals);
}
const AbbrevCode = enum {
@@ -6382,10 +6380,12 @@ fn freeCommonEntry(
fn writeInt(dwarf: *Dwarf, buf: []u8, int: u64) void {
switch (buf.len) {
- inline 0...8 => |len| std.mem.writeInt(@Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = len * 8,
- } }), buf[0..len], @intCast(int), dwarf.endian),
+ inline 0...8 => |len| std.mem.writeInt(
+ @Int(.unsigned, len * 8),
+ buf[0..len],
+ @intCast(int),
+ dwarf.endian,
+ ),
else => unreachable,
}
}
src/link/MappedFile.zig
@@ -108,10 +108,7 @@ pub const Node = extern struct {
has_content: bool,
/// Whether a moved event on this node bubbles down to children.
bubbles_moved: bool,
- unused: @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = 32 - @bitSizeOf(std.mem.Alignment) - 6,
- } }) = 0,
+ unused: @Int(.unsigned, 32 - @bitSizeOf(std.mem.Alignment) - 6) = 0,
};
pub const Location = union(enum(u1)) {
@@ -122,19 +119,14 @@ pub const Node = extern struct {
},
large: extern struct {
index: usize,
- unused: @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = 64 - @bitSizeOf(usize),
- } }) = 0,
+ unused: @Int(.unsigned, 64 - @bitSizeOf(usize)) = 0,
},
pub const Tag = @typeInfo(Location).@"union".tag_type.?;
- pub const Payload = @Type(.{ .@"union" = .{
- .layout = .@"extern",
- .tag_type = null,
- .fields = @typeInfo(Location).@"union".fields,
- .decls = &.{},
- } });
+ pub const Payload = extern union {
+ small: @FieldType(Location, "small"),
+ large: @FieldType(Location, "large"),
+ };
pub fn resolve(loc: Location, mf: *const MappedFile) [2]u64 {
return switch (loc) {
src/InternPool.zig
@@ -1153,23 +1153,17 @@ const Local = struct {
fn PtrArrayElem(comptime len: usize) type {
const elem_info = @typeInfo(Elem).@"struct";
const elem_fields = elem_info.fields;
- var new_fields: [elem_fields.len]std.builtin.Type.StructField = undefined;
- for (&new_fields, elem_fields) |*new_field, elem_field| {
- const T = *[len]elem_field.type;
- new_field.* = .{
- .name = elem_field.name,
- .type = T,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(T),
- };
+ var new_names: [elem_fields.len][]const u8 = undefined;
+ var new_types: [elem_fields.len]type = undefined;
+ for (elem_fields, &new_names, &new_types) |elem_field, *new_name, *NewType| {
+ new_name.* = elem_field.name;
+ NewType.* = *[len]elem_field.type;
+ }
+ if (elem_info.is_tuple) {
+ return @Tuple(&new_types);
+ } else {
+ return @Struct(.auto, null, &new_names, &new_types, &@splat(.{}));
}
- return @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &new_fields,
- .decls = &.{},
- .is_tuple = elem_info.is_tuple,
- } });
}
fn PtrElem(comptime opts: struct {
size: std.builtin.Type.Pointer.Size,
@@ -1177,32 +1171,17 @@ const Local = struct {
}) type {
const elem_info = @typeInfo(Elem).@"struct";
const elem_fields = elem_info.fields;
- var new_fields: [elem_fields.len]std.builtin.Type.StructField = undefined;
- for (&new_fields, elem_fields) |*new_field, elem_field| {
- const T = @Type(.{ .pointer = .{
- .size = opts.size,
- .is_const = opts.is_const,
- .is_volatile = false,
- .alignment = @alignOf(elem_field.type),
- .address_space = .generic,
- .child = elem_field.type,
- .is_allowzero = false,
- .sentinel_ptr = null,
- } });
- new_field.* = .{
- .name = elem_field.name,
- .type = T,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(T),
- };
+ var new_names: [elem_fields.len][]const u8 = undefined;
+ var new_types: [elem_fields.len]type = undefined;
+ for (elem_fields, &new_names, &new_types) |elem_field, *new_name, *NewType| {
+ new_name.* = elem_field.name;
+ NewType.* = @Pointer(opts.size, .{ .@"const" = opts.is_const }, elem_field.type, null);
+ }
+ if (elem_info.is_tuple) {
+ return @Tuple(&new_types);
+ } else {
+ return @Struct(.auto, null, &new_names, &new_types, &@splat(.{}));
}
- return @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &new_fields,
- .decls = &.{},
- .is_tuple = elem_info.is_tuple,
- } });
}
pub fn addOne(mutable: Mutable) Allocator.Error!PtrElem(.{ .size = .one }) {
src/link.zig
@@ -51,10 +51,7 @@ pub const Diags = struct {
const Int = blk: {
const bits = @typeInfo(@This()).@"struct".fields.len;
- break :blk @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = bits,
- } });
+ break :blk @Int(.unsigned, bits);
};
pub fn anySet(ef: Flags) bool {
src/main.zig
@@ -136,7 +136,7 @@ var log_scopes: std.ArrayList([]const u8) = .empty;
pub fn log(
comptime level: std.log.Level,
- comptime scope: @Type(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
src/Sema.zig
@@ -23904,7 +23904,7 @@ fn analyzeShuffle(
const b_src = block.builtinCallArgSrc(src_node, 2);
const mask_src = block.builtinCallArgSrc(src_node, 3);
- // If the type of `a` is `@Type(.undefined)`, i.e. the argument is untyped,
+ // If the type of `a` is `@TypeOf(undefined)`, i.e. the argument is untyped,
// this is 0, because it is an error to index into this vector.
const a_len: u32 = switch (sema.typeOf(a_uncoerced).zigTypeTag(zcu)) {
.array, .vector => @intCast(sema.typeOf(a_uncoerced).arrayLen(zcu)),
@@ -23916,7 +23916,7 @@ fn analyzeShuffle(
const a_ty = try pt.vectorType(.{ .len = a_len, .child = elem_ty.toIntern() });
const a_coerced = try sema.coerce(block, a_ty, a_uncoerced, a_src);
- // If the type of `b` is `@Type(.undefined)`, i.e. the argument is untyped, this is 0, because it is an error to index into this vector.
+ // If the type of `b` is `@TypeOf(undefined)`, i.e. the argument is untyped, this is 0, because it is an error to index into this vector.
const b_len: u32 = switch (sema.typeOf(b_uncoerced).zigTypeTag(zcu)) {
.array, .vector => @intCast(sema.typeOf(b_uncoerced).arrayLen(zcu)),
.undefined => 0,
test/behavior/x86_64/math.zig
@@ -36,34 +36,28 @@ pub fn ChangeScalar(comptime Type: type, comptime NewScalar: type) type {
}
pub fn AsSignedness(comptime Type: type, comptime signedness: std.builtin.Signedness) type {
return switch (@typeInfo(Scalar(Type))) {
- .int => |int| ChangeScalar(Type, @Type(.{ .int = .{
- .signedness = signedness,
- .bits = int.bits,
- } })),
+ .int => |int| ChangeScalar(Type, @Int(signedness, int.bits)),
.float => Type,
else => @compileError(@typeName(Type)),
};
}
pub fn AddOneBit(comptime Type: type) type {
return ChangeScalar(Type, switch (@typeInfo(Scalar(Type))) {
- .int => |int| @Type(.{ .int = .{ .signedness = int.signedness, .bits = 1 + int.bits } }),
+ .int => |int| @Int(int.signedness, 1 + int.bits),
.float => Scalar(Type),
else => @compileError(@typeName(Type)),
});
}
pub fn DoubleBits(comptime Type: type) type {
return ChangeScalar(Type, switch (@typeInfo(Scalar(Type))) {
- .int => |int| @Type(.{ .int = .{ .signedness = int.signedness, .bits = int.bits * 2 } }),
+ .int => |int| @Int(int.signedness, int.bits * 2),
.float => Scalar(Type),
else => @compileError(@typeName(Type)),
});
}
pub fn RoundBitsUp(comptime Type: type, comptime multiple: u16) type {
return ChangeScalar(Type, switch (@typeInfo(Scalar(Type))) {
- .int => |int| @Type(.{ .int = .{
- .signedness = int.signedness,
- .bits = std.mem.alignForward(u16, int.bits, multiple),
- } }),
+ .int => |int| @Int(int.signedness, std.mem.alignForward(u16, int.bits, multiple)),
.float => Scalar(Type),
else => @compileError(@typeName(Type)),
});
@@ -83,10 +77,7 @@ pub fn splat(comptime Type: type, scalar: Scalar(Type)) Type {
pub fn sign(rhs: anytype) ChangeScalar(@TypeOf(rhs), bool) {
const Int = ChangeScalar(@TypeOf(rhs), switch (@typeInfo(Scalar(@TypeOf(rhs)))) {
.int, .comptime_int => Scalar(@TypeOf(rhs)),
- .float => |float| @Type(.{ .int = .{
- .signedness = .signed,
- .bits = float.bits,
- } }),
+ .float => |float| @Int(.signed, float.bits),
else => @compileError(@typeName(@TypeOf(rhs))),
});
return @as(Int, @bitCast(rhs)) < splat(Int, 0);
test/behavior/basic.zig
@@ -1264,12 +1264,9 @@ test "reference to inferred local variable works as expected" {
try expect(crasher_local.lets_crash != a.lets_crash);
}
-test "@Type returned from block" {
+test "@Int returned from block" {
const T = comptime b: {
- break :b @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = 8,
- } });
+ break :b @Int(.unsigned, 8);
};
try std.testing.expect(T == u8);
}
test/behavior/bit_shifting.zig
@@ -119,21 +119,12 @@ test "Saturating Shift Left where lhs is of a computed type" {
if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
const S = struct {
- fn getIntShiftType(comptime T: type) type {
- var unsigned_shift_type = @typeInfo(std.math.Log2Int(T)).int;
- unsigned_shift_type.signedness = .signed;
-
- return @Type(.{
- .int = unsigned_shift_type,
- });
- }
-
pub fn FixedPoint(comptime ValueType: type) type {
return struct {
value: ValueType,
exponent: ShiftType,
- const ShiftType: type = getIntShiftType(ValueType);
+ const ShiftType = @Int(.signed, @typeInfo(std.math.Log2Int(ValueType)).int.bits);
pub fn shiftExponent(self: @This(), shift: ShiftType) @This() {
const shiftAbs = @abs(shift);
test/behavior/call.zig
@@ -355,7 +355,7 @@ test "inline call doesn't re-evaluate non generic struct" {
try comptime @call(.always_inline, S.foo, ArgTuple{.{ .a = 123, .b = 45 }});
}
-test "Enum constructed by @Type passed as generic argument" {
+test "Enum constructed by @Enum passed as generic argument" {
const S = struct {
const E = std.meta.FieldEnum(struct {
prev_pos: bool,
test/behavior/cast.zig
@@ -2446,9 +2446,14 @@ test "peer type resolution: pointer attributes are combined correctly" {
};
const NonAllowZero = comptime blk: {
- var ti = @typeInfo(@TypeOf(r1, r2, r3, r4));
- ti.pointer.is_allowzero = false;
- break :blk @Type(ti);
+ const ptr = @typeInfo(@TypeOf(r1, r2, r3, r4)).pointer;
+ break :blk @Pointer(ptr.size, .{
+ .@"const" = ptr.is_const,
+ .@"volatile" = ptr.is_volatile,
+ .@"allowzero" = false,
+ .@"align" = ptr.alignment,
+ .@"addrspace" = ptr.address_space,
+ }, ptr.child, ptr.sentinel());
};
try expectEqualSlices(u8, std.mem.span(@volatileCast(@as(NonAllowZero, @ptrCast(r1)))), "foo");
try expectEqualSlices(u8, std.mem.span(@volatileCast(@as(NonAllowZero, @ptrCast(r2)))), "bar");
test/behavior/enum.zig
@@ -1283,10 +1283,7 @@ test "Non-exhaustive enum backed by comptime_int" {
test "matching captures causes enum equivalence" {
const S = struct {
fn Nonexhaustive(comptime I: type) type {
- const UTag = @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = @typeInfo(I).int.bits,
- } });
+ const UTag = @Int(.unsigned, @typeInfo(I).int.bits);
return enum(UTag) { _ };
}
};
test/behavior/fn.zig
@@ -556,10 +556,10 @@ test "lazy values passed to anytype parameter" {
test "pass and return comptime-only types" {
const S = struct {
- fn returnNull(comptime x: @Type(.null)) @Type(.null) {
+ fn returnNull(comptime x: @TypeOf(null)) @TypeOf(null) {
return x;
}
- fn returnUndefined(comptime x: @Type(.undefined)) @Type(.undefined) {
+ fn returnUndefined(comptime x: @TypeOf(undefined)) @TypeOf(undefined) {
return x;
}
};
test/behavior/generics.zig
@@ -263,15 +263,7 @@ test "generic function instantiation turns into comptime call" {
pub fn FieldEnum(comptime T: type) type {
_ = T;
- var enumFields: [1]std.builtin.Type.EnumField = .{.{ .name = "A", .value = 0 }};
- return @Type(.{
- .@"enum" = .{
- .tag_type = u0,
- .fields = &enumFields,
- .decls = &.{},
- .is_exhaustive = true,
- },
- });
+ return @Enum(u0, .exhaustive, &.{"A"}, &.{0});
}
};
try S.doTheTest();
test/behavior/sizeof_and_typeof.zig
@@ -338,14 +338,14 @@ test "peer type resolution with @TypeOf doesn't trigger dependency loop check" {
test "@sizeOf reified union zero-size payload fields" {
comptime {
- try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union {}))));
- try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void }))));
+ try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{}, &.{}, &.{})));
+ try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{"a"}, &.{void}, &.{.{}})));
if (builtin.mode == .Debug or builtin.mode == .ReleaseSafe) {
- try std.testing.expect(1 == @sizeOf(@Type(@typeInfo(union { a: void, b: void }))));
- try std.testing.expect(1 == @sizeOf(@Type(@typeInfo(union { a: void, b: void, c: void }))));
+ try std.testing.expect(1 == @sizeOf(@Union(.auto, null, &.{ "a", "b" }, &.{ void, void }, &.{ .{}, .{} })));
+ try std.testing.expect(1 == @sizeOf(@Union(.auto, null, &.{ "a", "b", "c" }, &.{ void, void, void }, &.{ .{}, .{}, .{} })));
} else {
- try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void, b: void }))));
- try std.testing.expect(0 == @sizeOf(@Type(@typeInfo(union { a: void, b: void, c: void }))));
+ try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{ "a", "b" }, &.{ void, void }, &.{ .{}, .{} })));
+ try std.testing.expect(0 == @sizeOf(@Union(.auto, null, &.{ "a", "b", "c" }, &.{ void, void, void }, &.{ .{}, .{}, .{} })));
}
}
}
test/behavior/struct.zig
@@ -2034,10 +2034,7 @@ test "matching captures causes struct equivalence" {
fn UnsignedWrapper(comptime I: type) type {
const bits = @typeInfo(I).int.bits;
return struct {
- x: @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = bits,
- } }),
+ x: @Int(.unsigned, bits),
};
}
};
test/behavior/switch.zig
@@ -843,7 +843,8 @@ test "switch capture peer type resolution for in-memory coercible payloads" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const T1 = c_int;
- const T2 = @Type(@typeInfo(T1));
+ const t1_info = @typeInfo(T1).int;
+ const T2 = @Int(t1_info.signedness, t1_info.bits);
comptime assert(T1 != T2);
@@ -865,7 +866,8 @@ test "switch pointer capture peer type resolution" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const T1 = c_int;
- const T2 = @Type(@typeInfo(T1));
+ const t1_info = @typeInfo(T1).int;
+ const T2 = @Int(t1_info.signedness, t1_info.bits);
comptime assert(T1 != T2);
test/behavior/switch_loop.zig
@@ -230,10 +230,7 @@ test "switch loop on larger than pointer integer" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
- var entry: @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = @bitSizeOf(usize) + 1,
- } }) = undefined;
+ var entry: @Int(.unsigned, @bitSizeOf(usize) + 1) = undefined;
entry = 0;
loop: switch (entry) {
0 => {
test/behavior/tuple.zig
@@ -130,29 +130,7 @@ test "array-like initializer for tuple types" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
- const T = @Type(.{
- .@"struct" = .{
- .is_tuple = true,
- .layout = .auto,
- .decls = &.{},
- .fields = &.{
- .{
- .name = "0",
- .type = i32,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(i32),
- },
- .{
- .name = "1",
- .type = u8,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(u8),
- },
- },
- },
- });
+ const T = @Tuple(&.{ i32, u8 });
const S = struct {
fn doTheTest() !void {
var obj: T = .{ -1234, 128 };
@@ -320,20 +298,7 @@ test "zero sized struct in tuple handled correctly" {
const Self = @This();
const Inner = struct {};
- data: @Type(.{
- .@"struct" = .{
- .is_tuple = true,
- .layout = .auto,
- .decls = &.{},
- .fields = &.{.{
- .name = "0",
- .type = Inner,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(Inner),
- }},
- },
- }),
+ data: @Tuple(&.{Inner}),
pub fn do(this: Self) usize {
return @sizeOf(@TypeOf(this));
@@ -470,12 +435,7 @@ test "coerce anon tuple to tuple" {
}
test "empty tuple type" {
- const S = @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{},
- .decls = &.{},
- .is_tuple = true,
- } });
+ const S = @Tuple(&.{});
const s: S = .{};
try expect(s.len == 0);
@@ -616,18 +576,7 @@ test "OPV tuple fields aren't comptime" {
const t_info = @typeInfo(T);
try expect(!t_info.@"struct".fields[0].is_comptime);
- const T2 = @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "0",
- .type = void,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(void),
- }},
- .decls = &.{},
- .is_tuple = true,
- } });
+ const T2 = @Tuple(&.{void});
const t2_info = @typeInfo(T2);
try expect(!t2_info.@"struct".fields[0].is_comptime);
}
test/behavior/type.zig
@@ -4,63 +4,17 @@ const Type = std.builtin.Type;
const testing = std.testing;
const assert = std.debug.assert;
-fn testTypes(comptime types: []const type) !void {
- inline for (types) |testType| {
- try testing.expect(testType == @Type(@typeInfo(testType)));
- }
-}
-
-test "Type.MetaType" {
- try testing.expect(type == @Type(.{ .type = {} }));
- try testTypes(&[_]type{type});
-}
-
-test "Type.Void" {
- try testing.expect(void == @Type(.{ .void = {} }));
- try testTypes(&[_]type{void});
-}
-
-test "Type.Bool" {
- try testing.expect(bool == @Type(.{ .bool = {} }));
- try testTypes(&[_]type{bool});
-}
-
-test "Type.NoReturn" {
- try testing.expect(noreturn == @Type(.{ .noreturn = {} }));
- try testTypes(&[_]type{noreturn});
-}
-
test "Type.Int" {
- try testing.expect(u1 == @Type(.{ .int = .{ .signedness = .unsigned, .bits = 1 } }));
- try testing.expect(i1 == @Type(.{ .int = .{ .signedness = .signed, .bits = 1 } }));
- try testing.expect(u8 == @Type(.{ .int = .{ .signedness = .unsigned, .bits = 8 } }));
- try testing.expect(i8 == @Type(.{ .int = .{ .signedness = .signed, .bits = 8 } }));
- try testing.expect(u64 == @Type(.{ .int = .{ .signedness = .unsigned, .bits = 64 } }));
- try testing.expect(i64 == @Type(.{ .int = .{ .signedness = .signed, .bits = 64 } }));
- try testTypes(&[_]type{ u8, u32, i64 });
-}
-
-test "Type.ComptimeFloat" {
- try testTypes(&[_]type{comptime_float});
-}
-test "Type.ComptimeInt" {
- try testTypes(&[_]type{comptime_int});
-}
-test "Type.Undefined" {
- try testTypes(&[_]type{@TypeOf(undefined)});
-}
-test "Type.Null" {
- try testTypes(&[_]type{@TypeOf(null)});
-}
-
-test "Type.EnumLiteral" {
- try testTypes(&[_]type{
- @TypeOf(.Dummy),
- });
+ try testing.expect(u1 == @Int(.unsigned, 1));
+ try testing.expect(i1 == @Int(.signed, 1));
+ try testing.expect(u8 == @Int(.unsigned, 8));
+ try testing.expect(i8 == @Int(.signed, 8));
+ try testing.expect(u64 == @Int(.unsigned, 64));
+ try testing.expect(i64 == @Int(.signed, 64));
}
test "Type.Pointer" {
- try testTypes(&[_]type{
+ inline for (&[_]type{
// One Value Pointer Types
*u8, *const u8,
*volatile u8, *const volatile u8,
@@ -101,62 +55,30 @@ test "Type.Pointer" {
[*c]align(4) volatile u8, [*c]align(4) const volatile u8,
[*c]align(8) u8, [*c]align(8) const u8,
[*c]align(8) volatile u8, [*c]align(8) const volatile u8,
- });
+ }) |testType| {
+ const ptr = @typeInfo(testType).pointer;
+ try testing.expect(testType == @Pointer(ptr.size, .{
+ .@"const" = ptr.is_const,
+ .@"volatile" = ptr.is_volatile,
+ .@"allowzero" = ptr.is_allowzero,
+ .@"align" = ptr.alignment,
+ .@"addrspace" = ptr.address_space,
+ }, ptr.child, ptr.sentinel()));
+ }
}
-test "Type.Float" {
- try testing.expect(f16 == @Type(.{ .float = .{ .bits = 16 } }));
- try testing.expect(f32 == @Type(.{ .float = .{ .bits = 32 } }));
- try testing.expect(f64 == @Type(.{ .float = .{ .bits = 64 } }));
- try testing.expect(f80 == @Type(.{ .float = .{ .bits = 80 } }));
- try testing.expect(f128 == @Type(.{ .float = .{ .bits = 128 } }));
- try testTypes(&[_]type{ f16, f32, f64, f80, f128 });
+test "@Pointer create slice without sentinel" {
+ const Slice = @Pointer(.slice, .{ .@"const" = true, .@"align" = 8 }, ?*i32, null);
+ try testing.expect(Slice == []align(8) const ?*i32);
}
-test "Type.Array" {
- try testing.expect([123]u8 == @Type(.{
- .array = .{
- .len = 123,
- .child = u8,
- .sentinel_ptr = null,
- },
- }));
- try testing.expect([2]u32 == @Type(.{
- .array = .{
- .len = 2,
- .child = u32,
- .sentinel_ptr = null,
- },
- }));
- try testing.expect([2:0]u32 == @Type(.{
- .array = .{
- .len = 2,
- .child = u32,
- .sentinel_ptr = &@as(u32, 0),
- },
- }));
- try testTypes(&[_]type{ [1]u8, [30]usize, [7]bool });
+test "@Pointer create slice with null sentinel" {
+ const Slice = @Pointer(.slice, .{ .@"const" = true, .@"align" = 8 }, ?*i32, @as(?*i32, null));
+ try testing.expect(Slice == [:null]align(8) const ?*i32);
}
-test "@Type create slice with null sentinel" {
- const Slice = @Type(.{
- .pointer = .{
- .size = .slice,
- .is_const = true,
- .is_volatile = false,
- .is_allowzero = false,
- .alignment = 8,
- .address_space = .generic,
- .child = *i32,
- .sentinel_ptr = null,
- },
- });
- try testing.expect(Slice == []align(8) const *i32);
-}
-
-test "@Type picks up the sentinel value from Type" {
- try testTypes(&[_]type{
- [11:0]u8, [4:10]u8,
+test "@Pointer on @typeInfo round-trips sentinels" {
+ inline for (&[_]type{
[*:0]u8, [*:0]const u8,
[*:0]volatile u8, [*:0]const volatile u8,
[*:0]align(4) u8, [*:0]align(4) const u8,
@@ -179,24 +101,16 @@ test "@Type picks up the sentinel value from Type" {
[:0]allowzero align(4) u8, [:0]allowzero align(4) const u8,
[:0]allowzero align(4) volatile u8, [:0]allowzero align(4) const volatile u8,
[:4]allowzero align(4) volatile u8, [:4]allowzero align(4) const volatile u8,
- });
-}
-
-test "Type.Optional" {
- try testTypes(&[_]type{
- ?u8,
- ?*u8,
- ?[]u8,
- ?[*]u8,
- ?[*c]u8,
- });
-}
-
-test "Type.ErrorUnion" {
- try testTypes(&[_]type{
- error{}!void,
- error{Error}!void,
- });
+ }) |TestType| {
+ const ptr = @typeInfo(TestType).pointer;
+ try testing.expect(TestType == @Pointer(ptr.size, .{
+ .@"const" = ptr.is_const,
+ .@"volatile" = ptr.is_volatile,
+ .@"allowzero" = ptr.is_allowzero,
+ .@"align" = ptr.alignment,
+ .@"addrspace" = ptr.address_space,
+ }, ptr.child, ptr.sentinel()));
+ }
}
test "Type.Opaque" {
@@ -205,11 +119,7 @@ test "Type.Opaque" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
- const Opaque = @Type(.{
- .@"opaque" = .{
- .decls = &.{},
- },
- });
+ const Opaque = opaque {};
try testing.expect(Opaque != opaque {});
try testing.expectEqualSlices(
Type.Declaration,
@@ -218,52 +128,17 @@ test "Type.Opaque" {
);
}
-test "Type.Vector" {
- try testTypes(&[_]type{
- @Vector(0, u8),
- @Vector(4, u8),
- @Vector(8, *u8),
- @Vector(0, u8),
- @Vector(4, u8),
- @Vector(8, *u8),
- });
-}
-
-test "Type.AnyFrame" {
- if (true) {
- // https://github.com/ziglang/zig/issues/6025
- return error.SkipZigTest;
- }
-
- try testTypes(&[_]type{
- anyframe,
- anyframe->u8,
- anyframe->anyframe->u8,
- });
-}
-
fn add(a: i32, b: i32) i32 {
return a + b;
}
-test "Type.ErrorSet" {
- try testing.expect(@Type(.{ .error_set = null }) == anyerror);
-
- // error sets don't compare equal so just check if they compile
- inline for (.{ error{}, error{A}, error{ A, B, C } }) |T| {
- const info = @typeInfo(T);
- const T2 = @Type(info);
- try testing.expect(T == T2);
- }
-}
-
test "Type.Struct" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
- const A = @Type(@typeInfo(struct { x: u8, y: u32 }));
+ const A = @Struct(.auto, null, &.{ "x", "y" }, &.{ u8, u32 }, &@splat(.{}));
const infoA = @typeInfo(A).@"struct";
try testing.expectEqual(Type.ContainerLayout.auto, infoA.layout);
try testing.expectEqualSlices(u8, "x", infoA.fields[0].name);
@@ -281,7 +156,13 @@ test "Type.Struct" {
a.y += 1;
try testing.expectEqual(@as(u32, 2), a.y);
- const B = @Type(@typeInfo(extern struct { x: u8, y: u32 = 5 }));
+ const B = @Struct(
+ .@"extern",
+ null,
+ &.{ "x", "y" },
+ &.{ u8, u32 },
+ &.{ .{}, .{ .default_value_ptr = &@as(u32, 5) } },
+ );
const infoB = @typeInfo(B).@"struct";
try testing.expectEqual(Type.ContainerLayout.@"extern", infoB.layout);
try testing.expectEqualSlices(u8, "x", infoB.fields[0].name);
@@ -293,7 +174,16 @@ test "Type.Struct" {
try testing.expectEqual(@as(usize, 0), infoB.decls.len);
try testing.expectEqual(@as(bool, false), infoB.is_tuple);
- const C = @Type(@typeInfo(packed struct { x: u8 = 3, y: u32 = 5 }));
+ const C = @Struct(
+ .@"packed",
+ null,
+ &.{ "x", "y" },
+ &.{ u8, u32 },
+ &.{
+ .{ .default_value_ptr = &@as(u8, 3) },
+ .{ .default_value_ptr = &@as(u32, 5) },
+ },
+ );
const infoC = @typeInfo(C).@"struct";
try testing.expectEqual(Type.ContainerLayout.@"packed", infoC.layout);
try testing.expectEqualSlices(u8, "x", infoC.fields[0].name);
@@ -305,76 +195,23 @@ test "Type.Struct" {
try testing.expectEqual(@as(usize, 0), infoC.decls.len);
try testing.expectEqual(@as(bool, false), infoC.is_tuple);
- // anon structs
- const D = @Type(@typeInfo(@TypeOf(.{ .x = 3, .y = 5 })));
- const infoD = @typeInfo(D).@"struct";
- try testing.expectEqual(Type.ContainerLayout.auto, infoD.layout);
- try testing.expectEqualSlices(u8, "x", infoD.fields[0].name);
- try testing.expectEqual(comptime_int, infoD.fields[0].type);
- try testing.expectEqual(@as(comptime_int, 3), infoD.fields[0].defaultValue().?);
- try testing.expectEqualSlices(u8, "y", infoD.fields[1].name);
- try testing.expectEqual(comptime_int, infoD.fields[1].type);
- try testing.expectEqual(@as(comptime_int, 5), infoD.fields[1].defaultValue().?);
- try testing.expectEqual(@as(usize, 0), infoD.decls.len);
- try testing.expectEqual(@as(bool, false), infoD.is_tuple);
-
- // tuples
- const E = @Type(@typeInfo(@TypeOf(.{ 1, 2 })));
- const infoE = @typeInfo(E).@"struct";
- try testing.expectEqual(Type.ContainerLayout.auto, infoE.layout);
- try testing.expectEqualSlices(u8, "0", infoE.fields[0].name);
- try testing.expectEqual(comptime_int, infoE.fields[0].type);
- try testing.expectEqual(@as(comptime_int, 1), infoE.fields[0].defaultValue().?);
- try testing.expectEqualSlices(u8, "1", infoE.fields[1].name);
- try testing.expectEqual(comptime_int, infoE.fields[1].type);
- try testing.expectEqual(@as(comptime_int, 2), infoE.fields[1].defaultValue().?);
- try testing.expectEqual(@as(usize, 0), infoE.decls.len);
- try testing.expectEqual(@as(bool, true), infoE.is_tuple);
-
// empty struct
- const F = @Type(@typeInfo(struct {}));
+ const F = @Struct(.auto, null, &.{}, &.{}, &.{});
const infoF = @typeInfo(F).@"struct";
try testing.expectEqual(Type.ContainerLayout.auto, infoF.layout);
try testing.expect(infoF.fields.len == 0);
try testing.expectEqual(@as(bool, false), infoF.is_tuple);
-
- // empty tuple
- const G = @Type(@typeInfo(@TypeOf(.{})));
- const infoG = @typeInfo(G).@"struct";
- try testing.expectEqual(Type.ContainerLayout.auto, infoG.layout);
- try testing.expect(infoG.fields.len == 0);
- try testing.expectEqual(@as(bool, true), infoG.is_tuple);
}
test "Type.Enum" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
- const Foo = @Type(.{
- .@"enum" = .{
- .tag_type = u8,
- .fields = &.{
- .{ .name = "a", .value = 1 },
- .{ .name = "b", .value = 5 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
- });
+ const Foo = @Enum(u8, .exhaustive, &.{ "a", "b" }, &.{ 1, 5 });
try testing.expectEqual(true, @typeInfo(Foo).@"enum".is_exhaustive);
try testing.expectEqual(@as(u8, 1), @intFromEnum(Foo.a));
try testing.expectEqual(@as(u8, 5), @intFromEnum(Foo.b));
- const Bar = @Type(.{
- .@"enum" = .{
- .tag_type = u32,
- .fields = &.{
- .{ .name = "a", .value = 1 },
- .{ .name = "b", .value = 5 },
- },
- .decls = &.{},
- .is_exhaustive = false,
- },
- });
+ const Bar = @Enum(u32, .nonexhaustive, &.{ "a", "b" }, &.{ 1, 5 });
try testing.expectEqual(false, @typeInfo(Bar).@"enum".is_exhaustive);
try testing.expectEqual(@as(u32, 1), @intFromEnum(Bar.a));
try testing.expectEqual(@as(u32, 5), @intFromEnum(Bar.b));
@@ -382,12 +219,7 @@ test "Type.Enum" {
{ // from https://github.com/ziglang/zig/issues/19985
{ // enum with single field can be initialized.
- const E = @Type(.{ .@"enum" = .{
- .tag_type = u0,
- .is_exhaustive = true,
- .fields = &.{.{ .name = "foo", .value = 0 }},
- .decls = &.{},
- } });
+ const E = @Enum(u0, .exhaustive, &.{"foo"}, &.{0});
const s: struct { E } = .{.foo};
try testing.expectEqual(.foo, s[0]);
}
@@ -411,60 +243,20 @@ test "Type.Union" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest;
- const Untagged = @Type(.{
- .@"union" = .{
- .layout = .@"extern",
- .tag_type = null,
- .fields = &.{
- .{ .name = "int", .type = i32, .alignment = @alignOf(f32) },
- .{ .name = "float", .type = f32, .alignment = @alignOf(f32) },
- },
- .decls = &.{},
- },
- });
+ const Untagged = @Union(.@"extern", null, &.{ "int", "float" }, &.{ i32, f32 }, &.{ .{}, .{} });
var untagged = Untagged{ .int = 1 };
untagged.float = 2.0;
untagged.int = 3;
try testing.expectEqual(@as(i32, 3), untagged.int);
- const PackedUntagged = @Type(.{
- .@"union" = .{
- .layout = .@"packed",
- .tag_type = null,
- .fields = &.{
- .{ .name = "signed", .type = i32, .alignment = 0 },
- .{ .name = "unsigned", .type = u32, .alignment = 0 },
- },
- .decls = &.{},
- },
- });
+ const PackedUntagged = @Union(.@"packed", null, &.{ "signed", "unsigned" }, &.{ i32, u32 }, &.{ .{}, .{} });
var packed_untagged: PackedUntagged = .{ .signed = -1 };
_ = &packed_untagged;
try testing.expectEqual(@as(i32, -1), packed_untagged.signed);
try testing.expectEqual(~@as(u32, 0), packed_untagged.unsigned);
- const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u1,
- .fields = &.{
- .{ .name = "signed", .value = 0 },
- .{ .name = "unsigned", .value = 1 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
- });
- const Tagged = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = Tag,
- .fields = &.{
- .{ .name = "signed", .type = i32, .alignment = @alignOf(i32) },
- .{ .name = "unsigned", .type = u32, .alignment = @alignOf(u32) },
- },
- .decls = &.{},
- },
- });
+ const Tag = @Enum(u1, .exhaustive, &.{ "signed", "unsigned" }, &.{ 0, 1 });
+ const Tagged = @Union(.auto, Tag, &.{ "signed", "unsigned" }, &.{ i32, u32 }, &.{ .{}, .{} });
var tagged = Tagged{ .signed = -1 };
try testing.expectEqual(Tag.signed, @as(Tag, tagged));
tagged = .{ .unsigned = 1 };
@@ -472,74 +264,26 @@ test "Type.Union" {
}
test "Type.Union from Type.Enum" {
- const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u0,
- .fields = &.{
- .{ .name = "working_as_expected", .value = 0 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
- });
- const T = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = Tag,
- .fields = &.{
- .{ .name = "working_as_expected", .type = u32, .alignment = @alignOf(u32) },
- },
- .decls = &.{},
- },
- });
+ const Tag = @Enum(u0, .exhaustive, &.{"working_as_expected"}, &.{0});
+ const T = @Union(.auto, Tag, &.{"working_as_expected"}, &.{u32}, &.{.{}});
_ = @typeInfo(T).@"union";
}
test "Type.Union from regular enum" {
const E = enum { working_as_expected };
- const T = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = E,
- .fields = &.{
- .{ .name = "working_as_expected", .type = u32, .alignment = @alignOf(u32) },
- },
- .decls = &.{},
- },
- });
+ const T = @Union(.auto, E, &.{"working_as_expected"}, &.{u32}, &.{.{}});
_ = @typeInfo(T).@"union";
}
test "Type.Union from empty regular enum" {
const E = enum {};
- const U = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = E,
- .fields = &.{},
- .decls = &.{},
- },
- });
+ const U = @Union(.auto, E, &.{}, &.{}, &.{});
try testing.expectEqual(@sizeOf(U), 0);
}
test "Type.Union from empty Type.Enum" {
- const E = @Type(.{
- .@"enum" = .{
- .tag_type = u0,
- .fields = &.{},
- .decls = &.{},
- .is_exhaustive = true,
- },
- });
- const U = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = E,
- .fields = &.{},
- .decls = &.{},
- },
- });
+ const E = @Enum(u0, .exhaustive, &.{}, &.{});
+ const U = @Union(.auto, E, &.{}, &.{}, &.{});
try testing.expectEqual(@sizeOf(U), 0);
}
@@ -548,47 +292,22 @@ test "Type.Fn" {
const some_opaque = opaque {};
const some_ptr = *some_opaque;
- const T = fn (c_int, some_ptr) callconv(.c) void;
-
- {
- const fn_info = std.builtin.Type{ .@"fn" = .{
- .calling_convention = .c,
- .is_generic = false,
- .is_var_args = false,
- .return_type = void,
- .params = &.{
- .{ .is_generic = false, .is_noalias = false, .type = c_int },
- .{ .is_generic = false, .is_noalias = false, .type = some_ptr },
- },
- } };
-
- const fn_type = @Type(fn_info);
- try std.testing.expectEqual(T, fn_type);
- }
- {
- const fn_info = @typeInfo(T);
- const fn_type = @Type(fn_info);
- try std.testing.expectEqual(T, fn_type);
- }
+ const A = @Fn(&.{ c_int, some_ptr }, &@splat(.{}), void, .{ .@"callconv" = .c });
+ comptime assert(A == fn (c_int, some_ptr) callconv(.c) void);
+
+ const B = @Fn(&.{ c_int, some_ptr, u32 }, &.{ .{}, .{ .@"noalias" = true }, .{} }, u64, .{});
+ comptime assert(B == fn (c_int, noalias some_ptr, u32) u64);
+
+ const C = @Fn(&.{?[*]u8}, &.{.{}}, *const anyopaque, .{ .@"callconv" = .c, .varargs = true });
+ comptime assert(C == fn (?[*]u8, ...) callconv(.c) *const anyopaque);
}
test "reified struct field name from optional payload" {
comptime {
const m_name: ?[1:0]u8 = "a".*;
if (m_name) |*name| {
- const T = @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = name,
- .type = u8,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = 1,
- }},
- .decls = &.{},
- .is_tuple = false,
- } });
+ const T = @Struct(.auto, null, &.{name}, &.{u8}, &.{.{}});
const t: T = .{ .a = 123 };
try std.testing.expect(t.a == 123);
}
@@ -598,20 +317,7 @@ test "reified struct field name from optional payload" {
test "reified union uses @alignOf" {
const S = struct {
fn CreateUnion(comptime T: type) type {
- return @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = null,
- .fields = &[_]std.builtin.Type.UnionField{
- .{
- .name = "field",
- .type = T,
- .alignment = @alignOf(T),
- },
- },
- .decls = &.{},
- },
- });
+ return @Union(.auto, null, &.{"field"}, &.{T}, &.{.{}});
}
};
_ = S.CreateUnion(struct {});
@@ -620,22 +326,13 @@ test "reified union uses @alignOf" {
test "reified struct uses @alignOf" {
const S = struct {
fn NamespacedGlobals(comptime modules: anytype) type {
- return @Type(.{
- .@"struct" = .{
- .layout = .auto,
- .is_tuple = false,
- .fields = &.{
- .{
- .name = "globals",
- .type = modules.mach.globals,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(modules.mach.globals),
- },
- },
- .decls = &.{},
- },
- });
+ return @Struct(
+ .auto,
+ null,
+ &.{"globals"},
+ &.{modules.mach.globals},
+ &.{.{ .@"align" = @alignOf(modules.mach.globals) }},
+ );
}
};
_ = S.NamespacedGlobals(.{
@@ -645,56 +342,10 @@ test "reified struct uses @alignOf" {
});
}
-test "reified error set initialized with field pointer" {
- const S = struct {
- const info = .{
- .args = [_]Type.Error{
- .{ .name = "bar" },
- },
- };
- const Foo = @Type(.{
- .error_set = &info.args,
- });
- };
- try testing.expect(S.Foo == error{bar});
-}
-test "reified function type params initialized with field pointer" {
- const S = struct {
- const fn_info = .{
- .params = [_]Type.Fn.Param{
- .{ .is_generic = false, .is_noalias = false, .type = u8 },
- },
- };
- const Bar = @Type(.{
- .@"fn" = .{
- .calling_convention = .auto,
- .is_generic = false,
- .is_var_args = false,
- .return_type = void,
- .params = &fn_info.params,
- },
- });
- };
- try testing.expect(@typeInfo(S.Bar) == .@"fn");
-}
-
test "empty struct assigned to reified struct field" {
const S = struct {
fn NamespacedComponents(comptime modules: anytype) type {
- return @Type(.{
- .@"struct" = .{
- .layout = .auto,
- .is_tuple = false,
- .fields = &.{.{
- .name = "components",
- .type = @TypeOf(modules.components),
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = @alignOf(@TypeOf(modules.components)),
- }},
- .decls = &.{},
- },
- });
+ return @Struct(.auto, null, &.{"components"}, &.{@TypeOf(modules.components)}, &.{.{}});
}
fn namespacedComponents(comptime modules: anytype) NamespacedComponents(modules) {
@@ -710,16 +361,6 @@ test "empty struct assigned to reified struct field" {
});
}
-test "@Type should resolve its children types" {
- const sparse = enum(u2) { a, b, c };
- const dense = enum(u2) { a, b, c, d };
-
- comptime var sparse_info = @typeInfo(anyerror!sparse);
- sparse_info.error_union.payload = dense;
- const B = @Type(sparse_info);
- try testing.expectEqual(anyerror!dense, B);
-}
-
test "struct field names sliced at comptime from larger string" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
@@ -729,28 +370,14 @@ test "struct field names sliced at comptime from larger string" {
\\f3
;
comptime {
- var fields: []const Type.StructField = &[0]Type.StructField{};
+ var field_names: []const []const u8 = &.{};
var it = std.mem.tokenizeScalar(u8, text, '\n');
while (it.next()) |name| {
- fields = fields ++ &[_]Type.StructField{.{
- .alignment = @alignOf(usize),
- .name = name ++ "",
- .type = usize,
- .default_value_ptr = null,
- .is_comptime = false,
- }};
+ field_names = field_names ++ @as([]const []const u8, &.{name});
}
- const T = @Type(.{
- .@"struct" = .{
- .layout = .auto,
- .is_tuple = false,
- .fields = fields,
- .decls = &.{},
- },
- });
-
+ const T = @Struct(.auto, null, field_names, &@splat(usize), &@splat(.{}));
const gen_fields = @typeInfo(T).@"struct".fields;
try testing.expectEqual(3, gen_fields.len);
try testing.expectEqualStrings("f1", gen_fields[0].name);
@@ -762,10 +389,7 @@ test "struct field names sliced at comptime from larger string" {
test "matching captures causes opaque equivalence" {
const S = struct {
fn UnsignedId(comptime I: type) type {
- const U = @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = @typeInfo(I).int.bits,
- } });
+ const U = @Int(.unsigned, @typeInfo(I).int.bits);
return opaque {
fn id(x: U) U {
return x;
@@ -785,17 +409,9 @@ test "matching captures causes opaque equivalence" {
}
test "reify enum where fields refers to part of array" {
- const fields: [3]std.builtin.Type.EnumField = .{
- .{ .name = "foo", .value = 0 },
- .{ .name = "bar", .value = 1 },
- undefined,
- };
- const E = @Type(.{ .@"enum" = .{
- .tag_type = u8,
- .fields = fields[0..2],
- .decls = &.{},
- .is_exhaustive = true,
- } });
+ const field_names: [3][]const u8 = .{ "foo", "bar", undefined };
+ const field_values: [3]u8 = .{ undefined, 0, 1 };
+ const E = @Enum(u8, .exhaustive, field_names[0..2], field_values[1..3]);
var a: E = undefined;
var b: E = undefined;
a = .foo;
test/behavior/union.zig
@@ -2198,14 +2198,8 @@ test "matching captures causes union equivalence" {
fn SignedUnsigned(comptime I: type) type {
const bits = @typeInfo(I).int.bits;
return union {
- u: @Type(.{ .int = .{
- .signedness = .unsigned,
- .bits = bits,
- } }),
- i: @Type(.{ .int = .{
- .signedness = .signed,
- .bits = bits,
- } }),
+ u: @Int(.unsigned, bits),
+ i: @Int(.signed, bits),
};
}
};
test/cases/compile_errors/@import_zon_bad_type.zig
@@ -116,7 +116,7 @@ export fn testMutablePointer() void {
// tmp.zig:85:26: note: ZON does not allow nested optionals
// tmp.zig:90:29: error: type '*i32' is not available in ZON
// tmp.zig:90:29: note: ZON does not allow mutable pointers
-// neg_inf.zon:1:1: error: expected type '@Type(.enum_literal)'
+// neg_inf.zon:1:1: error: expected type '@EnumLiteral()'
// tmp.zig:37:38: note: imported here
// neg_inf.zon:1:1: error: expected type '?u8'
// tmp.zig:57:28: note: imported here
test/cases/compile_errors/@import_zon_opt_in_err.zig
@@ -70,7 +70,7 @@ export fn testVector() void {
// tmp.zig:22:29: note: imported here
// vec2.zon:1:2: error: expected type '?tmp.Enum'
// tmp.zig:28:30: note: imported here
-// vec2.zon:1:2: error: expected type '?@Type(.enum_literal)'
+// vec2.zon:1:2: error: expected type '?@EnumLiteral()'
// tmp.zig:33:39: note: imported here
// vec2.zon:1:2: error: expected type '?[1]u8'
// tmp.zig:38:31: note: imported here
test/cases/compile_errors/align_zero.zig
@@ -38,31 +38,11 @@ export fn i() void {
}
export fn j() void {
- _ = @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "test",
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = 0,
- }},
- .decls = &.{},
- .is_tuple = false,
- } });
+ _ = @Struct(.auto, null, &.{"test"}, &.{u32}, &.{.{ .@"align" = 0 }});
}
export fn k() void {
- _ = @Type(.{ .pointer = .{
- .size = .one,
- .is_const = false,
- .is_volatile = false,
- .alignment = 0,
- .address_space = .generic,
- .child = u32,
- .is_allowzero = false,
- .sentinel_ptr = null,
- } });
+ _ = @Pointer(.one, .{ .@"align" = 0 }, u32, null);
}
// error
@@ -76,5 +56,5 @@ export fn k() void {
// :29:17: error: alignment must be >= 1
// :33:35: error: alignment must be >= 1
// :37:34: error: alignment must be >= 1
-// :41:9: error: alignment must be >= 1
-// :56:9: error: alignment must be >= 1
+// :41:51: error: alignment must be >= 1
+// :45:25: error: alignment must be >= 1
test/cases/compile_errors/attempt_to_cast_enum_literal_to_error.zig
@@ -6,4 +6,4 @@ export fn entry() void {
// error
//
-// :3:10: error: expected type 'error{Hi}', found '@Type(.enum_literal)'
+// :3:10: error: expected type 'error{Hi}', found '@EnumLiteral()'
test/cases/compile_errors/attempt_to_create_17_bit_float_type.zig
@@ -1,8 +0,0 @@
-const builtin = @import("std").builtin;
-comptime {
- _ = @Type(.{ .float = .{ .bits = 17 } });
-}
-
-// error
-//
-// :3:9: error: 17-bit float unsupported
test/cases/compile_errors/error_set_decl_literal.zig
@@ -6,4 +6,4 @@ export fn entry() void {
// error
//
-// :3:19: error: expected type 'error{Foo}', found '@Type(.enum_literal)'
+// :3:19: error: expected type 'error{Foo}', found '@EnumLiteral()'
test/cases/compile_errors/invalid_pointer_to_opaque.zig
@@ -9,40 +9,13 @@ export fn c() void {
}
export fn d() void {
- _ = @Type(.{ .pointer = .{
- .size = .slice,
- .is_const = false,
- .is_volatile = false,
- .alignment = 1,
- .address_space = .generic,
- .child = anyopaque,
- .is_allowzero = false,
- .sentinel_ptr = null,
- } });
+ _ = @Pointer(.slice, .{}, anyopaque, null);
}
export fn e() void {
- _ = @Type(.{ .pointer = .{
- .size = .many,
- .is_const = false,
- .is_volatile = false,
- .alignment = 1,
- .address_space = .generic,
- .child = anyopaque,
- .is_allowzero = false,
- .sentinel_ptr = null,
- } });
+ _ = @Pointer(.many, .{}, anyopaque, null);
}
export fn f() void {
- _ = @Type(.{ .pointer = .{
- .size = .c,
- .is_const = false,
- .is_volatile = false,
- .alignment = 1,
- .address_space = .generic,
- .child = anyopaque,
- .is_allowzero = false,
- .sentinel_ptr = null,
- } });
+ _ = @Pointer(.c, .{}, anyopaque, null);
}
// error
@@ -51,5 +24,5 @@ export fn f() void {
// :5:12: error: indexable pointer to opaque type 'anyopaque' not allowed
// :8:13: error: indexable pointer to opaque type 'anyopaque' not allowed
// :12:9: error: indexable pointer to opaque type 'anyopaque' not allowed
-// :24:9: error: indexable pointer to opaque type 'anyopaque' not allowed
-// :36:9: error: indexable pointer to opaque type 'anyopaque' not allowed
+// :15:9: error: indexable pointer to opaque type 'anyopaque' not allowed
+// :18:9: error: indexable pointer to opaque type 'anyopaque' not allowed
test/cases/compile_errors/invalid_pointer_with_reify_type.zig
@@ -1,16 +1,7 @@
export fn entry() void {
- _ = @Type(.{ .pointer = .{
- .size = .one,
- .is_const = false,
- .is_volatile = false,
- .alignment = 1,
- .address_space = .generic,
- .child = u8,
- .is_allowzero = false,
- .sentinel_ptr = &@as(u8, 0),
- } });
+ _ = @Pointer(.one, .{}, u8, 0);
}
// error
//
-// :2:9: error: sentinels are only allowed on slices and unknown-length pointers
+// :2:33: error: sentinels are only allowed on slices and unknown-length pointers
test/cases/compile_errors/minmax_nonnumeric_operand.zig
@@ -36,4 +36,4 @@ const Union = union { foo: void };
// :13:29: error: expected number, found 'tmp.Union'
// :19:15: note: union declared here
// :14:61: error: expected number, found 'fn () u8'
-// :15:25: error: expected number, found '@Type(.enum_literal)'
+// :15:25: error: expected number, found '@EnumLiteral()'
test/cases/compile_errors/nested_vectors.zig
@@ -1,10 +1,10 @@
export fn entry() void {
const V1 = @Vector(4, u8);
- const V2 = @Type(.{ .vector = .{ .len = 4, .child = V1 } });
+ const V2 = @Vector(4, V1);
const v: V2 = undefined;
_ = v;
}
// error
//
-// :3:16: error: expected integer, float, bool, or pointer for the vector element type; found '@Vector(4, u8)'
+// :3:27: error: expected integer, float, bool, or pointer for the vector element type; found '@Vector(4, u8)'
test/cases/compile_errors/non_constant_expression_in_array_size.zig
@@ -14,4 +14,4 @@ export fn entry() usize {
//
// :6:12: error: unable to resolve comptime value
// :2:12: note: called at comptime from here
-// :1:13: note: struct fields must be comptime-known
+// :1:13: note: types must be comptime-known
test/cases/compile_errors/non_scalar_sentinel.zig
@@ -12,31 +12,10 @@ comptime {
}
comptime {
- _ = @Type(.{ .array = .{ .child = S, .len = 0, .sentinel_ptr = &sentinel } });
+ _ = @Pointer(.slice, .{}, S, sentinel);
}
comptime {
- _ = @Type(.{ .pointer = .{
- .size = .slice,
- .is_const = false,
- .is_volatile = false,
- .alignment = @alignOf(S),
- .address_space = .generic,
- .child = S,
- .is_allowzero = false,
- .sentinel_ptr = &sentinel,
- } });
-}
-comptime {
- _ = @Type(.{ .pointer = .{
- .size = .many,
- .is_const = false,
- .is_volatile = false,
- .alignment = @alignOf(S),
- .address_space = .generic,
- .child = S,
- .is_allowzero = false,
- .sentinel_ptr = &sentinel,
- } });
+ _ = @Pointer(.many, .{}, S, sentinel);
}
// error
@@ -47,9 +26,7 @@ comptime {
// :1:11: note: struct declared here
// :11:12: error: non-scalar sentinel type 'tmp.S'
// :1:11: note: struct declared here
-// :15:9: error: non-scalar sentinel type 'tmp.S'
-// :1:11: note: struct declared here
-// :18:9: error: non-scalar sentinel type 'tmp.S'
+// :15:34: error: non-scalar sentinel type 'tmp.S'
// :1:11: note: struct declared here
-// :30:9: error: non-scalar sentinel type 'tmp.S'
+// :18:33: error: non-scalar sentinel type 'tmp.S'
// :1:11: note: struct declared here
test/cases/compile_errors/reified_enum_field_value_overflow.zig
@@ -1,17 +1,8 @@
comptime {
- const E = @Type(.{ .@"enum" = .{
- .tag_type = u1,
- .fields = &.{
- .{ .name = "f0", .value = 0 },
- .{ .name = "f1", .value = 1 },
- .{ .name = "f2", .value = 2 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- } });
+ const E = @Enum(u1, .exhaustive, &.{ "f0", "f1", "f2" }, &.{ 0, 1, 2 });
_ = E;
}
// error
//
-// :2:15: error: field 'f2' with enumeration value '2' is too large for backing int type 'u1'
+// :2:72: error: type 'u1' cannot represent integer value '2'
test/cases/compile_errors/reify_enum_with_duplicate_field.zig
@@ -1,18 +1,8 @@
export fn entry() void {
- _ = @Type(.{
- .@"enum" = .{
- .tag_type = u32,
- .fields = &.{
- .{ .name = "A", .value = 0 },
- .{ .name = "A", .value = 1 },
- },
- .decls = &.{},
- .is_exhaustive = false,
- },
- });
+ _ = @Enum(u32, .nonexhaustive, &.{ "A", "A" }, &.{ 0, 1 });
}
// error
//
-// :2:9: error: duplicate enum field 'A'
-// :2:9: note: other field here
+// :2:36: error: duplicate enum field 'A'
+// :2:36: note: other field here
test/cases/compile_errors/reify_enum_with_duplicate_tag_value.zig
@@ -1,18 +1,8 @@
export fn entry() void {
- _ = @Type(.{
- .@"enum" = .{
- .tag_type = u32,
- .fields = &.{
- .{ .name = "A", .value = 10 },
- .{ .name = "B", .value = 10 },
- },
- .decls = &.{},
- .is_exhaustive = false,
- },
- });
+ _ = @Enum(u32, .nonexhaustive, &.{ "A", "B" }, &.{ 10, 10 });
}
// error
//
-// :2:9: error: enum tag value 10 already taken
-// :2:9: note: other enum tag value here
+// :2:52: error: enum tag value 10 already taken
+// :2:52: note: other enum tag value here
test/cases/compile_errors/reify_struct.zig
@@ -1,79 +1,16 @@
comptime {
- @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "foo",
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = 4,
- }},
- .decls = &.{},
- .is_tuple = true,
- } });
+ @Struct(.auto, null, &.{"foo"}, &.{u32}, &.{.{ .@"comptime" = true }});
}
comptime {
- @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "3",
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = false,
- .alignment = 4,
- }},
- .decls = &.{},
- .is_tuple = true,
- } });
+ @Struct(.@"extern", null, &.{"foo"}, &.{u32}, &.{.{ .@"comptime" = true, .default_value_ptr = &@as(u32, 10) }});
}
comptime {
- @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "0",
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = true,
- .alignment = 4,
- }},
- .decls = &.{},
- .is_tuple = true,
- } });
-}
-comptime {
- @Type(.{ .@"struct" = .{
- .layout = .@"extern",
- .fields = &.{.{
- .name = "0",
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = true,
- .alignment = 4,
- }},
- .decls = &.{},
- .is_tuple = false,
- } });
-}
-comptime {
- @Type(.{ .@"struct" = .{
- .layout = .@"packed",
- .fields = &.{.{
- .name = "0",
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = true,
- .alignment = 4,
- }},
- .decls = &.{},
- .is_tuple = false,
- } });
+ @Struct(.@"packed", null, &.{"foo"}, &.{u32}, &.{.{ .@"align" = 4 }});
}
// error
//
-// :2:5: error: tuple cannot have non-numeric field 'foo'
-// :16:5: error: tuple field name '3' does not match field index 0
-// :30:5: error: comptime field without default initialization value
-// :44:5: error: extern struct fields cannot be marked comptime
-// :58:5: error: alignment of a packed struct field must be set to 0
+// :2:46: error: comptime field without default initialization value
+// :5:51: error: extern struct fields cannot be marked comptime
+// :8:51: error: packed struct fields cannot be aligned
test/cases/compile_errors/reify_type.Fn_with_is_generic_true.zig
@@ -1,16 +0,0 @@
-const Foo = @Type(.{
- .@"fn" = .{
- .calling_convention = .auto,
- .is_generic = true,
- .is_var_args = false,
- .return_type = u0,
- .params = &.{},
- },
-});
-comptime {
- _ = Foo;
-}
-
-// error
-//
-// :1:13: error: Type.Fn.is_generic must be false for @Type
test/cases/compile_errors/reify_type.Fn_with_is_var_args_true_and_non-C_callconv.zig
@@ -1,18 +1,9 @@
-const Foo = @Type(.{
- .@"fn" = .{
- .calling_convention = .auto,
- .is_generic = false,
- .is_var_args = true,
- .return_type = u0,
- .params = &.{},
- },
-});
comptime {
- _ = Foo;
+ _ = @Fn(&.{u32}, &.{.{}}, u8, .{ .varargs = true });
}
// error
// target=x86_64-linux
//
-// :1:13: error: variadic function does not support 'auto' calling convention
-// :1:13: note: supported calling conventions: 'x86_64_sysv', 'x86_64_x32', 'x86_64_win'
+// :2:36: error: variadic function does not support 'auto' calling convention
+// :2:36: note: supported calling conventions: 'x86_64_sysv', 'x86_64_x32', 'x86_64_win'
test/cases/compile_errors/reify_type.Fn_with_return_type_null.zig
@@ -1,16 +0,0 @@
-const Foo = @Type(.{
- .@"fn" = .{
- .calling_convention = .auto,
- .is_generic = false,
- .is_var_args = false,
- .return_type = null,
- .params = &.{},
- },
-});
-comptime {
- _ = Foo;
-}
-
-// error
-//
-// :1:13: error: Type.Fn.return_type must be non-null for @Type
test/cases/compile_errors/reify_type_for_exhaustive_enum_with_non-integer_tag_type.zig
@@ -1,15 +1,8 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = bool,
- .fields = &.{},
- .decls = &.{},
- .is_exhaustive = false,
- },
-});
+const Tag = @Enum(bool, .nonexhaustive, &.{}, &.{});
export fn entry() void {
_ = @as(Tag, @enumFromInt(0));
}
// error
//
-// :1:13: error: Type.Enum.tag_type must be an integer type
+// :1:19: error: tag type must be an integer type
test/cases/compile_errors/reify_type_for_exhaustive_enum_with_undefined_tag_type.zig
@@ -1,15 +1,8 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = undefined,
- .fields = &.{},
- .decls = &.{},
- .is_exhaustive = false,
- },
-});
+const Tag = @Enum(undefined, .exhaustive, &.{}, &.{});
export fn entry() void {
_ = @as(Tag, @enumFromInt(0));
}
// error
//
-// :1:20: error: use of undefined value here causes illegal behavior
+// :1:19: error: use of undefined value here causes illegal behavior
test/cases/compile_errors/reify_type_for_tagged_extern_union.zig
@@ -1,26 +1,5 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u2,
- .fields = &.{
- .{ .name = "signed", .value = 0 },
- .{ .name = "unsigned", .value = 1 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
-});
-
-const Extern = @Type(.{
- .@"union" = .{
- .layout = .@"extern",
- .tag_type = Tag,
- .fields = &.{
- .{ .name = "signed", .type = i32, .alignment = @alignOf(i32) },
- .{ .name = "unsigned", .type = u32, .alignment = @alignOf(u32) },
- },
- .decls = &.{},
- },
-});
+const Tag = @Enum(u2, .exhaustive, &.{ "signed", "unsigned" }, &.{ 0, 1 });
+const Extern = @Union(.@"extern", Tag, &.{ "signed", "unsigned" }, &.{ i32, u32 }, &@splat(.{}));
export fn entry() void {
const tagged: Extern = .{ .signed = -1 };
@@ -29,4 +8,4 @@ export fn entry() void {
// error
//
-// :13:16: error: extern union does not support enum tag type
+// :2:35: error: extern union does not support enum tag type
test/cases/compile_errors/reify_type_for_tagged_packed_union.zig
@@ -1,26 +1,5 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u2,
- .fields = &.{
- .{ .name = "signed", .value = 0 },
- .{ .name = "unsigned", .value = 1 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
-});
-
-const Packed = @Type(.{
- .@"union" = .{
- .layout = .@"packed",
- .tag_type = Tag,
- .fields = &.{
- .{ .name = "signed", .type = i32, .alignment = @alignOf(i32) },
- .{ .name = "unsigned", .type = u32, .alignment = @alignOf(u32) },
- },
- .decls = &.{},
- },
-});
+const Tag = @Enum(u2, .exhaustive, &.{ "signed", "unsigned" }, &.{ 0, 1 });
+const Packed = @Union(.@"packed", Tag, &.{ "signed", "unsigned" }, &.{ i32, u32 }, &@splat(.{}));
export fn entry() void {
const tagged: Packed = .{ .signed = -1 };
@@ -29,4 +8,4 @@ export fn entry() void {
// error
//
-// :13:16: error: packed union does not support enum tag type
+// :2:35: error: packed union does not support enum tag type
test/cases/compile_errors/reify_type_for_tagged_union_with_extra_enum_field.zig
@@ -1,26 +1,5 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u2,
- .fields = &.{
- .{ .name = "signed", .value = 0 },
- .{ .name = "unsigned", .value = 1 },
- .{ .name = "arst", .value = 2 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
-});
-const Tagged = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = Tag,
- .fields = &.{
- .{ .name = "signed", .type = i32, .alignment = @alignOf(i32) },
- .{ .name = "unsigned", .type = u32, .alignment = @alignOf(u32) },
- },
- .decls = &.{},
- },
-});
+const Tag = @Enum(u2, .exhaustive, &.{ "signed", "unsigned", "arst" }, &.{ 0, 1, 2 });
+const Tagged = @Union(.auto, Tag, &.{ "signed", "unsigned" }, &.{ i32, u32 }, &@splat(.{}));
export fn entry() void {
var tagged = Tagged{ .signed = -1 };
tagged = .{ .unsigned = 1 };
@@ -28,6 +7,6 @@ export fn entry() void {
// error
//
-// :13:16: error: enum fields missing in union
+// :2:35: error: 1 enum fields missing in union
// :1:13: note: field 'arst' missing, declared here
// :1:13: note: enum declared here
test/cases/compile_errors/reify_type_for_tagged_union_with_extra_union_field.zig
@@ -1,26 +1,5 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u1,
- .fields = &.{
- .{ .name = "signed", .value = 0 },
- .{ .name = "unsigned", .value = 1 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
-});
-const Tagged = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = Tag,
- .fields = &.{
- .{ .name = "signed", .type = i32, .alignment = @alignOf(i32) },
- .{ .name = "unsigned", .type = u32, .alignment = @alignOf(u32) },
- .{ .name = "arst", .type = f32, .alignment = @alignOf(f32) },
- },
- .decls = &.{},
- },
-});
+const Tag = @Enum(u1, .exhaustive, &.{ "signed", "unsigned" }, &.{ 0, 1 });
+const Tagged = @Union(.auto, Tag, &.{ "signed", "unsigned", "arst" }, &.{ i32, u32, f32 }, &@splat(.{}));
export fn entry() void {
var tagged = Tagged{ .signed = -1 };
tagged = .{ .unsigned = 1 };
@@ -28,5 +7,5 @@ export fn entry() void {
// error
//
-// :12:16: error: no field named 'arst' in enum 'tmp.Tag'
+// :2:35: error: no field named 'arst' in enum 'tmp.Tag'
// :1:13: note: enum declared here
test/cases/compile_errors/reify_type_for_tagged_union_with_no_enum_fields.zig
@@ -1,22 +1,5 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u0,
- .fields = &.{},
- .decls = &.{},
- .is_exhaustive = true,
- },
-});
-const Tagged = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = Tag,
- .fields = &.{
- .{ .name = "signed", .type = i32, .alignment = @alignOf(i32) },
- .{ .name = "unsigned", .type = u32, .alignment = @alignOf(u32) },
- },
- .decls = &.{},
- },
-});
+const Tag = @Enum(u0, .exhaustive, &.{}, &.{});
+const Tagged = @Union(.auto, Tag, &.{ "signed", "unsigned" }, &.{ i32, u32 }, &@splat(.{}));
export fn entry() void {
const tagged: Tagged = undefined;
_ = tagged;
@@ -24,5 +7,5 @@ export fn entry() void {
// error
//
-// :9:16: error: no field named 'signed' in enum 'tmp.Tag'
+// :2:35: error: no field named 'signed' in enum 'tmp.Tag'
// :1:13: note: enum declared here
test/cases/compile_errors/reify_type_for_tagged_union_with_no_union_fields.zig
@@ -1,22 +1,5 @@
-const Tag = @Type(.{
- .@"enum" = .{
- .tag_type = u1,
- .fields = &.{
- .{ .name = "signed", .value = 0 },
- .{ .name = "unsigned", .value = 1 },
- },
- .decls = &.{},
- .is_exhaustive = true,
- },
-});
-const Tagged = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = Tag,
- .fields = &.{},
- .decls = &.{},
- },
-});
+const Tag = @Enum(u1, .exhaustive, &.{ "signed", "unsigned" }, &.{ 0, 1 });
+const Tagged = @Union(.auto, Tag, &.{}, &.{}, &.{});
export fn entry() void {
const tagged: Tagged = undefined;
_ = tagged;
@@ -24,7 +7,7 @@ export fn entry() void {
// error
//
-// :12:16: error: enum fields missing in union
+// :2:35: error: 2 enum fields missing in union
// :1:13: note: field 'signed' missing, declared here
// :1:13: note: field 'unsigned' missing, declared here
// :1:13: note: enum declared here
test/cases/compile_errors/reify_type_for_union_with_opaque_field.zig
@@ -1,18 +1,9 @@
-const Untagged = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = null,
- .fields = &.{
- .{ .name = "foo", .type = opaque {}, .alignment = 1 },
- },
- .decls = &.{},
- },
-});
+const Untagged = @Union(.auto, null, &.{"foo"}, &.{opaque {}}, &.{.{}});
export fn entry() usize {
return @sizeOf(Untagged);
}
// error
//
-// :1:18: error: opaque types have unknown size and therefore cannot be directly embedded in unions
-// :6:39: note: opaque declared here
+// :1:49: error: opaque types have unknown size and therefore cannot be directly embedded in unions
+// :1:52: note: opaque declared here
test/cases/compile_errors/reify_type_union_payload_is_undefined.zig
@@ -1,10 +0,0 @@
-const Foo = @Type(.{
- .@"struct" = undefined,
-});
-comptime {
- _ = Foo;
-}
-
-// error
-//
-// :1:20: error: use of undefined value here causes illegal behavior
test/cases/compile_errors/reify_type_with_invalid_field_alignment.zig
@@ -1,48 +1,15 @@
comptime {
- _ = @Type(.{
- .@"union" = .{
- .layout = .auto,
- .tag_type = null,
- .fields = &.{
- .{ .name = "foo", .type = usize, .alignment = 3 },
- },
- .decls = &.{},
- },
- });
+ _ = @Union(.auto, null, &.{"foo"}, &.{usize}, &.{.{ .@"align" = 3 }});
}
comptime {
- _ = @Type(.{
- .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "0",
- .type = u32,
- .default_value_ptr = null,
- .is_comptime = true,
- .alignment = 5,
- }},
- .decls = &.{},
- .is_tuple = false,
- },
- });
+ _ = @Struct(.auto, null, &.{"a"}, &.{u32}, &.{.{ .@"comptime" = true, .@"align" = 5 }});
}
comptime {
- _ = @Type(.{
- .pointer = .{
- .size = .many,
- .is_const = true,
- .is_volatile = false,
- .alignment = 7,
- .address_space = .generic,
- .child = u8,
- .is_allowzero = false,
- .sentinel_ptr = null,
- },
- });
+ _ = @Pointer(.many, .{ .@"align" = 7 }, u8, null);
}
// error
//
-// :2:9: error: alignment value '3' is not a power of two
-// :14:9: error: alignment value '5' is not a power of two
-// :30:9: error: alignment value '7' is not a power of two
+// :2:51: error: alignment value '3' is not a power of two
+// :5:48: error: alignment value '5' is not a power of two
+// :8:26: error: alignment value '7' is not a power of two
test/cases/compile_errors/reify_type_with_Type.Int.zig
@@ -1,13 +0,0 @@
-const builtin = @import("std").builtin;
-export fn entry() void {
- _ = @Type(builtin.Type.Int{
- .signedness = .signed,
- .bits = 8,
- });
-}
-
-// error
-//
-// :3:31: error: expected type 'builtin.Type', found 'builtin.Type.Int'
-// :?:?: note: struct declared here
-// :?:?: note: union declared here
test/cases/compile_errors/reify_type_with_undefined.zig
@@ -1,31 +1,11 @@
comptime {
- _ = @Type(.{ .array = .{ .len = 0, .child = u8, .sentinel_ptr = undefined } });
+ _ = @Struct(.auto, null, &.{}, &.{}, undefined);
}
comptime {
- _ = @Type(.{
- .@"struct" = .{
- .fields = undefined,
- .decls = undefined,
- .is_tuple = false,
- .layout = .auto,
- },
- });
-}
-comptime {
- const std = @import("std");
- const fields: [1]std.builtin.Type.StructField = undefined;
- _ = @Type(.{
- .@"struct" = .{
- .layout = .auto,
- .fields = &fields,
- .decls = &.{},
- .is_tuple = false,
- },
- });
+ _ = @Struct(.auto, null, &.{"foo"}, &.{undefined}, &.{.{}});
}
// error
//
-// :2:16: error: use of undefined value here causes illegal behavior
-// :5:16: error: use of undefined value here causes illegal behavior
-// :17:16: error: use of undefined value here causes illegal behavior
+// :2:42: error: use of undefined value here causes illegal behavior
+// :5:41: error: use of undefined value here causes illegal behavior
test/cases/compile_errors/runtime_condition_comptime_type_in_destructure.zig
@@ -7,4 +7,4 @@ export fn foobar() void {
// error
//
-// :4:5: error: value with comptime-only type '@Type(.enum_literal)' depends on runtime control flow
+// :4:5: error: value with comptime-only type '@EnumLiteral()' depends on runtime control flow
test/cases/compile_errors/tagName_on_undef_enum_literal.zig
@@ -1,5 +1,5 @@
comptime {
- const undef: @Type(.enum_literal) = undefined;
+ const undef: @EnumLiteral() = undefined;
_ = @tagName(undef);
}
test/cases/compile_errors/unable_to_evaluate_comptime_expr.zig
@@ -42,4 +42,4 @@ pub export fn entry3() void {
// :13:13: note: initializer of container-level variable must be comptime-known
// :22:9: error: unable to evaluate comptime expression
// :22:21: note: operation is runtime due to this operand
-// :21:13: note: enum fields must be comptime-known
+// :21:13: note: enum field values must be comptime-known
test/cases/compile_errors/wrong_type_for_reify_type.zig
@@ -1,8 +1,25 @@
-export fn entry() void {
- _ = @Type(0);
+export fn entryI() void {
+ _ = @Int(0, 0);
+}
+
+export fn entryE() void {
+ _ = @Enum(0, 0, 0, 0);
+}
+
+export fn entryS() void {
+ _ = @Struct(0, 0, &.{}, &.{}, &.{});
+}
+
+export fn entryU() void {
+ _ = @Union(0, 0, &.{}, &.{}, &.{});
}
// error
//
-// :2:15: error: expected type 'builtin.Type', found 'comptime_int'
-// :?:?: note: union declared here
+// :2:14: error: expected type 'builtin.Signedness', found 'comptime_int'
+// :?:?: note: enum declared here
+// :6:15: error: expected type 'type', found 'comptime_int'
+// :10:17: error: expected type 'builtin.Type.ContainerLayout', found 'comptime_int'
+// :?:?: enum declared here
+// :14:16: error: expected type 'builtin.Type.ContainerLayout', found 'comptime_int'
+// :?:?: enum declared here
test/cases/default_value_references_comptime_var.zig
@@ -2,49 +2,27 @@ export fn foo() void {
comptime var a: u8 = 0;
_ = struct { comptime *u8 = &a };
}
-export fn bar() void {
- comptime var a: u8 = 0;
- _ = @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "0",
- .type = *u8,
- .default_value_ptr = @ptrCast(&&a),
- .is_comptime = true,
- .alignment = @alignOf(*u8),
- }},
- .decls = &.{},
- .is_tuple = true,
- } });
-}
-export fn baz() void {
+export fn bar() void {
comptime var a: u8 = 0;
_ = struct { foo: *u8 = &a };
}
-export fn qux() void {
+export fn baz() void {
comptime var a: u8 = 0;
- _ = @Type(.{ .@"struct" = .{
- .layout = .auto,
- .fields = &.{.{
- .name = "foo",
- .type = *u8,
- .default_value_ptr = @ptrCast(&&a),
- .is_comptime = false,
- .alignment = @alignOf(*u8),
- }},
- .decls = &.{},
- .is_tuple = false,
- } });
+ _ = @Struct(
+ .auto,
+ null,
+ &.{"foo"},
+ &.{*u8},
+ &.{.{ .default_value_ptr = @ptrCast(&&a) }},
+ );
}
// error
//
// :3:33: error: field default value contains reference to comptime var
// :2:14: note: '0' points to comptime var declared here
-// :7:9: error: field default value contains reference to comptime var
-// :6:14: note: '0' points to comptime var declared here
-// :23:9: error: captured value contains reference to comptime var
-// :22:14: note: 'a' points to comptime var declared here
-// :27:9: error: field default value contains reference to comptime var
-// :26:14: note: 'foo' points to comptime var declared here
+// :8:9: error: captured value contains reference to comptime var
+// :7:14: note: 'a' points to comptime var declared here
+// :17:9: error: field default value contains reference to comptime var
+// :11:14: note: 'foo' points to comptime var declared here
test/cases/sentinel_references_comptime_var.zig
@@ -2,14 +2,6 @@ export fn foo() void {
comptime var a: u8 = 0;
_ = [0:&a]*u8;
}
-export fn bar() void {
- comptime var a: u8 = 0;
- _ = @Type(.{ .array = .{
- .child = *u8,
- .len = 0,
- .sentinel_ptr = @ptrCast(&&a),
- } });
-}
export fn baz() void {
comptime var a: u8 = 0;
@@ -17,25 +9,14 @@ export fn baz() void {
}
export fn qux() void {
comptime var a: u8 = 0;
- _ = @Type(.{ .pointer = .{
- .size = .many,
- .is_const = false,
- .is_volatile = false,
- .alignment = @alignOf(u8),
- .address_space = .generic,
- .child = *u8,
- .is_allowzero = false,
- .sentinel_ptr = @ptrCast(&&a),
- } });
+ _ = @Pointer(.many, .{}, *u8, &a);
}
// error
//
// :3:12: error: sentinel contains reference to comptime var
// :2:14: note: 'sentinel' points to comptime var declared here
-// :7:9: error: sentinel contains reference to comptime var
-// :6:14: note: 'sentinel_ptr' points to comptime var declared here
-// :16:11: error: sentinel contains reference to comptime var
-// :15:14: note: 'sentinel' points to comptime var declared here
-// :20:9: error: sentinel contains reference to comptime var
-// :19:14: note: 'sentinel_ptr' points to comptime var declared here
+// :8:11: error: sentinel contains reference to comptime var
+// :7:14: note: 'sentinel' points to comptime var declared here
+// :12:35: error: sentinel contains reference to comptime var
+// :11:14: note: 'sentinel' points to comptime var declared here
test/standalone/simple/issue_7030.zig
@@ -6,7 +6,7 @@ pub const std_options: std.Options = .{
pub fn log(
comptime message_level: std.log.Level,
- comptime scope: @Type(.enum_literal),
+ comptime scope: @EnumLiteral(),
comptime format: []const u8,
args: anytype,
) void {
test/standalone/simple/std_enums_big_enums.zig
@@ -3,20 +3,18 @@ const std = @import("std");
// big enums should not hit the eval branch quota
pub fn main() void {
const big = struct {
- const Big = @Type(.{ .@"enum" = .{
- .tag_type = u16,
- .fields = make_fields: {
- @setEvalBranchQuota(500000);
- var fields: [1001]std.builtin.Type.EnumField = undefined;
- for (&fields, 0..) |*field, i| {
- field.* = .{ .name = std.fmt.comptimePrint("field_{d}", .{i}), .value = i };
- }
- fields[1000] = .{ .name = "field_9999", .value = 9999 };
- break :make_fields &fields;
- },
- .decls = &.{},
- .is_exhaustive = true,
- } });
+ const Big = Big: {
+ @setEvalBranchQuota(500000);
+ var names: [1001][]const u8 = undefined;
+ var values: [1001]u16 = undefined;
+ for (values[0..1000], names[0..1000], 0..1000) |*val, *name, i| {
+ name.* = std.fmt.comptimePrint("field_{d}", .{i});
+ val.* = i;
+ }
+ names[1000] = "field_9999";
+ values[1000] = 9999;
+ break :Big @Enum(u16, .exhaustive, &names, &values);
+ };
};
var set = std.enums.EnumSet(big.Big).init(.{});
@@ -29,10 +27,11 @@ pub fn main() void {
var multiset = std.enums.EnumMultiset(big.Big).init(.{});
_ = &multiset;
+ @setEvalBranchQuota(4000);
+
var bounded_multiset = std.enums.BoundedEnumMultiset(big.Big, u8).init(.{});
_ = &bounded_multiset;
- @setEvalBranchQuota(3000);
var array = std.enums.EnumArray(big.Big, u8).init(undefined);
array = std.enums.EnumArray(big.Big, u8).initDefault(123, .{});
}
tools/lldb_pretty_printers.py
@@ -559,7 +559,7 @@ type_tag_handlers = {
'extern_options': lambda payload: 'std.builtin.ExternOptions',
'type_info': lambda payload: 'std.builtin.Type',
- 'enum_literal': lambda payload: '@TypeOf(.enum_literal)',
+ 'enum_literal': lambda payload: '@EnumLiteral()',
'null': lambda payload: '@TypeOf(null)',
'undefined': lambda payload: '@TypeOf(undefined)',
'empty_struct_literal': lambda payload: '@TypeOf(.{})',