commit
d073836894
|
@ -317,7 +317,6 @@ pub const TypeInfo = union(enum) {
|
|||
/// therefore must be kept in sync with the compiler implementation.
|
||||
pub const UnionField = struct {
|
||||
name: []const u8,
|
||||
enum_field: ?EnumField,
|
||||
field_type: type,
|
||||
};
|
||||
|
||||
|
|
|
@ -399,7 +399,7 @@ pub fn formatType(
|
|||
try writer.writeAll(@tagName(@as(UnionTagType, value)));
|
||||
try writer.writeAll(" = ");
|
||||
inline for (info.fields) |u_field| {
|
||||
if (@enumToInt(@as(UnionTagType, value)) == u_field.enum_field.?.value) {
|
||||
if (value == @field(UnionTagType, u_field.name)) {
|
||||
try formatType(@field(value, u_field.name), fmt, options, writer, max_depth - 1);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -139,9 +139,8 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void {
|
|||
const tag = meta.activeTag(key);
|
||||
const s = hash(hasher, tag, strat);
|
||||
inline for (info.fields) |field| {
|
||||
const enum_field = field.enum_field.?;
|
||||
if (enum_field.value == @enumToInt(tag)) {
|
||||
hash(hasher, @field(key, enum_field.name), strat);
|
||||
if (@field(tag_type, field.name) == tag) {
|
||||
hash(hasher, @field(key, field.name), strat);
|
||||
// TODO use a labelled break when it does not crash the compiler. cf #2908
|
||||
// break :blk;
|
||||
return;
|
||||
|
|
|
@ -156,7 +156,7 @@ pub fn Deserializer(comptime endian: builtin.Endian, comptime packing: Packing,
|
|||
const tag = try self.deserializeInt(TagInt);
|
||||
|
||||
inline for (info.fields) |field_info| {
|
||||
if (field_info.enum_field.?.value == tag) {
|
||||
if (@enumToInt(@field(TagType, field_info.name)) == tag) {
|
||||
const name = field_info.name;
|
||||
const FieldType = field_info.field_type;
|
||||
ptr.* = @unionInit(C, name, undefined);
|
||||
|
@ -320,7 +320,7 @@ pub fn Serializer(comptime endian: builtin.Endian, comptime packing: Packing, co
|
|||
// value, but @field requires a comptime value. Our alternative
|
||||
// is to check each field for a match
|
||||
inline for (info.fields) |field_info| {
|
||||
if (field_info.enum_field.?.value == @enumToInt(active_tag)) {
|
||||
if (@field(TagType, field_info.name) == active_tag) {
|
||||
const name = field_info.name;
|
||||
const FieldType = field_info.field_type;
|
||||
try self.serialize(@field(value, name));
|
||||
|
|
|
@ -1613,7 +1613,7 @@ pub fn parseFree(comptime T: type, value: T, options: ParseOptions) void {
|
|||
.Union => |unionInfo| {
|
||||
if (unionInfo.tag_type) |UnionTagType| {
|
||||
inline for (unionInfo.fields) |u_field| {
|
||||
if (@enumToInt(@as(UnionTagType, value)) == u_field.enum_field.?.value) {
|
||||
if (value == @field(UnionTagType, u_field.name)) {
|
||||
parseFree(u_field.field_type, @field(value, u_field.name), options);
|
||||
break;
|
||||
}
|
||||
|
@ -2458,7 +2458,7 @@ pub fn stringify(
|
|||
const info = @typeInfo(T).Union;
|
||||
if (info.tag_type) |UnionTagType| {
|
||||
inline for (info.fields) |u_field| {
|
||||
if (@enumToInt(@as(UnionTagType, value)) == u_field.enum_field.?.value) {
|
||||
if (value == @field(UnionTagType, u_field.name)) {
|
||||
return try stringify(@field(value, u_field.name), options, out_stream);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -465,10 +465,13 @@ pub fn TagPayloadType(comptime U: type, tag: @TagType(U)) type {
|
|||
testing.expect(trait.is(.Union)(U));
|
||||
|
||||
const info = @typeInfo(U).Union;
|
||||
const tag_info = @typeInfo(@TagType(U)).Enum;
|
||||
|
||||
inline for (info.fields) |field_info| {
|
||||
if (field_info.enum_field.?.value == @enumToInt(tag)) return field_info.field_type;
|
||||
if (comptime mem.eql(u8, field_info.name, @tagName(tag)))
|
||||
return field_info.field_type;
|
||||
}
|
||||
|
||||
unreachable;
|
||||
}
|
||||
|
||||
|
@ -504,15 +507,14 @@ pub fn eql(a: anytype, b: @TypeOf(a)) bool {
|
|||
}
|
||||
},
|
||||
.Union => |info| {
|
||||
if (info.tag_type) |_| {
|
||||
if (info.tag_type) |Tag| {
|
||||
const tag_a = activeTag(a);
|
||||
const tag_b = activeTag(b);
|
||||
if (tag_a != tag_b) return false;
|
||||
|
||||
inline for (info.fields) |field_info| {
|
||||
const enum_field = field_info.enum_field.?;
|
||||
if (enum_field.value == @enumToInt(tag_a)) {
|
||||
return eql(@field(a, enum_field.name), @field(b, enum_field.name));
|
||||
if (@field(Tag, field_info.name) == tag_a) {
|
||||
return eql(@field(a, field_info.name), @field(b, field_info.name));
|
||||
}
|
||||
}
|
||||
return false;
|
||||
|
|
271
src/analyze.cpp
271
src/analyze.cpp
|
@ -2373,7 +2373,10 @@ static Error resolve_union_alignment(CodeGen *g, ZigType *union_type) {
|
|||
if (field->gen_index == UINT32_MAX)
|
||||
continue;
|
||||
|
||||
AstNode *align_expr = field->decl_node->data.struct_field.align_expr;
|
||||
AstNode *align_expr = nullptr;
|
||||
if (union_type->data.unionation.decl_node->type == NodeTypeContainerDecl) {
|
||||
align_expr = field->decl_node->data.struct_field.align_expr;
|
||||
}
|
||||
if (align_expr != nullptr) {
|
||||
if (!analyze_const_align(g, &union_type->data.unionation.decls_scope->base, align_expr,
|
||||
&field->align))
|
||||
|
@ -2469,9 +2472,6 @@ static Error resolve_union_type(CodeGen *g, ZigType *union_type) {
|
|||
|
||||
AstNode *decl_node = union_type->data.unionation.decl_node;
|
||||
|
||||
|
||||
assert(decl_node->type == NodeTypeContainerDecl);
|
||||
|
||||
uint32_t field_count = union_type->data.unionation.src_field_count;
|
||||
TypeUnionField *most_aligned_union_member = union_type->data.unionation.most_aligned_union_member;
|
||||
|
||||
|
@ -2604,16 +2604,16 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
|
|||
if (decl_node->type == NodeTypeContainerDecl) {
|
||||
assert(!enum_type->data.enumeration.fields);
|
||||
field_count = (uint32_t)decl_node->data.container_decl.fields.length;
|
||||
if (field_count == 0) {
|
||||
add_node_error(g, decl_node, buf_sprintf("enums must have 1 or more fields"));
|
||||
|
||||
enum_type->data.enumeration.src_field_count = field_count;
|
||||
enum_type->data.enumeration.fields = nullptr;
|
||||
enum_type->data.enumeration.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
} else {
|
||||
field_count = enum_type->data.enumeration.src_field_count;
|
||||
field_count = enum_type->data.enumeration.src_field_count + enum_type->data.enumeration.non_exhaustive;
|
||||
}
|
||||
|
||||
if (field_count == 0) {
|
||||
add_node_error(g, decl_node, buf_sprintf("enums must have 1 or more fields"));
|
||||
enum_type->data.enumeration.src_field_count = field_count;
|
||||
enum_type->data.enumeration.fields = nullptr;
|
||||
enum_type->data.enumeration.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
|
||||
Scope *scope = &enum_type->data.enumeration.decls_scope->base;
|
||||
|
@ -3056,7 +3056,6 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
return ErrorNone;
|
||||
|
||||
AstNode *decl_node = union_type->data.unionation.decl_node;
|
||||
assert(decl_node->type == NodeTypeContainerDecl);
|
||||
|
||||
if (union_type->data.unionation.resolve_loop_flag_zero_bits) {
|
||||
if (union_type->data.unionation.resolve_status != ResolveStatusInvalid) {
|
||||
|
@ -3070,30 +3069,51 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
|
||||
union_type->data.unionation.resolve_loop_flag_zero_bits = true;
|
||||
|
||||
assert(union_type->data.unionation.fields == nullptr);
|
||||
uint32_t field_count = (uint32_t)decl_node->data.container_decl.fields.length;
|
||||
uint32_t field_count;
|
||||
if (decl_node->type == NodeTypeContainerDecl) {
|
||||
assert(union_type->data.unionation.fields == nullptr);
|
||||
field_count = (uint32_t)decl_node->data.container_decl.fields.length;
|
||||
union_type->data.unionation.src_field_count = field_count;
|
||||
union_type->data.unionation.fields = heap::c_allocator.allocate<TypeUnionField>(field_count);
|
||||
union_type->data.unionation.fields_by_name.init(field_count);
|
||||
} else {
|
||||
field_count = union_type->data.unionation.src_field_count;
|
||||
assert(field_count == 0 || union_type->data.unionation.fields != nullptr);
|
||||
}
|
||||
|
||||
if (field_count == 0) {
|
||||
add_node_error(g, decl_node, buf_sprintf("unions must have 1 or more fields"));
|
||||
union_type->data.unionation.src_field_count = field_count;
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
union_type->data.unionation.src_field_count = field_count;
|
||||
union_type->data.unionation.fields = heap::c_allocator.allocate<TypeUnionField>(field_count);
|
||||
union_type->data.unionation.fields_by_name.init(field_count);
|
||||
|
||||
Scope *scope = &union_type->data.unionation.decls_scope->base;
|
||||
|
||||
HashMap<BigInt, AstNode *, bigint_hash, bigint_eql> occupied_tag_values = {};
|
||||
|
||||
AstNode *enum_type_node = decl_node->data.container_decl.init_arg_expr;
|
||||
union_type->data.unionation.have_explicit_tag_type = decl_node->data.container_decl.auto_enum ||
|
||||
enum_type_node != nullptr;
|
||||
bool auto_layout = (union_type->data.unionation.layout == ContainerLayoutAuto);
|
||||
bool want_safety = (field_count >= 2) && (auto_layout || enum_type_node != nullptr) && !(g->build_mode == BuildModeFastRelease || g->build_mode == BuildModeSmallRelease);
|
||||
bool is_auto_enum; // union(enum) or union(enum(expr))
|
||||
bool is_explicit_enum; // union(expr)
|
||||
AstNode *enum_type_node; // expr in union(enum(expr)) or union(expr)
|
||||
if (decl_node->type == NodeTypeContainerDecl) {
|
||||
is_auto_enum = decl_node->data.container_decl.auto_enum;
|
||||
is_explicit_enum = decl_node->data.container_decl.init_arg_expr != nullptr;
|
||||
enum_type_node = decl_node->data.container_decl.init_arg_expr;
|
||||
} else {
|
||||
is_auto_enum = false;
|
||||
is_explicit_enum = union_type->data.unionation.tag_type != nullptr;
|
||||
enum_type_node = nullptr;
|
||||
}
|
||||
union_type->data.unionation.have_explicit_tag_type = is_auto_enum || is_explicit_enum;
|
||||
|
||||
bool is_auto_layout = union_type->data.unionation.layout == ContainerLayoutAuto;
|
||||
bool want_safety = (field_count >= 2)
|
||||
&& (is_auto_layout || is_explicit_enum)
|
||||
&& !(g->build_mode == BuildModeFastRelease || g->build_mode == BuildModeSmallRelease);
|
||||
ZigType *tag_type;
|
||||
bool create_enum_type = decl_node->data.container_decl.auto_enum || (enum_type_node == nullptr && want_safety);
|
||||
bool create_enum_type = is_auto_enum || (!is_explicit_enum && want_safety);
|
||||
bool *covered_enum_fields;
|
||||
bool *is_zero_bits = heap::c_allocator.allocate<bool>(field_count);
|
||||
ZigLLVMDIEnumerator **di_enumerators;
|
||||
if (create_enum_type) {
|
||||
occupied_tag_values.init(field_count);
|
||||
|
@ -3151,71 +3171,81 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
return err;
|
||||
}
|
||||
tag_type = enum_type;
|
||||
covered_enum_fields = heap::c_allocator.allocate<bool>(enum_type->data.enumeration.src_field_count);
|
||||
} else {
|
||||
tag_type = nullptr;
|
||||
if (decl_node->type == NodeTypeContainerDecl) {
|
||||
tag_type = nullptr;
|
||||
} else {
|
||||
tag_type = union_type->data.unionation.tag_type;
|
||||
}
|
||||
}
|
||||
if (tag_type != nullptr) {
|
||||
covered_enum_fields = heap::c_allocator.allocate<bool>(tag_type->data.enumeration.src_field_count);
|
||||
}
|
||||
union_type->data.unionation.tag_type = tag_type;
|
||||
|
||||
uint32_t gen_field_index = 0;
|
||||
for (uint32_t i = 0; i < field_count; i += 1) {
|
||||
AstNode *field_node = decl_node->data.container_decl.fields.at(i);
|
||||
Buf *field_name = field_node->data.struct_field.name;
|
||||
TypeUnionField *union_field = &union_type->data.unionation.fields[i];
|
||||
union_field->name = field_node->data.struct_field.name;
|
||||
union_field->decl_node = field_node;
|
||||
union_field->gen_index = UINT32_MAX;
|
||||
if (decl_node->type == NodeTypeContainerDecl) {
|
||||
AstNode *field_node = decl_node->data.container_decl.fields.at(i);
|
||||
union_field->name = field_node->data.struct_field.name;
|
||||
union_field->decl_node = field_node;
|
||||
union_field->gen_index = UINT32_MAX;
|
||||
is_zero_bits[i] = false;
|
||||
|
||||
auto field_entry = union_type->data.unionation.fields_by_name.put_unique(union_field->name, union_field);
|
||||
if (field_entry != nullptr) {
|
||||
ErrorMsg *msg = add_node_error(g, field_node,
|
||||
buf_sprintf("duplicate union field: '%s'", buf_ptr(union_field->name)));
|
||||
add_error_note(g, msg, field_entry->value->decl_node, buf_sprintf("other field here"));
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
auto field_entry = union_type->data.unionation.fields_by_name.put_unique(union_field->name, union_field);
|
||||
if (field_entry != nullptr) {
|
||||
ErrorMsg *msg = add_node_error(g, union_field->decl_node,
|
||||
buf_sprintf("duplicate union field: '%s'", buf_ptr(union_field->name)));
|
||||
add_error_note(g, msg, field_entry->value->decl_node, buf_sprintf("other field here"));
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
|
||||
if (field_node->data.struct_field.type == nullptr) {
|
||||
if (is_auto_enum || is_explicit_enum) {
|
||||
union_field->type_entry = g->builtin_types.entry_void;
|
||||
is_zero_bits[i] = true;
|
||||
} else {
|
||||
add_node_error(g, field_node, buf_sprintf("union field missing type"));
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
} else {
|
||||
ZigValue *field_type_val = analyze_const_value(g, scope,
|
||||
field_node->data.struct_field.type, g->builtin_types.entry_type, nullptr, LazyOkNoUndef);
|
||||
if (type_is_invalid(field_type_val->type)) {
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
assert(field_type_val->special != ConstValSpecialRuntime);
|
||||
union_field->type_val = field_type_val;
|
||||
}
|
||||
|
||||
if (field_node->data.struct_field.value != nullptr && !is_auto_enum) {
|
||||
ErrorMsg *msg = add_node_error(g, field_node->data.struct_field.value,
|
||||
buf_create_from_str("untagged union field assignment"));
|
||||
add_error_note(g, msg, decl_node, buf_create_from_str("consider 'union(enum)' here"));
|
||||
}
|
||||
}
|
||||
|
||||
bool field_is_zero_bits;
|
||||
if (field_node->data.struct_field.type == nullptr) {
|
||||
if (decl_node->data.container_decl.auto_enum ||
|
||||
decl_node->data.container_decl.init_arg_expr != nullptr)
|
||||
{
|
||||
union_field->type_entry = g->builtin_types.entry_void;
|
||||
field_is_zero_bits = true;
|
||||
} else {
|
||||
add_node_error(g, field_node, buf_sprintf("union field missing type"));
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
} else {
|
||||
ZigValue *field_type_val = analyze_const_value(g, scope,
|
||||
field_node->data.struct_field.type, g->builtin_types.entry_type, nullptr, LazyOkNoUndef);
|
||||
if (type_is_invalid(field_type_val->type)) {
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
assert(field_type_val->special != ConstValSpecialRuntime);
|
||||
union_field->type_val = field_type_val;
|
||||
if (union_type->data.unionation.resolve_status == ResolveStatusInvalid)
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
|
||||
if (union_field->type_val != nullptr) {
|
||||
bool field_is_opaque_type;
|
||||
if ((err = type_val_resolve_is_opaque_type(g, field_type_val, &field_is_opaque_type))) {
|
||||
if ((err = type_val_resolve_is_opaque_type(g, union_field->type_val, &field_is_opaque_type))) {
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
if (field_is_opaque_type) {
|
||||
add_node_error(g, field_node,
|
||||
add_node_error(g, union_field->decl_node,
|
||||
buf_create_from_str(
|
||||
"opaque types have unknown size and therefore cannot be directly embedded in unions"));
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
|
||||
switch (type_val_resolve_requires_comptime(g, field_type_val)) {
|
||||
switch (type_val_resolve_requires_comptime(g, union_field->type_val)) {
|
||||
case ReqCompTimeInvalid:
|
||||
if (g->trace_err != nullptr) {
|
||||
g->trace_err = add_error_note(g, g->trace_err, field_node,
|
||||
g->trace_err = add_error_note(g, g->trace_err, union_field->decl_node,
|
||||
buf_create_from_str("while checking this field"));
|
||||
}
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
|
@ -3227,29 +3257,25 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
break;
|
||||
}
|
||||
|
||||
if ((err = type_val_resolve_zero_bits(g, field_type_val, union_type, nullptr, &field_is_zero_bits))) {
|
||||
if ((err = type_val_resolve_zero_bits(g, union_field->type_val, union_type, nullptr, &is_zero_bits[i]))) {
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
}
|
||||
|
||||
if (field_node->data.struct_field.value != nullptr && !decl_node->data.container_decl.auto_enum) {
|
||||
ErrorMsg *msg = add_node_error(g, field_node->data.struct_field.value,
|
||||
buf_create_from_str("untagged union field assignment"));
|
||||
add_error_note(g, msg, decl_node, buf_create_from_str("consider 'union(enum)' here"));
|
||||
}
|
||||
|
||||
if (create_enum_type) {
|
||||
di_enumerators[i] = ZigLLVMCreateDebugEnumerator(g->dbuilder, buf_ptr(field_name), i);
|
||||
di_enumerators[i] = ZigLLVMCreateDebugEnumerator(g->dbuilder, buf_ptr(union_field->name), i);
|
||||
union_field->enum_field = &tag_type->data.enumeration.fields[i];
|
||||
union_field->enum_field->name = field_name;
|
||||
union_field->enum_field->name = union_field->name;
|
||||
union_field->enum_field->decl_index = i;
|
||||
union_field->enum_field->decl_node = field_node;
|
||||
union_field->enum_field->decl_node = union_field->decl_node;
|
||||
|
||||
auto prev_entry = tag_type->data.enumeration.fields_by_name.put_unique(union_field->enum_field->name, union_field->enum_field);
|
||||
assert(prev_entry == nullptr); // caught by union de-duplicator above
|
||||
|
||||
AstNode *tag_value = field_node->data.struct_field.value;
|
||||
AstNode *tag_value = decl_node->type == NodeTypeContainerDecl
|
||||
? union_field->decl_node->data.struct_field.value : nullptr;
|
||||
|
||||
// In this first pass we resolve explicit tag values.
|
||||
// In a second pass we will fill in the unspecified ones.
|
||||
if (tag_value != nullptr) {
|
||||
|
@ -3277,11 +3303,11 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
return ErrorSemanticAnalyzeFail;
|
||||
}
|
||||
}
|
||||
} else if (enum_type_node != nullptr) {
|
||||
union_field->enum_field = find_enum_type_field(tag_type, field_name);
|
||||
} else if (tag_type != nullptr) {
|
||||
union_field->enum_field = find_enum_type_field(tag_type, union_field->name);
|
||||
if (union_field->enum_field == nullptr) {
|
||||
ErrorMsg *msg = add_node_error(g, field_node,
|
||||
buf_sprintf("enum field not found: '%s'", buf_ptr(field_name)));
|
||||
ErrorMsg *msg = add_node_error(g, union_field->decl_node,
|
||||
buf_sprintf("enum field not found: '%s'", buf_ptr(union_field->name)));
|
||||
add_error_note(g, msg, tag_type->data.enumeration.decl_node,
|
||||
buf_sprintf("enum declared here"));
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
|
@ -3290,21 +3316,23 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
covered_enum_fields[union_field->enum_field->decl_index] = true;
|
||||
} else {
|
||||
union_field->enum_field = heap::c_allocator.create<TypeEnumField>();
|
||||
union_field->enum_field->name = field_name;
|
||||
union_field->enum_field->name = union_field->name;
|
||||
union_field->enum_field->decl_index = i;
|
||||
bigint_init_unsigned(&union_field->enum_field->value, i);
|
||||
}
|
||||
assert(union_field->enum_field != nullptr);
|
||||
|
||||
if (field_is_zero_bits)
|
||||
continue;
|
||||
|
||||
union_field->gen_index = gen_field_index;
|
||||
gen_field_index += 1;
|
||||
}
|
||||
|
||||
bool src_have_tag = decl_node->data.container_decl.auto_enum ||
|
||||
decl_node->data.container_decl.init_arg_expr != nullptr;
|
||||
uint32_t gen_field_index = 0;
|
||||
for (uint32_t i = 0; i < field_count; i += 1) {
|
||||
TypeUnionField *union_field = &union_type->data.unionation.fields[i];
|
||||
if (!is_zero_bits[i]) {
|
||||
union_field->gen_index = gen_field_index;
|
||||
gen_field_index += 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool src_have_tag = is_auto_enum || is_explicit_enum;
|
||||
|
||||
if (src_have_tag && union_type->data.unionation.layout != ContainerLayoutAuto) {
|
||||
const char *qual_str;
|
||||
|
@ -3318,8 +3346,7 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
qual_str = "extern";
|
||||
break;
|
||||
}
|
||||
AstNode *source_node = (decl_node->data.container_decl.init_arg_expr != nullptr) ?
|
||||
decl_node->data.container_decl.init_arg_expr : decl_node;
|
||||
AstNode *source_node = enum_type_node != nullptr ? enum_type_node : decl_node;
|
||||
add_node_error(g, source_node,
|
||||
buf_sprintf("%s union does not support enum tag type", qual_str));
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
|
@ -3327,43 +3354,47 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
|
|||
}
|
||||
|
||||
if (create_enum_type) {
|
||||
// Now iterate again and populate the unspecified tag values
|
||||
uint32_t next_maybe_unoccupied_index = 0;
|
||||
if (decl_node->type == NodeTypeContainerDecl) {
|
||||
// Now iterate again and populate the unspecified tag values
|
||||
uint32_t next_maybe_unoccupied_index = 0;
|
||||
|
||||
for (uint32_t field_i = 0; field_i < field_count; field_i += 1) {
|
||||
AstNode *field_node = decl_node->data.container_decl.fields.at(field_i);
|
||||
TypeUnionField *union_field = &union_type->data.unionation.fields[field_i];
|
||||
AstNode *tag_value = field_node->data.struct_field.value;
|
||||
for (uint32_t field_i = 0; field_i < field_count; field_i += 1) {
|
||||
AstNode *field_node = decl_node->data.container_decl.fields.at(field_i);
|
||||
TypeUnionField *union_field = &union_type->data.unionation.fields[field_i];
|
||||
AstNode *tag_value = field_node->data.struct_field.value;
|
||||
|
||||
if (tag_value == nullptr) {
|
||||
if (occupied_tag_values.size() == 0) {
|
||||
bigint_init_unsigned(&union_field->enum_field->value, next_maybe_unoccupied_index);
|
||||
next_maybe_unoccupied_index += 1;
|
||||
} else {
|
||||
BigInt proposed_value;
|
||||
for (;;) {
|
||||
bigint_init_unsigned(&proposed_value, next_maybe_unoccupied_index);
|
||||
if (tag_value == nullptr) {
|
||||
if (occupied_tag_values.size() == 0) {
|
||||
bigint_init_unsigned(&union_field->enum_field->value, next_maybe_unoccupied_index);
|
||||
next_maybe_unoccupied_index += 1;
|
||||
auto entry = occupied_tag_values.put_unique(proposed_value, field_node);
|
||||
if (entry != nullptr) {
|
||||
continue;
|
||||
} else {
|
||||
BigInt proposed_value;
|
||||
for (;;) {
|
||||
bigint_init_unsigned(&proposed_value, next_maybe_unoccupied_index);
|
||||
next_maybe_unoccupied_index += 1;
|
||||
auto entry = occupied_tag_values.put_unique(proposed_value, field_node);
|
||||
if (entry != nullptr) {
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
bigint_init_bigint(&union_field->enum_field->value, &proposed_value);
|
||||
}
|
||||
bigint_init_bigint(&union_field->enum_field->value, &proposed_value);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (enum_type_node != nullptr) {
|
||||
} else if (tag_type != nullptr) {
|
||||
for (uint32_t i = 0; i < tag_type->data.enumeration.src_field_count; i += 1) {
|
||||
TypeEnumField *enum_field = &tag_type->data.enumeration.fields[i];
|
||||
if (!covered_enum_fields[i]) {
|
||||
AstNode *enum_decl_node = tag_type->data.enumeration.decl_node;
|
||||
AstNode *field_node = enum_decl_node->data.container_decl.fields.at(i);
|
||||
ErrorMsg *msg = add_node_error(g, decl_node,
|
||||
buf_sprintf("enum field missing: '%s'", buf_ptr(enum_field->name)));
|
||||
add_error_note(g, msg, field_node,
|
||||
buf_sprintf("declared here"));
|
||||
if (decl_node->type == NodeTypeContainerDecl) {
|
||||
AstNode *enum_decl_node = tag_type->data.enumeration.decl_node;
|
||||
AstNode *field_node = enum_decl_node->data.container_decl.fields.at(i);
|
||||
add_error_note(g, msg, field_node,
|
||||
buf_sprintf("declared here"));
|
||||
}
|
||||
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
|
||||
}
|
||||
}
|
||||
|
@ -8351,7 +8382,7 @@ static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveS
|
|||
ZigLLVMDIFile *di_file;
|
||||
ZigLLVMDIScope *di_scope;
|
||||
unsigned line;
|
||||
if (decl_node != nullptr && !struct_type->data.structure.created_by_at_type) {
|
||||
if (decl_node != nullptr) {
|
||||
Scope *scope = &struct_type->data.structure.decls_scope->base;
|
||||
ZigType *import = get_scope_import(scope);
|
||||
di_file = import->data.structure.root_struct->di_file;
|
||||
|
@ -8714,7 +8745,7 @@ static void resolve_llvm_types_union(CodeGen *g, ZigType *union_type, ResolveSta
|
|||
|
||||
uint64_t store_size_in_bits = union_field->type_entry->size_in_bits;
|
||||
uint64_t abi_align_in_bits = 8*union_field->type_entry->abi_align;
|
||||
AstNode *field_node = decl_node->data.container_decl.fields.at(i);
|
||||
AstNode *field_node = union_field->decl_node;
|
||||
union_inner_di_types[union_field->gen_index] = ZigLLVMCreateDebugMemberType(g->dbuilder,
|
||||
ZigLLVMTypeToScope(union_type->llvm_di_type), buf_ptr(union_field->enum_field->name),
|
||||
import->data.structure.root_struct->di_file, (unsigned)(field_node->line + 1),
|
||||
|
|
107
src/ir.cpp
107
src/ir.cpp
|
@ -25424,8 +25424,6 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
|
|||
|
||||
init_const_slice(ira->codegen, fields[2], union_field_array, 0, union_field_count, false);
|
||||
|
||||
ZigType *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField", nullptr);
|
||||
|
||||
for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++) {
|
||||
TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
|
||||
ZigValue *union_field_val = &union_field_array->data.x_array.data.s_none.elements[union_field_index];
|
||||
|
@ -25433,20 +25431,10 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInst* source_instr, ZigTy
|
|||
union_field_val->special = ConstValSpecialStatic;
|
||||
union_field_val->type = type_info_union_field_type;
|
||||
|
||||
ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 3);
|
||||
ZigValue **inner_fields = alloc_const_vals_ptrs(ira->codegen, 2);
|
||||
inner_fields[1]->special = ConstValSpecialStatic;
|
||||
inner_fields[1]->type = get_optional_type(ira->codegen, type_info_enum_field_type);
|
||||
|
||||
if (fields[1]->data.x_optional == nullptr) {
|
||||
inner_fields[1]->data.x_optional = nullptr;
|
||||
} else {
|
||||
inner_fields[1]->data.x_optional = ira->codegen->pass1_arena->create<ZigValue>();
|
||||
make_enum_field_val(ira, inner_fields[1]->data.x_optional, union_field->enum_field, type_info_enum_field_type);
|
||||
}
|
||||
|
||||
inner_fields[2]->special = ConstValSpecialStatic;
|
||||
inner_fields[2]->type = ira->codegen->builtin_types.entry_type;
|
||||
inner_fields[2]->data.x_type = union_field->type_entry;
|
||||
inner_fields[1]->type = ira->codegen->builtin_types.entry_type;
|
||||
inner_fields[1]->data.x_type = union_field->type_entry;
|
||||
|
||||
ZigValue *name = create_const_str_lit(ira->codegen, union_field->name)->data.x_ptr.data.ref.pointee;
|
||||
init_const_slice(ira->codegen, inner_fields[0], name, 0, buf_len(union_field->name), true);
|
||||
|
@ -26102,7 +26090,8 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
|
|||
entry->data.structure.layout = layout;
|
||||
entry->data.structure.special = is_tuple ? StructSpecialInferredTuple : StructSpecialNone;
|
||||
entry->data.structure.created_by_at_type = true;
|
||||
entry->data.structure.decls_scope = create_decls_scope(ira->codegen, nullptr, nullptr, entry, entry, &entry->name);
|
||||
entry->data.structure.decls_scope = create_decls_scope(
|
||||
ira->codegen, source_instr->source_node, source_instr->scope, entry, get_scope_import(source_instr->scope), &entry->name);
|
||||
|
||||
assert(fields_ptr->data.x_ptr.special == ConstPtrSpecialBaseArray);
|
||||
assert(fields_ptr->data.x_ptr.data.base_array.elem_index == 0);
|
||||
|
@ -26226,13 +26215,89 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
|
|||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
field->value = *field_int_value;
|
||||
}
|
||||
|
||||
return entry;
|
||||
}
|
||||
case ZigTypeIdUnion:
|
||||
ir_add_error(ira, source_instr, buf_sprintf(
|
||||
"TODO implement @Type for 'TypeInfo.%s': see https://github.com/ziglang/zig/issues/2907", type_id_name(tagTypeId)));
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
case ZigTypeIdUnion: {
|
||||
assert(payload->special == ConstValSpecialStatic);
|
||||
assert(payload->type == ir_type_info_get_type(ira, "Union", nullptr));
|
||||
|
||||
ZigValue *layout_value = get_const_field(ira, source_instr->source_node, payload, "layout", 0);
|
||||
if (layout_value == nullptr)
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
assert(layout_value->special == ConstValSpecialStatic);
|
||||
assert(layout_value->type == ir_type_info_get_type(ira, "ContainerLayout", nullptr));
|
||||
ContainerLayout layout = (ContainerLayout)bigint_as_u32(&layout_value->data.x_enum_tag);
|
||||
|
||||
ZigType *tag_type = get_const_field_meta_type_optional(ira, source_instr->source_node, payload, "tag_type", 1);
|
||||
if (tag_type != nullptr && type_is_invalid(tag_type)) {
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
}
|
||||
if (tag_type != nullptr && tag_type->id != ZigTypeIdEnum) {
|
||||
ir_add_error(ira, source_instr, buf_sprintf(
|
||||
"expected enum type, found '%s'", type_id_name(tag_type->id)));
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
}
|
||||
|
||||
ZigValue *fields_value = get_const_field(ira, source_instr->source_node, payload, "fields", 2);
|
||||
if (fields_value == nullptr)
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
|
||||
assert(fields_value->special == ConstValSpecialStatic);
|
||||
assert(is_slice(fields_value->type));
|
||||
ZigValue *fields_ptr = fields_value->data.x_struct.fields[slice_ptr_index];
|
||||
ZigValue *fields_len_value = fields_value->data.x_struct.fields[slice_len_index];
|
||||
size_t fields_len = bigint_as_usize(&fields_len_value->data.x_bigint);
|
||||
|
||||
ZigValue *decls_value = get_const_field(ira, source_instr->source_node, payload, "decls", 3);
|
||||
if (decls_value == nullptr)
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
|
||||
assert(decls_value->special == ConstValSpecialStatic);
|
||||
assert(is_slice(decls_value->type));
|
||||
ZigValue *decls_len_value = decls_value->data.x_struct.fields[slice_len_index];
|
||||
size_t decls_len = bigint_as_usize(&decls_len_value->data.x_bigint);
|
||||
if (decls_len != 0) {
|
||||
ir_add_error(ira, source_instr, buf_create_from_str("TypeInfo.Union.decls must be empty for @Type"));
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
}
|
||||
|
||||
ZigType *entry = new_type_table_entry(ZigTypeIdUnion);
|
||||
buf_init_from_buf(&entry->name,
|
||||
get_anon_type_name(ira->codegen, ira->old_irb.exec, "union", source_instr->scope, source_instr->source_node, &entry->name));
|
||||
entry->data.unionation.decl_node = source_instr->source_node;
|
||||
entry->data.unionation.fields = heap::c_allocator.allocate<TypeUnionField>(fields_len);
|
||||
entry->data.unionation.fields_by_name.init(fields_len);
|
||||
entry->data.unionation.decls_scope = create_decls_scope(
|
||||
ira->codegen, source_instr->source_node, source_instr->scope, entry, get_scope_import(source_instr->scope), &entry->name);
|
||||
entry->data.unionation.tag_type = tag_type;
|
||||
entry->data.unionation.src_field_count = fields_len;
|
||||
entry->data.unionation.layout = layout;
|
||||
|
||||
assert(fields_ptr->data.x_ptr.special == ConstPtrSpecialBaseArray);
|
||||
assert(fields_ptr->data.x_ptr.data.base_array.elem_index == 0);
|
||||
ZigValue *fields_arr = fields_ptr->data.x_ptr.data.base_array.array_val;
|
||||
assert(fields_arr->special == ConstValSpecialStatic);
|
||||
assert(fields_arr->data.x_array.special == ConstArraySpecialNone);
|
||||
for (size_t i = 0; i < fields_len; i++) {
|
||||
ZigValue *field_value = &fields_arr->data.x_array.data.s_none.elements[i];
|
||||
assert(field_value->type == ir_type_info_get_type(ira, "UnionField", nullptr));
|
||||
TypeUnionField *field = &entry->data.unionation.fields[i];
|
||||
field->name = buf_alloc();
|
||||
if ((err = get_const_field_buf(ira, source_instr->source_node, field_value, "name", 0, field->name)))
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
if (entry->data.unionation.fields_by_name.put_unique(field->name, field) != nullptr) {
|
||||
ir_add_error(ira, source_instr, buf_sprintf("duplicate union field '%s'", buf_ptr(field->name)));
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
}
|
||||
field->decl_node = source_instr->source_node;
|
||||
ZigValue *type_value = get_const_field(ira, source_instr->source_node, field_value, "field_type", 1);
|
||||
if (type_value == nullptr)
|
||||
return ira->codegen->invalid_inst_gen->value->type;
|
||||
field->type_val = type_value;
|
||||
field->type_entry = type_value->data.x_type;
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
case ZigTypeIdFn:
|
||||
case ZigTypeIdBoundFn:
|
||||
ir_add_error(ira, source_instr, buf_sprintf(
|
||||
|
|
|
@ -10,6 +10,135 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
|
|||
"tmp.zig:2:37: error: expected type '[:1]const u8', found '*const [2:2]u8'",
|
||||
});
|
||||
|
||||
cases.add("@Type for union with opaque field",
|
||||
\\const TypeInfo = @import("builtin").TypeInfo;
|
||||
\\const Untagged = @Type(.{
|
||||
\\ .Union = .{
|
||||
\\ .layout = .Auto,
|
||||
\\ .tag_type = null,
|
||||
\\ .fields = &[_]TypeInfo.UnionField{
|
||||
\\ .{ .name = "foo", .field_type = @Type(.Opaque) },
|
||||
\\ },
|
||||
\\ .decls = &[_]TypeInfo.Declaration{},
|
||||
\\ },
|
||||
\\});
|
||||
\\export fn entry() void {
|
||||
\\ _ = Untagged{};
|
||||
\\}
|
||||
, &[_][]const u8{
|
||||
"tmp.zig:2:25: error: opaque types have unknown size and therefore cannot be directly embedded in unions",
|
||||
"tmp.zig:13:17: note: referenced here",
|
||||
});
|
||||
|
||||
cases.add("@Type for union with zero fields",
|
||||
\\const TypeInfo = @import("builtin").TypeInfo;
|
||||
\\const Untagged = @Type(.{
|
||||
\\ .Union = .{
|
||||
\\ .layout = .Auto,
|
||||
\\ .tag_type = null,
|
||||
\\ .fields = &[_]TypeInfo.UnionField{},
|
||||
\\ .decls = &[_]TypeInfo.Declaration{},
|
||||
\\ },
|
||||
\\});
|
||||
\\export fn entry() void {
|
||||
\\ _ = Untagged{};
|
||||
\\}
|
||||
, &[_][]const u8{
|
||||
"tmp.zig:2:25: error: unions must have 1 or more fields",
|
||||
"tmp.zig:11:17: note: referenced here",
|
||||
});
|
||||
|
||||
cases.add("@Type for exhaustive enum with zero fields",
|
||||
\\const TypeInfo = @import("builtin").TypeInfo;
|
||||
\\const Tag = @Type(.{
|
||||
\\ .Enum = .{
|
||||
\\ .layout = .Auto,
|
||||
\\ .tag_type = u1,
|
||||
\\ .fields = &[_]TypeInfo.EnumField{},
|
||||
\\ .decls = &[_]TypeInfo.Declaration{},
|
||||
\\ .is_exhaustive = true,
|
||||
\\ },
|
||||
\\});
|
||||
\\export fn entry() void {
|
||||
\\ _ = @intToEnum(Tag, 0);
|
||||
\\}
|
||||
, &[_][]const u8{
|
||||
"tmp.zig:2:20: error: enums must have 1 or more fields",
|
||||
"tmp.zig:12:9: note: referenced here",
|
||||
});
|
||||
|
||||
cases.add("@Type for tagged union with extra union field",
|
||||
\\const TypeInfo = @import("builtin").TypeInfo;
|
||||
\\const Tag = @Type(.{
|
||||
\\ .Enum = .{
|
||||
\\ .layout = .Auto,
|
||||
\\ .tag_type = u1,
|
||||
\\ .fields = &[_]TypeInfo.EnumField{
|
||||
\\ .{ .name = "signed", .value = 0 },
|
||||
\\ .{ .name = "unsigned", .value = 1 },
|
||||
\\ },
|
||||
\\ .decls = &[_]TypeInfo.Declaration{},
|
||||
\\ .is_exhaustive = true,
|
||||
\\ },
|
||||
\\});
|
||||
\\const Tagged = @Type(.{
|
||||
\\ .Union = .{
|
||||
\\ .layout = .Auto,
|
||||
\\ .tag_type = Tag,
|
||||
\\ .fields = &[_]TypeInfo.UnionField{
|
||||
\\ .{ .name = "signed", .field_type = i32 },
|
||||
\\ .{ .name = "unsigned", .field_type = u32 },
|
||||
\\ .{ .name = "arst", .field_type = f32 },
|
||||
\\ },
|
||||
\\ .decls = &[_]TypeInfo.Declaration{},
|
||||
\\ },
|
||||
\\});
|
||||
\\export fn entry() void {
|
||||
\\ var tagged = Tagged{ .signed = -1 };
|
||||
\\ tagged = .{ .unsigned = 1 };
|
||||
\\}
|
||||
, &[_][]const u8{
|
||||
"tmp.zig:14:23: error: enum field not found: 'arst'",
|
||||
"tmp.zig:2:20: note: enum declared here",
|
||||
"tmp.zig:27:24: note: referenced here",
|
||||
});
|
||||
|
||||
cases.add("@Type for tagged union with extra enum field",
|
||||
\\const TypeInfo = @import("builtin").TypeInfo;
|
||||
\\const Tag = @Type(.{
|
||||
\\ .Enum = .{
|
||||
\\ .layout = .Auto,
|
||||
\\ .tag_type = u2,
|
||||
\\ .fields = &[_]TypeInfo.EnumField{
|
||||
\\ .{ .name = "signed", .value = 0 },
|
||||
\\ .{ .name = "unsigned", .value = 1 },
|
||||
\\ .{ .name = "arst", .field_type = 2 },
|
||||
\\ },
|
||||
\\ .decls = &[_]TypeInfo.Declaration{},
|
||||
\\ .is_exhaustive = true,
|
||||
\\ },
|
||||
\\});
|
||||
\\const Tagged = @Type(.{
|
||||
\\ .Union = .{
|
||||
\\ .layout = .Auto,
|
||||
\\ .tag_type = Tag,
|
||||
\\ .fields = &[_]TypeInfo.UnionField{
|
||||
\\ .{ .name = "signed", .field_type = i32 },
|
||||
\\ .{ .name = "unsigned", .field_type = u32 },
|
||||
\\ },
|
||||
\\ .decls = &[_]TypeInfo.Declaration{},
|
||||
\\ },
|
||||
\\});
|
||||
\\export fn entry() void {
|
||||
\\ var tagged = Tagged{ .signed = -1 };
|
||||
\\ tagged = .{ .unsigned = 1 };
|
||||
\\}
|
||||
, &[_][]const u8{
|
||||
"tmp.zig:9:32: error: no member named 'field_type' in struct 'std.builtin.EnumField'",
|
||||
"tmp.zig:18:21: note: referenced here",
|
||||
"tmp.zig:27:18: note: referenced here",
|
||||
});
|
||||
|
||||
cases.add("@Type with undefined",
|
||||
\\comptime {
|
||||
\\ _ = @Type(.{ .Array = .{ .len = 0, .child = u8, .sentinel = undefined } });
|
||||
|
@ -7419,7 +7548,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
|
|||
});
|
||||
|
||||
cases.add( // fixed bug #2032
|
||||
"compile diagnostic string for top level decl type",
|
||||
"compile diagnostic string for top level decl type",
|
||||
\\export fn entry() void {
|
||||
\\ var foo: u32 = @This(){};
|
||||
\\}
|
||||
|
|
|
@ -313,3 +313,64 @@ test "Type.Enum" {
|
|||
testing.expectEqual(@as(u32, 5), @enumToInt(Bar.b));
|
||||
testing.expectEqual(@as(u32, 6), @enumToInt(@intToEnum(Bar, 6)));
|
||||
}
|
||||
|
||||
test "Type.Union" {
|
||||
const Untagged = @Type(.{
|
||||
.Union = .{
|
||||
.layout = .Auto,
|
||||
.tag_type = null,
|
||||
.fields = &[_]TypeInfo.UnionField{
|
||||
.{ .name = "int", .field_type = i32 },
|
||||
.{ .name = "float", .field_type = f32 },
|
||||
},
|
||||
.decls = &[_]TypeInfo.Declaration{},
|
||||
},
|
||||
});
|
||||
var untagged = Untagged{ .int = 1 };
|
||||
untagged.float = 2.0;
|
||||
untagged.int = 3;
|
||||
testing.expectEqual(@as(i32, 3), untagged.int);
|
||||
|
||||
const PackedUntagged = @Type(.{
|
||||
.Union = .{
|
||||
.layout = .Packed,
|
||||
.tag_type = null,
|
||||
.fields = &[_]TypeInfo.UnionField{
|
||||
.{ .name = "signed", .field_type = i32 },
|
||||
.{ .name = "unsigned", .field_type = u32 },
|
||||
},
|
||||
.decls = &[_]TypeInfo.Declaration{},
|
||||
},
|
||||
});
|
||||
var packed_untagged = PackedUntagged{ .signed = -1 };
|
||||
testing.expectEqual(@as(i32, -1), packed_untagged.signed);
|
||||
testing.expectEqual(~@as(u32, 0), packed_untagged.unsigned);
|
||||
|
||||
const Tag = @Type(.{
|
||||
.Enum = .{
|
||||
.layout = .Auto,
|
||||
.tag_type = u1,
|
||||
.fields = &[_]TypeInfo.EnumField{
|
||||
.{ .name = "signed", .value = 0 },
|
||||
.{ .name = "unsigned", .value = 1 },
|
||||
},
|
||||
.decls = &[_]TypeInfo.Declaration{},
|
||||
.is_exhaustive = true,
|
||||
},
|
||||
});
|
||||
const Tagged = @Type(.{
|
||||
.Union = .{
|
||||
.layout = .Auto,
|
||||
.tag_type = Tag,
|
||||
.fields = &[_]TypeInfo.UnionField{
|
||||
.{ .name = "signed", .field_type = i32 },
|
||||
.{ .name = "unsigned", .field_type = u32 },
|
||||
},
|
||||
.decls = &[_]TypeInfo.Declaration{},
|
||||
},
|
||||
});
|
||||
var tagged = Tagged{ .signed = -1 };
|
||||
testing.expectEqual(Tag.signed, tagged);
|
||||
tagged = .{ .unsigned = 1 };
|
||||
testing.expectEqual(Tag.unsigned, tagged);
|
||||
}
|
||||
|
|
|
@ -198,8 +198,6 @@ fn testUnion() void {
|
|||
expect(typeinfo_info.Union.layout == .Auto);
|
||||
expect(typeinfo_info.Union.tag_type.? == TypeId);
|
||||
expect(typeinfo_info.Union.fields.len == 25);
|
||||
expect(typeinfo_info.Union.fields[4].enum_field != null);
|
||||
expect(typeinfo_info.Union.fields[4].enum_field.?.value == 4);
|
||||
expect(typeinfo_info.Union.fields[4].field_type == @TypeOf(@typeInfo(u8).Int));
|
||||
expect(typeinfo_info.Union.decls.len == 21);
|
||||
|
||||
|
@ -213,7 +211,6 @@ fn testUnion() void {
|
|||
expect(notag_union_info.Union.tag_type == null);
|
||||
expect(notag_union_info.Union.layout == .Auto);
|
||||
expect(notag_union_info.Union.fields.len == 2);
|
||||
expect(notag_union_info.Union.fields[0].enum_field == null);
|
||||
expect(notag_union_info.Union.fields[1].field_type == u32);
|
||||
|
||||
const TestExternUnion = extern union {
|
||||
|
@ -223,7 +220,6 @@ fn testUnion() void {
|
|||
const extern_union_info = @typeInfo(TestExternUnion);
|
||||
expect(extern_union_info.Union.layout == .Extern);
|
||||
expect(extern_union_info.Union.tag_type == null);
|
||||
expect(extern_union_info.Union.fields[0].enum_field == null);
|
||||
expect(extern_union_info.Union.fields[0].field_type == *c_void);
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in New Issue