mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 14:23:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

all: update to std.builtin.Type.{Pointer,Array,StructField} field renames

Browse Source
This commit is contained in:
mlugg 2025-01-15 17:34:12 +00:00
parent 89a9cabafd
commit 9804cc8bc6
No known key found for this signature in database
GPG Key ID: 3F5B7DCCBF4AF02E
26 changed files with 117 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/std/Build/Step/Options.zig
View File

@ -318,9 +318,7 @@ fn printStruct(options: *Options, out: anytype, comptime T: type, comptime val:
try out.print(" {p_}: {s}", .{ std.zig.fmtId(field.name), type_name });
}
if (field.default_value != null) {
const default_value = @as(*field.type, @ptrCast(@alignCast(@constCast(field.default_value.?)))).*;
if (field.defaultValue()) |default_value| {
try out.writeAll(" = ");
switch (@typeInfo(@TypeOf(default_value))) {
.@"enum" => try out.print(".{s},\n", .{@tagName(default_value)}),

2
lib/std/crypto/phc_encoding.zig
View File

@ -164,7 +164,7 @@ pub fn deserialize(comptime HashResult: type, str: []const u8) Error!HashResult
// with default values
var expected_fields: usize = 0;
inline for (comptime meta.fields(HashResult)) |p| {
if (@typeInfo(p.type) != .optional and p.default_value == null) {
if (@typeInfo(p.type) != .optional and p.default_value_ptr == null) {
expected_fields += 1;
}
}

2
lib/std/enums.zig
View File

@ -19,7 +19,7 @@ pub fn EnumFieldStruct(comptime E: type, comptime Data: type, comptime field_def
struct_field.* = .{
.name = enum_field.name ++ "",
.type = Data,
.default_value = if (field_default) |d| @as(?*const anyopaque, @ptrCast(&d)) else null,
.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,
};

2
lib/std/fmt.zig
View File

@ -633,7 +633,7 @@ pub fn formatType(
.many, .c => {
if (actual_fmt.len == 0)
@compileError("cannot format pointer without a specifier (i.e. {s} or {*})");
if (ptr_info.sentinel) |_| {
if (ptr_info.sentinel() != null) {
return formatType(mem.span(value), actual_fmt, options, writer, max_depth);
}
if (actual_fmt[0] == 's' and ptr_info.child == u8) {

2
lib/std/io.zig
View File

@ -805,7 +805,7 @@ pub fn PollFiles(comptime StreamEnum: type) type {
struct_field.* = .{
.name = enum_field.name ++ "",
.type = fs.File,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = @alignOf(fs.File),
};

20
lib/std/json/static.zig
View File

@ -476,9 +476,8 @@ pub fn innerParse(
arraylist.appendAssumeCapacity(try innerParse(ptrInfo.child, allocator, source, options));
}
if (ptrInfo.sentinel) |some| {
const sentinel_value = @as(*align(1) const ptrInfo.child, @ptrCast(some)).*;
return try arraylist.toOwnedSliceSentinel(sentinel_value);
if (ptrInfo.sentinel()) |s| {
return try arraylist.toOwnedSliceSentinel(s);
}
return try arraylist.toOwnedSlice();
@ -487,11 +486,11 @@ pub fn innerParse(
if (ptrInfo.child != u8) return error.UnexpectedToken;
// Dynamic length string.
if (ptrInfo.sentinel) |sentinel_ptr| {
if (ptrInfo.sentinel()) |s| {
// Use our own array list so we can append the sentinel.
var value_list = ArrayList(u8).init(allocator);
_ = try source.allocNextIntoArrayList(&value_list, .alloc_always);
return try value_list.toOwnedSliceSentinel(@as(*const u8, @ptrCast(sentinel_ptr)).*);
return try value_list.toOwnedSliceSentinel(s);
}
if (ptrInfo.is_const) {
switch (try source.nextAllocMax(allocator, options.allocate.?, options.max_value_len.?)) {
@ -714,8 +713,8 @@ pub fn innerParseFromValue(
.slice => {
switch (source) {
.array => |array| {
const r = if (ptrInfo.sentinel) |sentinel_ptr|
try allocator.allocSentinel(ptrInfo.child, array.items.len, @as(*align(1) const ptrInfo.child, @ptrCast(sentinel_ptr)).*)
const r = if (ptrInfo.sentinel()) |sentinel|
try allocator.allocSentinel(ptrInfo.child, array.items.len, sentinel)
else
try allocator.alloc(ptrInfo.child, array.items.len);
@ -729,8 +728,8 @@ pub fn innerParseFromValue(
if (ptrInfo.child != u8) return error.UnexpectedToken;
// Dynamic length string.
const r = if (ptrInfo.sentinel) |sentinel_ptr|
try allocator.allocSentinel(ptrInfo.child, s.len, @as(*align(1) const ptrInfo.child, @ptrCast(sentinel_ptr)).*)
const r = if (ptrInfo.sentinel()) |sentinel|
try allocator.allocSentinel(ptrInfo.child, s.len, sentinel)
else
try allocator.alloc(ptrInfo.child, s.len);
@memcpy(r[0..], s);
@ -787,8 +786,7 @@ fn sliceToEnum(comptime T: type, slice: []const u8) !T {
fn fillDefaultStructValues(comptime T: type, r: *T, fields_seen: *[@typeInfo(T).@"struct".fields.len]bool) !void {
inline for (@typeInfo(T).@"struct".fields, 0..) |field, i| {
if (!fields_seen[i]) {
if (field.default_value) |default_ptr| {
const default = @as(*align(1) const field.type, @ptrCast(default_ptr)).*;
if (field.defaultValue()) |default| {
@field(r, field.name) = default;
} else {
return error.MissingField;

2
lib/std/json/stringify.zig
View File

@ -642,7 +642,7 @@ pub fn WriteStream(
},
},
.many, .slice => {
if (ptr_info.size == .many and ptr_info.sentinel == null)
if (ptr_info.size == .many and ptr_info.sentinel() == null)
@compileError("unable to stringify type '" ++ @typeName(T) ++ "' without sentinel");
const slice = if (ptr_info.size == .many) std.mem.span(value) else value;

75
lib/std/mem.zig
View File

@ -263,8 +263,8 @@ pub fn zeroes(comptime T: type) T {
.pointer => |ptr_info| {
switch (ptr_info.size) {
.slice => {
if (ptr_info.sentinel) |sentinel| {
if (ptr_info.child == u8 and @as(*const u8, @ptrCast(sentinel)).* == 0) {
if (ptr_info.sentinel()) |sentinel| {
if (ptr_info.child == u8 and sentinel == 0) {
return ""; // A special case for the most common use-case: null-terminated strings.
}
@compileError("Can't set a sentinel slice to zero. This would require allocating memory.");
@ -282,11 +282,7 @@ pub fn zeroes(comptime T: type) T {
}
},
.array => |info| {
if (info.sentinel) |sentinel_ptr| {
const sentinel = @as(*align(1) const info.child, @ptrCast(sentinel_ptr)).*;
return [_:sentinel]info.child{zeroes(info.child)} ** info.len;
}
return [_]info.child{zeroes(info.child)} ** info.len;
return @splat(zeroes(info.child));
},
.vector => |info| {
return @splat(zeroes(info.child));
@ -456,9 +452,8 @@ pub fn zeroInit(comptime T: type, init: anytype) T {
@field(value, field.name) = @field(init, field.name);
},
}
} else if (field.default_value) |default_value_ptr| {
const default_value = @as(*align(1) const field.type, @ptrCast(default_value_ptr)).*;
@field(value, field.name) = default_value;
} else if (field.defaultValue()) |val| {
@field(value, field.name) = val;
} else {
switch (@typeInfo(field.type)) {
.@"struct" => {
@ -782,10 +777,10 @@ fn Span(comptime T: type) type {
var new_ptr_info = ptr_info;
switch (ptr_info.size) {
.c => {
new_ptr_info.sentinel = &@as(ptr_info.child, 0);
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)),
.many => if (ptr_info.sentinel() == null) @compileError("invalid type given to std.mem.span: " ++ @typeName(T)),
.one, .slice => @compileError("invalid type given to std.mem.span: " ++ @typeName(T)),
}
new_ptr_info.size = .slice;
@ -822,8 +817,7 @@ pub fn span(ptr: anytype) Span(@TypeOf(ptr)) {
const Result = Span(@TypeOf(ptr));
const l = len(ptr);
const ptr_info = @typeInfo(Result).pointer;
if (ptr_info.sentinel) |s_ptr| {
const s = @as(*align(1) const ptr_info.child, @ptrCast(s_ptr)).*;
if (ptr_info.sentinel()) |s| {
return ptr[0..l :s];
} else {
return ptr[0..l];
@ -853,12 +847,11 @@ fn SliceTo(comptime T: type, comptime end: std.meta.Elem(T)) type {
// 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) |sentinel_ptr| {
const sentinel = @as(*align(1) const array_info.child, @ptrCast(sentinel_ptr)).*;
if (end == sentinel) {
new_ptr_info.sentinel = &end;
if (array_info.sentinel()) |s| {
if (end == s) {
new_ptr_info.sentinel_ptr = &end;
} else {
new_ptr_info.sentinel = null;
new_ptr_info.sentinel_ptr = null;
}
}
},
@ -868,17 +861,16 @@ fn SliceTo(comptime T: type, comptime end: std.meta.Elem(T)) type {
// 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) |sentinel_ptr| {
const sentinel = @as(*align(1) const ptr_info.child, @ptrCast(sentinel_ptr)).*;
if (end == sentinel) {
new_ptr_info.sentinel = &end;
if (ptr_info.sentinel()) |s| {
if (end == s) {
new_ptr_info.sentinel_ptr = &end;
} else {
new_ptr_info.sentinel = null;
new_ptr_info.sentinel_ptr = null;
}
}
},
.c => {
new_ptr_info.sentinel = &end;
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;
@ -906,8 +898,7 @@ pub fn sliceTo(ptr: anytype, comptime end: std.meta.Elem(@TypeOf(ptr))) SliceTo(
const Result = SliceTo(@TypeOf(ptr), end);
const length = lenSliceTo(ptr, end);
const ptr_info = @typeInfo(Result).pointer;
if (ptr_info.sentinel) |s_ptr| {
const s = @as(*align(1) const ptr_info.child, @ptrCast(s_ptr)).*;
if (ptr_info.sentinel()) |s| {
return ptr[0..length :s];
} else {
return ptr[0..length];
@ -959,9 +950,8 @@ fn lenSliceTo(ptr: anytype, comptime end: std.meta.Elem(@TypeOf(ptr))) usize {
.pointer => |ptr_info| switch (ptr_info.size) {
.one => switch (@typeInfo(ptr_info.child)) {
.array => |array_info| {
if (array_info.sentinel) |sentinel_ptr| {
const sentinel = @as(*align(1) const array_info.child, @ptrCast(sentinel_ptr)).*;
if (sentinel == end) {
if (array_info.sentinel()) |s| {
if (s == end) {
return indexOfSentinel(array_info.child, end, ptr);
}
}
@ -969,16 +959,15 @@ fn lenSliceTo(ptr: anytype, comptime end: std.meta.Elem(@TypeOf(ptr))) usize {
},
else => {},
},
.many => if (ptr_info.sentinel) |sentinel_ptr| {
const sentinel = @as(*align(1) const ptr_info.child, @ptrCast(sentinel_ptr)).*;
if (sentinel == end) {
.many => if (ptr_info.sentinel()) |s| {
if (s == end) {
return indexOfSentinel(ptr_info.child, end, ptr);
}
// We're looking for something other than the sentinel,
// but iterating past the sentinel would be a bug so we need
// to check for both.
var i: usize = 0;
while (ptr[i] != end and ptr[i] != sentinel) i += 1;
while (ptr[i] != end and ptr[i] != s) i += 1;
return i;
},
.c => {
@ -986,10 +975,9 @@ fn lenSliceTo(ptr: anytype, comptime end: std.meta.Elem(@TypeOf(ptr))) usize {
return indexOfSentinel(ptr_info.child, end, ptr);
},
.slice => {
if (ptr_info.sentinel) |sentinel_ptr| {
const sentinel = @as(*align(1) const ptr_info.child, @ptrCast(sentinel_ptr)).*;
if (sentinel == end) {
return indexOfSentinel(ptr_info.child, sentinel, ptr);
if (ptr_info.sentinel()) |s| {
if (s == end) {
return indexOfSentinel(ptr_info.child, s, ptr);
}
}
return indexOfScalar(ptr_info.child, ptr, end) orelse ptr.len;
@ -1040,9 +1028,8 @@ pub fn len(value: anytype) usize {
switch (@typeInfo(@TypeOf(value))) {
.pointer => |info| switch (info.size) {
.many => {
const sentinel_ptr = info.sentinel orelse
const sentinel = info.sentinel() orelse
@compileError("invalid type given to std.mem.len: " ++ @typeName(@TypeOf(value)));
const sentinel = @as(*align(1) const info.child, @ptrCast(sentinel_ptr)).*;
return indexOfSentinel(info.child, sentinel, value);
},
.c => {
@ -3587,7 +3574,7 @@ fn ReverseIterator(comptime T: type) type {
var new_ptr_info = ptr_info;
new_ptr_info.size = .many;
new_ptr_info.child = array_info.child;
new_ptr_info.sentinel = array_info.sentinel;
new_ptr_info.sentinel_ptr = array_info.sentinel_ptr;
break :blk @Type(.{ .pointer = new_ptr_info });
},
else => {},
@ -3608,7 +3595,7 @@ fn ReverseIterator(comptime T: type) type {
var ptr = @typeInfo(Pointer).pointer;
ptr.size = .one;
ptr.child = Element;
ptr.sentinel = null;
ptr.sentinel_ptr = null;
break :ptr ptr;
} });
return struct {
@ -3979,7 +3966,7 @@ fn CopyPtrAttrs(
.alignment = info.alignment,
.address_space = info.address_space,
.child = child,
.sentinel = null,
.sentinel_ptr = null,
},
});
}
@ -4547,7 +4534,7 @@ fn AlignedSlice(comptime AttributeSource: type, comptime new_alignment: usize) t
.alignment = new_alignment,
.address_space = info.address_space,
.child = info.child,
.sentinel = null,
.sentinel_ptr = null,
},
});
}

2
lib/std/mem/Allocator.zig
View File

@ -307,7 +307,7 @@ pub fn reallocAdvanced(
pub fn free(self: Allocator, memory: anytype) void {
const Slice = @typeInfo(@TypeOf(memory)).pointer;
const bytes = mem.sliceAsBytes(memory);
const bytes_len = bytes.len + if (Slice.sentinel != null) @sizeOf(Slice.child) else 0;
const bytes_len = bytes.len + if (Slice.sentinel() != null) @sizeOf(Slice.child) else 0;
if (bytes_len == 0) return;
const non_const_ptr = @constCast(bytes.ptr);
// TODO: https://github.com/ziglang/zig/issues/4298

25
lib/std/meta.zig
View File

@ -132,21 +132,12 @@ test Elem {
/// Result is always comptime-known.
pub inline fn sentinel(comptime T: type) ?Elem(T) {
switch (@typeInfo(T)) {
.array => |info| {
const sentinel_ptr = info.sentinel orelse return null;
return @as(*const info.child, @ptrCast(sentinel_ptr)).*;
},
.array => |info| return info.sentinel(),
.pointer => |info| {
switch (info.size) {
.many, .slice => {
const sentinel_ptr = info.sentinel orelse return null;
return @as(*align(1) const info.child, @ptrCast(sentinel_ptr)).*;
},
.many, .slice => return info.sentinel(),
.one => switch (@typeInfo(info.child)) {
.array => |array_info| {
const sentinel_ptr = array_info.sentinel orelse return null;
return @as(*align(1) const array_info.child, @ptrCast(sentinel_ptr)).*;
},
.array => |array_info| return array_info.sentinel(),
else => {},
},
else => {},
@ -190,11 +181,11 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
.array = .{
.len = array_info.len,
.child = array_info.child,
.sentinel = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
.sentinel_ptr = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
},
}),
.is_allowzero = info.is_allowzero,
.sentinel = info.sentinel,
.sentinel_ptr = info.sentinel_ptr,
},
}),
else => {},
@ -208,7 +199,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
.address_space = info.address_space,
.child = info.child,
.is_allowzero = info.is_allowzero,
.sentinel = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
.sentinel_ptr = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
},
}),
else => {},
@ -226,7 +217,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
.address_space = ptr_info.address_space,
.child = ptr_info.child,
.is_allowzero = ptr_info.is_allowzero,
.sentinel = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
.sentinel_ptr = @as(?*const anyopaque, @ptrCast(&sentinel_val)),
},
}),
},
@ -1018,7 +1009,7 @@ fn CreateUniqueTuple(comptime N: comptime_int, comptime types: [N]type) type {
tuple_fields[i] = .{
.name = std.fmt.bufPrintZ(&num_buf, "{d}", .{i}) catch unreachable,
.type = T,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 0,
};

2
lib/std/meta/trailer_flags.zig
View File

@ -25,7 +25,7 @@ pub fn TrailerFlags(comptime Fields: type) type {
fields[i] = Type.StructField{
.name = struct_field.name,
.type = ?struct_field.type,
.default_value = &@as(?struct_field.type, null),
.default_value_ptr = &@as(?struct_field.type, null),
.is_comptime = false,
.alignment = @alignOf(?struct_field.type),
};

2
lib/std/multi_array_list.zig
View File

@ -571,7 +571,7 @@ pub fn MultiArrayList(comptime T: type) type {
for (&entry_fields, sizes.fields) |*entry_field, i| entry_field.* = .{
.name = fields[i].name ++ "_ptr",
.type = *fields[i].type,
.default_value = null,
.default_value_ptr = null,
.is_comptime = fields[i].is_comptime,
.alignment = fields[i].alignment,
};

7
lib/std/zig/c_translation.zig
View File

@ -180,10 +180,7 @@ pub fn sizeof(target: anytype) usize {
// specially handled here.
if (ptr.size == .one and ptr.is_const and @typeInfo(ptr.child) == .array) {
const array_info = @typeInfo(ptr.child).array;
if ((array_info.child == u8 or array_info.child == u16) and
array_info.sentinel != null and
@as(*align(1) const array_info.child, @ptrCast(array_info.sentinel.?)).* == 0)
{
if ((array_info.child == u8 or array_info.child == u16) and array_info.sentinel() == 0) {
// length of the string plus one for the null terminator.
return (array_info.len + 1) * @sizeOf(array_info.child);
}
@ -348,7 +345,7 @@ pub fn FlexibleArrayType(comptime SelfType: type, comptime ElementType: type) ty
.address_space = .generic,
.child = ElementType,
.is_allowzero = true,
.sentinel = null,
.sentinel_ptr = null,
} });
},
else => |info| @compileError("Invalid self type \"" ++ @tagName(info) ++ "\" for flexible array getter: " ++ @typeName(SelfType)),

6
src/InternPool.zig
View File

@ -1134,7 +1134,7 @@ const Local = struct {
for (&new_fields, elem_fields) |*new_field, elem_field| new_field.* = .{
.name = elem_field.name,
.type = *[len]elem_field.type,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 0,
};
@ -1162,9 +1162,9 @@ const Local = struct {
.address_space = .generic,
.child = elem_field.type,
.is_allowzero = false,
.sentinel = null,
.sentinel_ptr = null,
} }),
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 0,
};

5
src/Value.zig
View File

@ -4641,10 +4641,7 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe
@field(result, field.name) = if (struct_obj.nameIndex(ip, field_name_ip)) |field_idx| f: {
const field_val = try val.fieldValue(pt, field_idx);
break :f try field_val.interpret(field.type, pt);
} else if (field.default_value) |ptr| f: {
const typed_ptr: *const field.type = @ptrCast(@alignCast(ptr));
break :f typed_ptr.*;
} else return error.TypeMismatch;
} else (field.defaultValue() orelse return error.TypeMismatch);
}
return result;
},

4
src/codegen/llvm/Builder.zig
View File

@ -8463,7 +8463,7 @@ pub const Metadata = enum(u32) {
field.* = .{
.name = name,
.type = []const u8,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 0,
};
@ -8474,7 +8474,7 @@ pub const Metadata = enum(u32) {
field.* = .{
.name = name,
.type = std.fmt.Formatter(format),
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 0,
};

6
test/behavior/tuple.zig
View File

@ -141,14 +141,14 @@ test "array-like initializer for tuple types" {
.{
.name = "0",
.type = i32,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = @alignOf(i32),
},
.{
.name = "1",
.type = u8,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = @alignOf(u8),
},
@ -330,7 +330,7 @@ test "zero sized struct in tuple handled correctly" {
.fields = &.{.{
.name = "0",
.type = struct {},
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 0,
}},

4
test/behavior/tuple_declarations.zig
View File

@ -20,13 +20,13 @@ test "tuple declaration type info" {
try expectEqualStrings(info.fields[0].name, "0");
try expect(info.fields[0].type == u32);
try expect(@as(*const u32, @ptrCast(@alignCast(info.fields[0].default_value))).* == 1);
try expect(info.fields[0].defaultValue() == 1);
try expect(info.fields[0].is_comptime);
try expect(info.fields[0].alignment == @alignOf(u32));
try expectEqualStrings(info.fields[1].name, "1");
try expect(info.fields[1].type == []const u8);
try expect(info.fields[1].default_value == null);
try expect(info.fields[1].defaultValue() == null);
try expect(!info.fields[1].is_comptime);
try expect(info.fields[1].alignment == @alignOf([]const u8));
}

36
test/behavior/type.zig
View File

@ -118,21 +118,21 @@ test "Type.Array" {
.array = .{
.len = 123,
.child = u8,
.sentinel = null,
.sentinel_ptr = null,
},
}));
try testing.expect([2]u32 == @Type(.{
.array = .{
.len = 2,
.child = u32,
.sentinel = null,
.sentinel_ptr = null,
},
}));
try testing.expect([2:0]u32 == @Type(.{
.array = .{
.len = 2,
.child = u32,
.sentinel = &@as(u32, 0),
.sentinel_ptr = &@as(u32, 0),
},
}));
try testTypes(&[_]type{ [1]u8, [30]usize, [7]bool });
@ -148,7 +148,7 @@ test "@Type create slice with null sentinel" {
.alignment = 8,
.address_space = .generic,
.child = *i32,
.sentinel = null,
.sentinel_ptr = null,
},
});
try testing.expect(Slice == []align(8) const *i32);
@ -266,10 +266,10 @@ test "Type.Struct" {
try testing.expectEqual(Type.ContainerLayout.auto, infoA.layout);
try testing.expectEqualSlices(u8, "x", infoA.fields[0].name);
try testing.expectEqual(u8, infoA.fields[0].type);
try testing.expectEqual(@as(?*const anyopaque, null), infoA.fields[0].default_value);
try testing.expectEqual(@as(?*const anyopaque, null), infoA.fields[0].default_value_ptr);
try testing.expectEqualSlices(u8, "y", infoA.fields[1].name);
try testing.expectEqual(u32, infoA.fields[1].type);
try testing.expectEqual(@as(?*const anyopaque, null), infoA.fields[1].default_value);
try testing.expectEqual(@as(?*const anyopaque, null), infoA.fields[1].default_value_ptr);
try testing.expectEqualSlices(Type.Declaration, &.{}, infoA.decls);
try testing.expectEqual(@as(bool, false), infoA.is_tuple);
@ -284,10 +284,10 @@ test "Type.Struct" {
try testing.expectEqual(Type.ContainerLayout.@"extern", infoB.layout);
try testing.expectEqualSlices(u8, "x", infoB.fields[0].name);
try testing.expectEqual(u8, infoB.fields[0].type);
try testing.expectEqual(@as(?*const anyopaque, null), infoB.fields[0].default_value);
try testing.expectEqual(@as(?*const anyopaque, null), infoB.fields[0].default_value_ptr);
try testing.expectEqualSlices(u8, "y", infoB.fields[1].name);
try testing.expectEqual(u32, infoB.fields[1].type);
try testing.expectEqual(@as(u32, 5), @as(*align(1) const u32, @ptrCast(infoB.fields[1].default_value.?)).*);
try testing.expectEqual(@as(u32, 5), infoB.fields[1].defaultValue().?);
try testing.expectEqual(@as(usize, 0), infoB.decls.len);
try testing.expectEqual(@as(bool, false), infoB.is_tuple);
@ -296,10 +296,10 @@ test "Type.Struct" {
try testing.expectEqual(Type.ContainerLayout.@"packed", infoC.layout);
try testing.expectEqualSlices(u8, "x", infoC.fields[0].name);
try testing.expectEqual(u8, infoC.fields[0].type);
try testing.expectEqual(@as(u8, 3), @as(*const u8, @ptrCast(infoC.fields[0].default_value.?)).*);
try testing.expectEqual(@as(u8, 3), infoC.fields[0].defaultValue().?);
try testing.expectEqualSlices(u8, "y", infoC.fields[1].name);
try testing.expectEqual(u32, infoC.fields[1].type);
try testing.expectEqual(@as(u32, 5), @as(*align(1) const u32, @ptrCast(infoC.fields[1].default_value.?)).*);
try testing.expectEqual(@as(u32, 5), infoC.fields[1].defaultValue().?);
try testing.expectEqual(@as(usize, 0), infoC.decls.len);
try testing.expectEqual(@as(bool, false), infoC.is_tuple);
@ -309,10 +309,10 @@ test "Type.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), @as(*const comptime_int, @ptrCast(infoD.fields[0].default_value.?)).*);
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), @as(*const comptime_int, @ptrCast(infoD.fields[1].default_value.?)).*);
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);
@ -322,10 +322,10 @@ test "Type.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), @as(*const comptime_int, @ptrCast(infoE.fields[0].default_value.?)).*);
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), @as(*const comptime_int, @ptrCast(infoE.fields[1].default_value.?)).*);
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);
@ -582,7 +582,7 @@ test "reified struct field name from optional payload" {
.fields = &.{.{
.name = name,
.type = u8,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 1,
}},
@ -628,7 +628,7 @@ test "reified struct uses @alignOf" {
.{
.name = "globals",
.type = modules.mach.globals,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = @alignOf(modules.mach.globals),
},
@ -688,7 +688,7 @@ test "empty struct assigned to reified struct field" {
.fields = &.{.{
.name = "components",
.type = @TypeOf(modules.components),
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = @alignOf(@TypeOf(modules.components)),
}},
@ -738,7 +738,7 @@ test "struct field names sliced at comptime from larger string" {
.alignment = 0,
.name = name ++ "",
.type = usize,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
}};
}

32
test/behavior/type_info.zig
View File

@ -84,7 +84,7 @@ fn testPointer() !void {
try expect(u32_ptr_info.pointer.is_volatile == false);
try expect(u32_ptr_info.pointer.alignment == @alignOf(u32));
try expect(u32_ptr_info.pointer.child == u32);
try expect(u32_ptr_info.pointer.sentinel == null);
try expect(u32_ptr_info.pointer.sentinel() == null);
}
test "type info: unknown length pointer type info" {
@ -98,7 +98,7 @@ fn testUnknownLenPtr() !void {
try expect(u32_ptr_info.pointer.size == .many);
try expect(u32_ptr_info.pointer.is_const == true);
try expect(u32_ptr_info.pointer.is_volatile == true);
try expect(u32_ptr_info.pointer.sentinel == null);
try expect(u32_ptr_info.pointer.sentinel() == null);
try expect(u32_ptr_info.pointer.alignment == @alignOf(f64));
try expect(u32_ptr_info.pointer.child == f64);
}
@ -114,9 +114,9 @@ fn testNullTerminatedPtr() !void {
try expect(ptr_info.pointer.size == .many);
try expect(ptr_info.pointer.is_const == false);
try expect(ptr_info.pointer.is_volatile == false);
try expect(@as(*const u8, @ptrCast(ptr_info.pointer.sentinel.?)).* == 0);
try expect(ptr_info.pointer.sentinel().? == 0);
try expect(@typeInfo([:0]u8).pointer.sentinel != null);
try expect(@typeInfo([:0]u8).pointer.sentinel() != null);
}
test "type info: slice type info" {
@ -145,14 +145,14 @@ fn testArray() !void {
try expect(info == .array);
try expect(info.array.len == 42);
try expect(info.array.child == u8);
try expect(info.array.sentinel == null);
try expect(info.array.sentinel() == null);
}
{
const info = @typeInfo([10:0]u8);
try expect(info.array.len == 10);
try expect(info.array.child == u8);
try expect(@as(*const u8, @ptrCast(info.array.sentinel.?)).* == @as(u8, 0));
try expect(info.array.sentinel().? == @as(u8, 0));
try expect(@sizeOf([10:0]u8) == info.array.len + 1);
}
}
@ -292,8 +292,8 @@ fn testStruct() !void {
try expect(unpacked_struct_info.@"struct".is_tuple == false);
try expect(unpacked_struct_info.@"struct".backing_integer == null);
try expect(unpacked_struct_info.@"struct".fields[0].alignment == @alignOf(u32));
try expect(@as(*align(1) const u32, @ptrCast(unpacked_struct_info.@"struct".fields[0].default_value.?)).* == 4);
try expect(mem.eql(u8, "foobar", @as(*align(1) const *const [6:0]u8, @ptrCast(unpacked_struct_info.@"struct".fields[1].default_value.?)).*));
try expect(unpacked_struct_info.@"struct".fields[0].defaultValue().? == 4);
try expect(mem.eql(u8, "foobar", unpacked_struct_info.@"struct".fields[1].defaultValue().?));
}
const TestStruct = struct {
@ -315,8 +315,8 @@ fn testPackedStruct() !void {
try expect(struct_info.@"struct".fields.len == 4);
try expect(struct_info.@"struct".fields[0].alignment == 0);
try expect(struct_info.@"struct".fields[2].type == f32);
try expect(struct_info.@"struct".fields[2].default_value == null);
try expect(@as(*align(1) const u32, @ptrCast(struct_info.@"struct".fields[3].default_value.?)).* == 4);
try expect(struct_info.@"struct".fields[2].defaultValue() == null);
try expect(struct_info.@"struct".fields[3].defaultValue().? == 4);
try expect(struct_info.@"struct".fields[3].alignment == 0);
try expect(struct_info.@"struct".decls.len == 1);
}
@ -380,7 +380,7 @@ fn testFunction() !void {
try expect(foo_ptr_fn_info.pointer.address_space == .generic);
try expect(foo_ptr_fn_info.pointer.child == foo_fn_type);
try expect(!foo_ptr_fn_info.pointer.is_allowzero);
try expect(foo_ptr_fn_info.pointer.sentinel == null);
try expect(foo_ptr_fn_info.pointer.sentinel() == null);
// Avoid looking at `typeInfoFooAligned` on targets which don't support function alignment.
switch (builtin.target.cpu.arch) {
@ -408,7 +408,7 @@ fn testFunction() !void {
try expect(aligned_foo_ptr_fn_info.pointer.address_space == .generic);
try expect(aligned_foo_ptr_fn_info.pointer.child == aligned_foo_fn_type);
try expect(!aligned_foo_ptr_fn_info.pointer.is_allowzero);
try expect(aligned_foo_ptr_fn_info.pointer.sentinel == null);
try expect(aligned_foo_ptr_fn_info.pointer.sentinel() == null);
}
extern fn typeInfoFoo(a: usize, b: bool, ...) callconv(.c) usize;
@ -517,7 +517,7 @@ test "type info: TypeId -> Type impl cast" {
test "sentinel of opaque pointer type" {
const c_void_info = @typeInfo(*anyopaque);
try expect(c_void_info.pointer.sentinel == null);
try expect(c_void_info.pointer.sentinel_ptr == null);
}
test "@typeInfo does not force declarations into existence" {
@ -601,9 +601,9 @@ test "typeInfo resolves usingnamespace declarations" {
try expectEqualStrings(decls[1].name, "f1");
}
test "value from struct @typeInfo default_value can be loaded at comptime" {
test "value from struct @typeInfo default_value_ptr can be loaded at comptime" {
comptime {
const a = @typeInfo(@TypeOf(.{ .foo = @as(u8, 1) })).@"struct".fields[0].default_value;
const a = @typeInfo(@TypeOf(.{ .foo = @as(u8, 1) })).@"struct".fields[0].default_value_ptr;
try expect(@as(*const u8, @ptrCast(a)).* == 1);
}
}
@ -646,7 +646,7 @@ test "@typeInfo decls ignore dependency loops" {
test "type info of tuple of string literal default value" {
const struct_field = @typeInfo(@TypeOf(.{"hi"})).@"struct".fields[0];
const value = @as(*align(1) const *const [2:0]u8, @ptrCast(struct_field.default_value.?)).*;
const value = struct_field.defaultValue().?;
comptime std.debug.assert(value[0] == 'h');
}

2
test/cases/compile_errors/invalid_pointer_with_reify_type.zig
View File

@ -7,7 +7,7 @@ export fn entry() void {
.address_space = .generic,
.child = u8,
.is_allowzero = false,
.sentinel = &@as(u8, 0),
.sentinel_ptr = &@as(u8, 0),
} });
}

6
test/cases/compile_errors/non_scalar_sentinel.zig
View File

@ -12,7 +12,7 @@ comptime {
}
comptime {
_ = @Type(.{ .array = .{ .child = S, .len = 0, .sentinel = &sentinel } });
_ = @Type(.{ .array = .{ .child = S, .len = 0, .sentinel_ptr = &sentinel } });
}
comptime {
_ = @Type(.{ .pointer = .{
@ -23,7 +23,7 @@ comptime {
.address_space = .generic,
.child = S,
.is_allowzero = false,
.sentinel = &sentinel,
.sentinel_ptr = &sentinel,
} });
}
comptime {
@ -35,7 +35,7 @@ comptime {
.address_space = .generic,
.child = S,
.is_allowzero = false,
.sentinel = &sentinel,
.sentinel_ptr = &sentinel,
} });
}

4
test/cases/compile_errors/packed_struct_field_alignment_unavailable_for_reify_type.zig
View File

@ -1,11 +1,9 @@
export fn entry() void {
_ = @Type(.{ .@"struct" = .{ .layout = .@"packed", .fields = &.{
.{ .name = "one", .type = u4, .default_value = null, .is_comptime = false, .alignment = 2 },
.{ .name = "one", .type = u4, .default_value_ptr = null, .is_comptime = false, .alignment = 2 },
}, .decls = &.{}, .is_tuple = false } });
}
// error
// backend=stage2
// target=native
//
// :2:9: error: alignment in a packed struct field must be set to 0

12
test/cases/compile_errors/reify_struct.zig
View File

@ -4,7 +4,7 @@ comptime {
.fields = &.{.{
.name = "foo",
.type = u32,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 4,
}},
@ -18,7 +18,7 @@ comptime {
.fields = &.{.{
.name = "3",
.type = u32,
.default_value = null,
.default_value_ptr = null,
.is_comptime = false,
.alignment = 4,
}},
@ -32,7 +32,7 @@ comptime {
.fields = &.{.{
.name = "0",
.type = u32,
.default_value = null,
.default_value_ptr = null,
.is_comptime = true,
.alignment = 4,
}},
@ -46,7 +46,7 @@ comptime {
.fields = &.{.{
.name = "0",
.type = u32,
.default_value = null,
.default_value_ptr = null,
.is_comptime = true,
.alignment = 4,
}},
@ -60,7 +60,7 @@ comptime {
.fields = &.{.{
.name = "0",
.type = u32,
.default_value = null,
.default_value_ptr = null,
.is_comptime = true,
.alignment = 4,
}},
@ -70,8 +70,6 @@ comptime {
}
// error
// backend=stage2
// target=native
//
// :2:5: error: tuple cannot have non-numeric field 'foo'
// :16:5: error: tuple field name '3' does not match field index 0

4
test/cases/compile_errors/reify_type_with_invalid_field_alignment.zig
View File

@ -17,7 +17,7 @@ comptime {
.fields = &.{.{
.name = "0",
.type = u32,
.default_value = null,
.default_value_ptr = null,
.is_comptime = true,
.alignment = 5,
}},
@ -36,7 +36,7 @@ comptime {
.address_space = .generic,
.child = u8,
.is_allowzero = false,
.sentinel = null,
.sentinel_ptr = null,
},
});
}

2
test/cases/compile_errors/reify_type_with_undefined.zig
View File

@ -1,5 +1,5 @@
comptime {
_ = @Type(.{ .array = .{ .len = 0, .child = u8, .sentinel = undefined } });
_ = @Type(.{ .array = .{ .len = 0, .child = u8, .sentinel_ptr = undefined } });
}
comptime {
_ = @Type(.{