authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2021-01-31 12:37:12+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2021-01-31 12:37:12+02:00
logfdc875ed0080cd2542a854a8cd6c627b25e9b7a4
tree440a26f4a274b02dd67fc8b307e767b6faec24a9
parent78d2f2b819b4dc90bb112197d376d37e50540493
parent0b5f3c2ef96df02341cdf54f6eefb3cdb88781d8
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #7750 from tadeokondrak/6609-tagtype-tag

Remove @TagType; std.meta.TagType -> std.meta.Tag

31 files changed, 96 insertions(+), 187 deletions(-)

doc/langref.html.in+7-18
......@@ -2909,15 +2909,15 @@ test "enum variant switch" {
29092909 expect(mem.eql(u8, what_is_it, "this is a number"));
29102910}
29112911
2912// @TagType can be used to access the integer tag type of an enum.
2912// @typeInfo can be used to access the integer tag type of an enum.
29132913const Small = enum {
29142914 one,
29152915 two,
29162916 three,
29172917 four,
29182918};
2919test "@TagType" {
2920 expect(@TagType(Small) == u2);
2919test "std.meta.Tag" {
2920 expect(@typeInfo(Small).Enum.tag_type == u2);
29212921}
29222922
29232923// @typeInfo tells us the field count and the fields names:
......@@ -3092,8 +3092,7 @@ test "simple union" {
30923092 {#header_open|Tagged union#}
30933093 <p>Unions can be declared with an enum tag type.
30943094 This turns the union into a <em>tagged</em> union, which makes it eligible
3095 to use with {#link|switch#} expressions. One can use {#link|@TagType#} to
3096 obtain the enum type from the union type.
3095 to use with {#link|switch#} expressions.
30973096 Tagged unions coerce to their tag type: {#link|Type Coercion: unions and enums#}.
30983097 </p>
30993098 {#code_begin|test#}
......@@ -3119,8 +3118,8 @@ test "switch on tagged union" {
31193118 }
31203119}
31213120
3122test "@TagType" {
3123 expect(@TagType(ComplexType) == ComplexTypeTag);
3121test "get tag type" {
3122 expect(std.meta.Tag(ComplexType) == ComplexTypeTag);
31243123}
31253124
31263125test "coerce to enum" {
......@@ -7740,7 +7739,7 @@ test "@hasDecl" {
77407739 {#header_close#}
77417740
77427741 {#header_open|@intToEnum#}
7743 <pre>{#syntax#}@intToEnum(comptime DestType: type, int_value: @TagType(DestType)) DestType{#endsyntax#}</pre>
7742 <pre>{#syntax#}@intToEnum(comptime DestType: type, int_value: std.meta.Tag(DestType)) DestType{#endsyntax#}</pre>
77447743 <p>
77457744 Converts an integer into an {#link|enum#} value.
77467745 </p>
......@@ -8435,16 +8434,6 @@ fn doTheTest() void {
84358434 </p>
84368435 {#header_close#}
84378436
8438 {#header_open|@TagType#}
8439 <pre>{#syntax#}@TagType(T: type) type{#endsyntax#}</pre>
8440 <p>
8441 For an enum, returns the integer type that is used to store the enumeration value.
8442 </p>
8443 <p>
8444 For a union, returns the enum type that is used to store the tag value.
8445 </p>
8446 {#header_close#}
8447
84488437 {#header_open|@This#}
84498438 <pre>{#syntax#}@This() type{#endsyntax#}</pre>
84508439 <p>
lib/std/builtin.zig+1-1
......@@ -175,7 +175,7 @@ pub const SourceLocation = struct {
175175 column: u32,
176176};
177177
178pub const TypeId = @TagType(TypeInfo);
178pub const TypeId = std.meta.Tag(TypeInfo);
179179
180180/// This data structure is used by the Zig language code generation and
181181/// therefore must be kept in sync with the compiler implementation.
lib/std/c/ast.zig+1-1
......@@ -110,7 +110,7 @@ pub const Error = union(enum) {
110110
111111 pub const ExpectedToken = struct {
112112 token: TokenIndex,
113 expected_id: @TagType(Token.Id),
113 expected_id: std.meta.Tag(Token.Id),
114114
115115 pub fn render(self: *const ExpectedToken, tree: *Tree, stream: anytype) !void {
116116 const found_token = tree.tokens.at(self.token);
lib/std/c/parse.zig+3-3
......@@ -26,7 +26,7 @@ pub const Options = struct {
2626 None,
2727
2828 /// Some warnings are errors
29 Some: []@TagType(ast.Error),
29 Some: []std.meta.Tag(ast.Error),
3030
3131 /// All warnings are errors
3232 All,
......@@ -1363,7 +1363,7 @@ const Parser = struct {
13631363 return &node.base;
13641364 }
13651365
1366 fn eatToken(parser: *Parser, id: @TagType(Token.Id)) ?TokenIndex {
1366 fn eatToken(parser: *Parser, id: std.meta.Tag(Token.Id)) ?TokenIndex {
13671367 while (true) {
13681368 switch ((parser.it.next() orelse return null).id) {
13691369 .LineComment, .MultiLineComment, .Nl => continue,
......@@ -1377,7 +1377,7 @@ const Parser = struct {
13771377 }
13781378 }
13791379
1380 fn expectToken(parser: *Parser, id: @TagType(Token.Id)) Error!TokenIndex {
1380 fn expectToken(parser: *Parser, id: std.meta.Tag(Token.Id)) Error!TokenIndex {
13811381 while (true) {
13821382 switch ((parser.it.next() orelse return error.ParseError).id) {
13831383 .LineComment, .MultiLineComment, .Nl => continue,
lib/std/c/tokenizer.zig+2-2
......@@ -131,7 +131,7 @@ pub const Token = struct {
131131 Keyword_error,
132132 Keyword_pragma,
133133
134 pub fn symbol(id: @TagType(Id)) []const u8 {
134 pub fn symbol(id: std.meta.TagType(Id)) []const u8 {
135135 return switch (id) {
136136 .Invalid => "Invalid",
137137 .Eof => "Eof",
......@@ -347,7 +347,7 @@ pub const Token = struct {
347347pub const Tokenizer = struct {
348348 buffer: []const u8,
349349 index: usize = 0,
350 prev_tok_id: @TagType(Token.Id) = .Invalid,
350 prev_tok_id: std.meta.TagType(Token.Id) = .Invalid,
351351 pp_directive: bool = false,
352352
353353 pub fn next(self: *Tokenizer) Token {
lib/std/hash/auto_hash.zig+1-1
......@@ -239,7 +239,7 @@ fn testHashDeepRecursive(key: anytype) u64 {
239239
240240test "typeContainsSlice" {
241241 comptime {
242 testing.expect(!typeContainsSlice(@TagType(std.builtin.TypeInfo)));
242 testing.expect(!typeContainsSlice(meta.Tag(std.builtin.TypeInfo)));
243243
244244 testing.expect(typeContainsSlice([]const u8));
245245 testing.expect(!typeContainsSlice(u8));
lib/std/json.zig+5-5
......@@ -246,7 +246,7 @@ pub const StreamingParser = struct {
246246 // Only call this function to generate array/object final state.
247247 pub fn fromInt(x: anytype) State {
248248 debug.assert(x == 0 or x == 1);
249 const T = @TagType(State);
249 const T = std.meta.Tag(State);
250250 return @intToEnum(State, @intCast(T, x));
251251 }
252252 };
......@@ -1138,7 +1138,7 @@ pub const TokenStream = struct {
11381138 }
11391139};
11401140
1141fn checkNext(p: *TokenStream, id: std.meta.TagType(Token)) void {
1141fn checkNext(p: *TokenStream, id: std.meta.Tag(Token)) void {
11421142 const token = (p.next() catch unreachable).?;
11431143 debug.assert(std.meta.activeTag(token) == id);
11441144}
......@@ -1782,7 +1782,7 @@ test "parseFree descends into tagged union" {
17821782 };
17831783 // use a string with unicode escape so we know result can't be a reference to global constant
17841784 const r = try parse(T, &TokenStream.init("\"with\\u0105unicode\""), options);
1785 testing.expectEqual(@TagType(T).string, @as(@TagType(T), r));
1785 testing.expectEqual(std.meta.Tag(T).string, @as(std.meta.Tag(T), r));
17861786 testing.expectEqualSlices(u8, "withąunicode", r.string);
17871787 testing.expectEqual(@as(usize, 0), fail_alloc.deallocations);
17881788 parseFree(T, r, options);
......@@ -2077,7 +2077,7 @@ pub const Parser = struct {
20772077 }
20782078 }
20792079
2080 fn parseString(p: *Parser, allocator: *Allocator, s: std.meta.TagPayloadType(Token, Token.String), input: []const u8, i: usize) !Value {
2080 fn parseString(p: *Parser, allocator: *Allocator, s: std.meta.TagPayload(Token, Token.String), input: []const u8, i: usize) !Value {
20812081 const slice = s.slice(input, i);
20822082 switch (s.escapes) {
20832083 .None => return Value{ .String = if (p.copy_strings) try allocator.dupe(u8, slice) else slice },
......@@ -2090,7 +2090,7 @@ pub const Parser = struct {
20902090 }
20912091 }
20922092
2093 fn parseNumber(p: *Parser, n: std.meta.TagPayloadType(Token, Token.Number), input: []const u8, i: usize) !Value {
2093 fn parseNumber(p: *Parser, n: std.meta.TagPayload(Token, Token.Number), input: []const u8, i: usize) !Value {
20942094 return if (n.is_integer)
20952095 Value{ .Integer = try std.fmt.parseInt(i64, n.slice(input, i), 10) }
20962096 else
lib/std/meta.zig+21-16
......@@ -600,15 +600,18 @@ test "std.meta.FieldEnum" {
600600 expectEqualEnum(enum { a, b, c }, FieldEnum(union { a: u8, b: void, c: f32 }));
601601}
602602
603pub fn TagType(comptime T: type) type {
603// Deprecated: use Tag
604pub const TagType = Tag;
605
606pub fn Tag(comptime T: type) type {
604607 return switch (@typeInfo(T)) {
605608 .Enum => |info| info.tag_type,
606 .Union => |info| if (info.tag_type) |Tag| Tag else null,
609 .Union => |info| info.tag_type orelse @compileError(@typeName(T) ++ " has no tag type"),
607610 else => @compileError("expected enum or union type, found '" ++ @typeName(T) ++ "'"),
608611 };
609612}
610613
611test "std.meta.TagType" {
614test "std.meta.Tag" {
612615 const E = enum(u8) {
613616 C = 33,
614617 D,
......@@ -618,14 +621,14 @@ test "std.meta.TagType" {
618621 D: u16,
619622 };
620623
621 testing.expect(TagType(E) == u8);
622 testing.expect(TagType(U) == E);
624 testing.expect(Tag(E) == u8);
625 testing.expect(Tag(U) == E);
623626}
624627
625628///Returns the active tag of a tagged union
626pub fn activeTag(u: anytype) @TagType(@TypeOf(u)) {
629pub fn activeTag(u: anytype) Tag(@TypeOf(u)) {
627630 const T = @TypeOf(u);
628 return @as(@TagType(T), u);
631 return @as(Tag(T), u);
629632}
630633
631634test "std.meta.activeTag" {
......@@ -646,13 +649,15 @@ test "std.meta.activeTag" {
646649 testing.expect(activeTag(u) == UE.Float);
647650}
648651
652const TagPayloadType = TagPayload;
653
649654///Given a tagged union type, and an enum, return the type of the union
650655/// field corresponding to the enum tag.
651pub fn TagPayloadType(comptime U: type, tag: @TagType(U)) type {
656pub fn TagPayload(comptime U: type, tag: Tag(U)) type {
652657 testing.expect(trait.is(.Union)(U));
653658
654659 const info = @typeInfo(U).Union;
655 const tag_info = @typeInfo(@TagType(U)).Enum;
660 const tag_info = @typeInfo(Tag(U)).Enum;
656661
657662 inline for (info.fields) |field_info| {
658663 if (comptime mem.eql(u8, field_info.name, @tagName(tag)))
......@@ -662,14 +667,14 @@ pub fn TagPayloadType(comptime U: type, tag: @TagType(U)) type {
662667 unreachable;
663668}
664669
665test "std.meta.TagPayloadType" {
670test "std.meta.TagPayload" {
666671 const Event = union(enum) {
667672 Moved: struct {
668673 from: i32,
669674 to: i32,
670675 },
671676 };
672 const MovedEvent = TagPayloadType(Event, Event.Moved);
677 const MovedEvent = TagPayload(Event, Event.Moved);
673678 var e: Event = undefined;
674679 testing.expect(MovedEvent == @TypeOf(e.Moved));
675680}
......@@ -694,13 +699,13 @@ pub fn eql(a: anytype, b: @TypeOf(a)) bool {
694699 }
695700 },
696701 .Union => |info| {
697 if (info.tag_type) |Tag| {
702 if (info.tag_type) |UnionTag| {
698703 const tag_a = activeTag(a);
699704 const tag_b = activeTag(b);
700705 if (tag_a != tag_b) return false;
701706
702707 inline for (info.fields) |field_info| {
703 if (@field(Tag, field_info.name) == tag_a) {
708 if (@field(UnionTag, field_info.name) == tag_a) {
704709 return eql(@field(a, field_info.name), @field(b, field_info.name));
705710 }
706711 }
......@@ -822,9 +827,9 @@ test "intToEnum with error return" {
822827
823828pub const IntToEnumError = error{InvalidEnumTag};
824829
825pub fn intToEnum(comptime Tag: type, tag_int: anytype) IntToEnumError!Tag {
826 inline for (@typeInfo(Tag).Enum.fields) |f| {
827 const this_tag_value = @field(Tag, f.name);
830pub fn intToEnum(comptime EnumTag: type, tag_int: anytype) IntToEnumError!EnumTag {
831 inline for (@typeInfo(EnumTag).Enum.fields) |f| {
832 const this_tag_value = @field(EnumTag, f.name);
828833 if (tag_int == @enumToInt(this_tag_value)) {
829834 return this_tag_value;
830835 }
lib/std/meta/trailer_flags.zig+1-1
......@@ -146,7 +146,7 @@ test "TrailerFlags" {
146146 b: bool,
147147 c: u64,
148148 });
149 testing.expectEqual(u2, @TagType(Flags.FieldEnum));
149 testing.expectEqual(u2, meta.Tag(Flags.FieldEnum));
150150
151151 var flags = Flags.init(.{
152152 .b = true,
lib/std/testing.zig+3-3
......@@ -119,10 +119,10 @@ pub fn expectEqual(expected: anytype, actual: @TypeOf(expected)) void {
119119 @compileError("Unable to compare untagged union values");
120120 }
121121
122 const TagType = @TagType(@TypeOf(expected));
122 const Tag = std.meta.Tag(@TypeOf(expected));
123123
124 const expectedTag = @as(TagType, expected);
125 const actualTag = @as(TagType, actual);
124 const expectedTag = @as(Tag, expected);
125 const actualTag = @as(Tag, actual);
126126
127127 expectEqual(expectedTag, actualTag);
128128
lib/std/zig/parser_test.zig+1-1
......@@ -3822,7 +3822,7 @@ fn testCanonical(source: []const u8) !void {
38223822 return testTransform(source, source);
38233823}
38243824
3825const Error = @TagType(std.zig.ast.Error);
3825const Error = std.meta.Tag(std.zig.ast.Error);
38263826
38273827fn testError(source: []const u8, expected_errors: []const Error) !void {
38283828 const tree = try std.zig.parse(std.testing.allocator, source);
src/DepTokenizer.zig+2-2
......@@ -266,11 +266,11 @@ pub fn next(self: *Tokenizer) ?Token {
266266 unreachable;
267267}
268268
269fn errorPosition(comptime id: @TagType(Token), index: usize, bytes: []const u8) Token {
269fn errorPosition(comptime id: std.meta.Tag(Token), index: usize, bytes: []const u8) Token {
270270 return @unionInit(Token, @tagName(id), .{ .index = index, .bytes = bytes });
271271}
272272
273fn errorIllegalChar(comptime id: @TagType(Token), index: usize, char: u8) Token {
273fn errorIllegalChar(comptime id: std.meta.Tag(Token), index: usize, char: u8) Token {
274274 return @unionInit(Token, @tagName(id), .{ .index = index, .char = char });
275275}
276276
src/astgen.zig-1
......@@ -3077,7 +3077,6 @@ fn nodeMayNeedMemoryLocation(start_node: *ast.Node, scope: *Scope) bool {
30773077 .{ "@round", false },
30783078 .{ "@subWithOverflow", false },
30793079 .{ "@tagName", false },
3080 .{ "@TagType", false },
30813080 .{ "@This", false },
30823081 .{ "@truncate", false },
30833082 .{ "@Type", false },
src/link/MachO/commands.zig+1-1
......@@ -140,7 +140,7 @@ pub const LoadCommand = union(enum) {
140140 }
141141
142142 fn eql(self: LoadCommand, other: LoadCommand) bool {
143 if (@as(@TagType(LoadCommand), self) != @as(@TagType(LoadCommand), other)) return false;
143 if (@as(meta.Tag(LoadCommand), self) != @as(meta.Tag(LoadCommand), other)) return false;
144144 return switch (self) {
145145 .DyldInfoOnly => |x| meta.eql(x, other.DyldInfoOnly),
146146 .Symtab => |x| meta.eql(x, other.Symtab),
src/stage1/all_types.hpp-8
......@@ -1811,7 +1811,6 @@ enum BuiltinFnId {
18111811 BuiltinFnIdIntToPtr,
18121812 BuiltinFnIdPtrToInt,
18131813 BuiltinFnIdTagName,
1814 BuiltinFnIdTagType,
18151814 BuiltinFnIdFieldParentPtr,
18161815 BuiltinFnIdByteOffsetOf,
18171816 BuiltinFnIdBitOffsetOf,
......@@ -2623,7 +2622,6 @@ enum IrInstSrcId {
26232622 IrInstSrcIdDeclRef,
26242623 IrInstSrcIdPanic,
26252624 IrInstSrcIdTagName,
2626 IrInstSrcIdTagType,
26272625 IrInstSrcIdFieldParentPtr,
26282626 IrInstSrcIdByteOffsetOf,
26292627 IrInstSrcIdBitOffsetOf,
......@@ -4074,12 +4072,6 @@ struct IrInstGenTagName {
40744072 IrInstGen *target;
40754073};
40764074
4077struct IrInstSrcTagType {
4078 IrInstSrc base;
4079
4080 IrInstSrc *target;
4081};
4082
40834075struct IrInstSrcFieldParentPtr {
40844076 IrInstSrc base;
40854077
src/stage1/analyze.cpp+1-1
......@@ -3267,7 +3267,7 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
32673267
32683268 tag_type = new_type_table_entry(ZigTypeIdEnum);
32693269 buf_resize(&tag_type->name, 0);
3270 buf_appendf(&tag_type->name, "@TagType(%s)", buf_ptr(&union_type->name));
3270 buf_appendf(&tag_type->name, "@typeInfo(%s).Union.tag_type.?", buf_ptr(&union_type->name));
32713271 tag_type->llvm_type = tag_int_type->llvm_type;
32723272 tag_type->llvm_di_type = tag_int_type->llvm_di_type;
32733273 tag_type->abi_size = tag_int_type->abi_size;
src/stage1/codegen.cpp-1
......@@ -8842,7 +8842,6 @@ static void define_builtin_fns(CodeGen *g) {
88428842 create_builtin_fn(g, BuiltinFnIdIntToPtr, "intToPtr", 2);
88438843 create_builtin_fn(g, BuiltinFnIdPtrToInt, "ptrToInt", 1);
88448844 create_builtin_fn(g, BuiltinFnIdTagName, "tagName", 1);
8845 create_builtin_fn(g, BuiltinFnIdTagType, "TagType", 1);
88468845 create_builtin_fn(g, BuiltinFnIdFieldParentPtr, "fieldParentPtr", 3);
88478846 create_builtin_fn(g, BuiltinFnIdByteOffsetOf, "byteOffsetOf", 2);
88488847 create_builtin_fn(g, BuiltinFnIdBitOffsetOf, "bitOffsetOf", 2);
src/stage1/ir.cpp-54
......@@ -516,8 +516,6 @@ static void destroy_instruction_src(IrInstSrc *inst) {
516516 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcSetAlignStack *>(inst));
517517 case IrInstSrcIdArgType:
518518 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcArgType *>(inst));
519 case IrInstSrcIdTagType:
520 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcTagType *>(inst));
521519 case IrInstSrcIdExport:
522520 return heap::c_allocator.destroy(reinterpret_cast<IrInstSrcExport *>(inst));
523521 case IrInstSrcIdExtern:
......@@ -1496,10 +1494,6 @@ static constexpr IrInstSrcId ir_inst_id(IrInstSrcTagName *) {
14961494 return IrInstSrcIdTagName;
14971495}
14981496
1499static constexpr IrInstSrcId ir_inst_id(IrInstSrcTagType *) {
1500 return IrInstSrcIdTagType;
1501}
1502
15031497static constexpr IrInstSrcId ir_inst_id(IrInstSrcFieldParentPtr *) {
15041498 return IrInstSrcIdFieldParentPtr;
15051499}
......@@ -4450,17 +4444,6 @@ static IrInstGen *ir_build_tag_name_gen(IrAnalyze *ira, IrInst *source_instr, Ir
44504444 return &instruction->base;
44514445}
44524446
4453static IrInstSrc *ir_build_tag_type(IrBuilderSrc *irb, Scope *scope, AstNode *source_node,
4454 IrInstSrc *target)
4455{
4456 IrInstSrcTagType *instruction = ir_build_instruction<IrInstSrcTagType>(irb, scope, source_node);
4457 instruction->target = target;
4458
4459 ir_ref_instruction(target, irb->current_basic_block);
4460
4461 return &instruction->base;
4462}
4463
44644447static IrInstSrc *ir_build_field_parent_ptr_src(IrBuilderSrc *irb, Scope *scope, AstNode *source_node,
44654448 IrInstSrc *type_value, IrInstSrc *field_name, IrInstSrc *field_ptr)
44664449{
......@@ -7202,16 +7185,6 @@ static IrInstSrc *ir_gen_builtin_fn_call(IrBuilderSrc *irb, Scope *scope, AstNod
72027185 IrInstSrc *tag_name = ir_build_tag_name_src(irb, scope, node, arg0_value);
72037186 return ir_lval_wrap(irb, scope, tag_name, lval, result_loc);
72047187 }
7205 case BuiltinFnIdTagType:
7206 {
7207 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
7208 IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
7209 if (arg0_value == irb->codegen->invalid_inst_src)
7210 return arg0_value;
7211
7212 IrInstSrc *tag_type = ir_build_tag_type(irb, scope, node, arg0_value);
7213 return ir_lval_wrap(irb, scope, tag_type, lval, result_loc);
7214 }
72157188 case BuiltinFnIdFieldParentPtr:
72167189 {
72177190 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
......@@ -31051,30 +31024,6 @@ static IrInstGen *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstSrcArgTy
3105131024 return ir_const_type(ira, &instruction->base.base, result_type);
3105231025}
3105331026
31054static IrInstGen *ir_analyze_instruction_tag_type(IrAnalyze *ira, IrInstSrcTagType *instruction) {
31055 Error err;
31056 IrInstGen *target_inst = instruction->target->child;
31057 ZigType *enum_type = ir_resolve_type(ira, target_inst);
31058 if (type_is_invalid(enum_type))
31059 return ira->codegen->invalid_inst_gen;
31060
31061 if (enum_type->id == ZigTypeIdEnum) {
31062 if ((err = type_resolve(ira->codegen, enum_type, ResolveStatusSizeKnown)))
31063 return ira->codegen->invalid_inst_gen;
31064
31065 return ir_const_type(ira, &instruction->base.base, enum_type->data.enumeration.tag_int_type);
31066 } else if (enum_type->id == ZigTypeIdUnion) {
31067 ZigType *tag_type = ir_resolve_union_tag_type(ira, instruction->target->base.source_node, enum_type);
31068 if (type_is_invalid(tag_type))
31069 return ira->codegen->invalid_inst_gen;
31070 return ir_const_type(ira, &instruction->base.base, tag_type);
31071 } else {
31072 ir_add_error(ira, &target_inst->base, buf_sprintf("expected enum or union, found '%s'",
31073 buf_ptr(&enum_type->name)));
31074 return ira->codegen->invalid_inst_gen;
31075 }
31076}
31077
3107831027static ZigType *ir_resolve_atomic_operand_type(IrAnalyze *ira, IrInstGen *op) {
3107931028 ZigType *operand_type = ir_resolve_type(ira, op);
3108031029 if (type_is_invalid(operand_type))
......@@ -32435,8 +32384,6 @@ static IrInstGen *ir_analyze_instruction_base(IrAnalyze *ira, IrInstSrc *instruc
3243532384 return ir_analyze_instruction_set_align_stack(ira, (IrInstSrcSetAlignStack *)instruction);
3243632385 case IrInstSrcIdArgType:
3243732386 return ir_analyze_instruction_arg_type(ira, (IrInstSrcArgType *)instruction);
32438 case IrInstSrcIdTagType:
32439 return ir_analyze_instruction_tag_type(ira, (IrInstSrcTagType *)instruction);
3244032387 case IrInstSrcIdExport:
3244132388 return ir_analyze_instruction_export(ira, (IrInstSrcExport *)instruction);
3244232389 case IrInstSrcIdExtern:
......@@ -32879,7 +32826,6 @@ bool ir_inst_src_has_side_effects(IrInstSrc *instruction) {
3287932826 case IrInstSrcIdImplicitCast:
3288032827 case IrInstSrcIdResolveResult:
3288132828 case IrInstSrcIdArgType:
32882 case IrInstSrcIdTagType:
3288332829 case IrInstSrcIdErrorReturnTrace:
3288432830 case IrInstSrcIdErrorUnion:
3288532831 case IrInstSrcIdFloatOp:
src/stage1/ir_print.cpp-11
......@@ -282,8 +282,6 @@ const char* ir_inst_src_type_str(IrInstSrcId id) {
282282 return "SrcPanic";
283283 case IrInstSrcIdTagName:
284284 return "SrcTagName";
285 case IrInstSrcIdTagType:
286 return "SrcTagType";
287285 case IrInstSrcIdFieldParentPtr:
288286 return "SrcFieldParentPtr";
289287 case IrInstSrcIdByteOffsetOf:
......@@ -2354,12 +2352,6 @@ static void ir_print_arg_type(IrPrintSrc *irp, IrInstSrcArgType *instruction) {
23542352 fprintf(irp->f, ")");
23552353}
23562354
2357static void ir_print_enum_tag_type(IrPrintSrc *irp, IrInstSrcTagType *instruction) {
2358 fprintf(irp->f, "@TagType(");
2359 ir_print_other_inst_src(irp, instruction->target);
2360 fprintf(irp->f, ")");
2361}
2362
23632355static void ir_print_export(IrPrintSrc *irp, IrInstSrcExport *instruction) {
23642356 fprintf(irp->f, "@export(");
23652357 ir_print_other_inst_src(irp, instruction->target);
......@@ -2953,9 +2945,6 @@ static void ir_print_inst_src(IrPrintSrc *irp, IrInstSrc *instruction, bool trai
29532945 case IrInstSrcIdArgType:
29542946 ir_print_arg_type(irp, (IrInstSrcArgType *)instruction);
29552947 break;
2956 case IrInstSrcIdTagType:
2957 ir_print_enum_tag_type(irp, (IrInstSrcTagType *)instruction);
2958 break;
29592948 case IrInstSrcIdExport:
29602949 ir_print_export(irp, (IrInstSrcExport *)instruction);
29612950 break;
src/test.zig+2-2
......@@ -750,7 +750,7 @@ pub const TestContext = struct {
750750
751751 for (actual_errors.list) |actual_error| {
752752 for (case_error_list) |case_msg, i| {
753 const ex_tag: @TagType(@TypeOf(case_msg)) = case_msg;
753 const ex_tag: std.meta.Tag(@TypeOf(case_msg)) = case_msg;
754754 switch (actual_error) {
755755 .src => |actual_msg| {
756756 for (actual_msg.notes) |*note| {
......@@ -789,7 +789,7 @@ pub const TestContext = struct {
789789 }
790790 while (notes_to_check.popOrNull()) |note| {
791791 for (case_error_list) |case_msg, i| {
792 const ex_tag: @TagType(@TypeOf(case_msg)) = case_msg;
792 const ex_tag: std.meta.Tag(@TypeOf(case_msg)) = case_msg;
793793 switch (note.*) {
794794 .src => |actual_msg| {
795795 for (actual_msg.notes) |*sub_note| {
src/translate_c.zig+1-1
......@@ -3288,7 +3288,7 @@ const ClangFunctionType = union(enum) {
32883288 NoProto: *const clang.FunctionType,
32893289
32903290 fn getReturnType(self: @This()) clang.QualType {
3291 switch (@as(@TagType(@This()), self)) {
3291 switch (@as(std.meta.Tag(@This()), self)) {
32923292 .Proto => return self.Proto.getReturnType(),
32933293 .NoProto => return self.NoProto.getReturnType(),
32943294 }
src/type.zig+1-1
......@@ -110,7 +110,7 @@ pub const Type = extern union {
110110
111111 pub fn tag(self: Type) Tag {
112112 if (self.tag_if_small_enough < Tag.no_payload_count) {
113 return @intToEnum(Tag, @intCast(@TagType(Tag), self.tag_if_small_enough));
113 return @intToEnum(Tag, @intCast(std.meta.Tag(Tag), self.tag_if_small_enough));
114114 } else {
115115 return self.ptr_otherwise.tag;
116116 }
src/value.zig+1-1
......@@ -223,7 +223,7 @@ pub const Value = extern union {
223223
224224 pub fn tag(self: Value) Tag {
225225 if (self.tag_if_small_enough < Tag.no_payload_count) {
226 return @intToEnum(Tag, @intCast(@TagType(Tag), self.tag_if_small_enough));
226 return @intToEnum(Tag, @intCast(std.meta.Tag(Tag), self.tag_if_small_enough));
227227 } else {
228228 return self.ptr_otherwise.tag;
229229 }
test/compile_errors.zig+4-16
......@@ -323,7 +323,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
323323 \\ e: E,
324324 \\};
325325 \\export fn entry() void {
326 \\ if (@TagType(E) != u8) @compileError("did not infer u8 tag type");
326 \\ if (@typeInfo(E).Enum.tag_type != u8) @compileError("did not infer u8 tag type");
327327 \\ const s: S = undefined;
328328 \\}
329329 , &[_][]const u8{
......@@ -2728,7 +2728,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
27282728 \\const InvalidToken = struct {};
27292729 \\const ExpectedVarDeclOrFn = struct {};
27302730 , &[_][]const u8{
2731 "tmp.zig:4:9: error: expected type '@TagType(Error)', found 'type'",
2731 "tmp.zig:4:9: error: expected type '@typeInfo(Error).Union.tag_type.?', found 'type'",
27322732 });
27332733
27342734 cases.addTest("binary OR operator on error sets",
......@@ -7462,24 +7462,12 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
74627462 "tmp.zig:4:5: note: declared here",
74637463 });
74647464
7465 cases.add("@TagType when union has no attached enum",
7466 \\const Foo = union {
7467 \\ A: i32,
7468 \\};
7469 \\export fn entry() void {
7470 \\ const x = @TagType(Foo);
7471 \\}
7472 , &[_][]const u8{
7473 "tmp.zig:5:24: error: union 'Foo' has no tag",
7474 "tmp.zig:1:13: note: consider 'union(enum)' here",
7475 });
7476
74777465 cases.add("non-integer tag type to automatic union enum",
74787466 \\const Foo = union(enum(f32)) {
74797467 \\ A: i32,
74807468 \\};
74817469 \\export fn entry() void {
7482 \\ const x = @TagType(Foo);
7470 \\ const x = @typeInfo(Foo).Union.tag_type.?;
74837471 \\}
74847472 , &[_][]const u8{
74857473 "tmp.zig:1:24: error: expected integer tag type, found 'f32'",
......@@ -7490,7 +7478,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
74907478 \\ A: i32,
74917479 \\};
74927480 \\export fn entry() void {
7493 \\ const x = @TagType(Foo);
7481 \\ const x = @typeInfo(Foo).Union.tag_type.?;
74947482 \\}
74957483 , &[_][]const u8{
74967484 "tmp.zig:1:19: error: expected enum tag type, found 'u32'",
test/runtime_safety.zig+1-1
......@@ -74,7 +74,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
7474 \\pub fn main() void {
7575 \\ var u: U = undefined;
7676 \\ @memset(@ptrCast([*]u8, &u), 0x55, @sizeOf(U));
77 \\ var t: @TagType(U) = u;
77 \\ var t: @typeInfo(U).Union.tag_type.? = u;
7878 \\ var n = @tagName(t);
7979 \\}
8080 );
test/stage1/behavior/bugs/1322.zig+2-2
......@@ -13,7 +13,7 @@ const C = struct {};
1313
1414test "tagged union with all void fields but a meaningful tag" {
1515 var a: A = A{ .b = B{ .c = C{} } };
16 std.testing.expect(@as(@TagType(B), a.b) == @TagType(B).c);
16 std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).c);
1717 a = A{ .b = B.None };
18 std.testing.expect(@as(@TagType(B), a.b) == @TagType(B).None);
18 std.testing.expect(@as(std.meta.Tag(B), a.b) == std.meta.Tag(B).None);
1919}
test/stage1/behavior/enum.zig+8-7
......@@ -1,5 +1,6 @@
11const expect = @import("std").testing.expect;
22const mem = @import("std").mem;
3const Tag = @import("std").meta.Tag;
34
45test "extern enum" {
56 const S = struct {
......@@ -827,12 +828,12 @@ test "set enum tag type" {
827828 {
828829 var x = Small.One;
829830 x = Small.Two;
830 comptime expect(@TagType(Small) == u2);
831 comptime expect(Tag(Small) == u2);
831832 }
832833 {
833834 var x = Small2.One;
834835 x = Small2.Two;
835 comptime expect(@TagType(Small2) == u2);
836 comptime expect(Tag(Small2) == u2);
836837 }
837838}
838839
......@@ -905,11 +906,11 @@ fn getC(data: *const BitFieldOfEnums) C {
905906}
906907
907908test "casting enum to its tag type" {
908 testCastEnumToTagType(Small2.Two);
909 comptime testCastEnumToTagType(Small2.Two);
909 testCastEnumTag(Small2.Two);
910 comptime testCastEnumTag(Small2.Two);
910911}
911912
912fn testCastEnumToTagType(value: Small2) void {
913fn testCastEnumTag(value: Small2) void {
913914 expect(@enumToInt(value) == 1);
914915}
915916
......@@ -1163,14 +1164,14 @@ test "enum with comptime_int tag type" {
11631164 Two = 2,
11641165 Three = 1,
11651166 };
1166 comptime expect(@TagType(Enum) == comptime_int);
1167 comptime expect(Tag(Enum) == comptime_int);
11671168}
11681169
11691170test "enum with one member default to u0 tag type" {
11701171 const E0 = enum {
11711172 X,
11721173 };
1173 comptime expect(@TagType(E0) == u0);
1174 comptime expect(Tag(E0) == u0);
11741175}
11751176
11761177test "tagName on enum literals" {
test/stage1/behavior/type_info.zig+1-1
......@@ -14,7 +14,7 @@ test "type info: tag type, void info" {
1414}
1515
1616fn testBasic() void {
17 expect(@TagType(TypeInfo) == TypeId);
17 expect(@typeInfo(TypeInfo).Union.tag_type == TypeId);
1818 const void_info = @typeInfo(void);
1919 expect(void_info == TypeId.Void);
2020 expect(void_info.Void == {});
test/stage1/behavior/union.zig+23-22
......@@ -1,6 +1,7 @@
11const std = @import("std");
22const expect = std.testing.expect;
33const expectEqual = std.testing.expectEqual;
4const Tag = std.meta.Tag;
45
56const Value = union(enum) {
67 Int: u64,
......@@ -128,7 +129,7 @@ const MultipleChoice = union(enum(u32)) {
128129test "simple union(enum(u32))" {
129130 var x = MultipleChoice.C;
130131 expect(x == MultipleChoice.C);
131 expect(@enumToInt(@as(@TagType(MultipleChoice), x)) == 60);
132 expect(@enumToInt(@as(Tag(MultipleChoice), x)) == 60);
132133}
133134
134135const MultipleChoice2 = union(enum(u32)) {
......@@ -144,13 +145,13 @@ const MultipleChoice2 = union(enum(u32)) {
144145};
145146
146147test "union(enum(u32)) with specified and unspecified tag values" {
147 comptime expect(@TagType(@TagType(MultipleChoice2)) == u32);
148 comptime expect(Tag(Tag(MultipleChoice2)) == u32);
148149 testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
149150 comptime testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
150151}
151152
152153fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) void {
153 expect(@enumToInt(@as(@TagType(MultipleChoice2), x)) == 60);
154 expect(@enumToInt(@as(Tag(MultipleChoice2), x)) == 60);
154155 expect(1123 == switch (x) {
155156 MultipleChoice2.A => 1,
156157 MultipleChoice2.B => 2,
......@@ -204,11 +205,11 @@ test "union field access gives the enum values" {
204205}
205206
206207test "cast union to tag type of union" {
207 testCastUnionToTagType(TheUnion{ .B = 1234 });
208 comptime testCastUnionToTagType(TheUnion{ .B = 1234 });
208 testCastUnionToTag(TheUnion{ .B = 1234 });
209 comptime testCastUnionToTag(TheUnion{ .B = 1234 });
209210}
210211
211fn testCastUnionToTagType(x: TheUnion) void {
212fn testCastUnionToTag(x: TheUnion) void {
212213 expect(@as(TheTag, x) == TheTag.B);
213214}
214215
......@@ -298,7 +299,7 @@ const TaggedUnionWithAVoid = union(enum) {
298299
299300fn testTaggedUnionInit(x: anytype) bool {
300301 const y = TaggedUnionWithAVoid{ .A = x };
301 return @as(@TagType(TaggedUnionWithAVoid), y) == TaggedUnionWithAVoid.A;
302 return @as(Tag(TaggedUnionWithAVoid), y) == TaggedUnionWithAVoid.A;
302303}
303304
304305pub const UnionEnumNoPayloads = union(enum) {
......@@ -309,8 +310,8 @@ pub const UnionEnumNoPayloads = union(enum) {
309310test "tagged union with no payloads" {
310311 const a = UnionEnumNoPayloads{ .B = {} };
311312 switch (a) {
312 @TagType(UnionEnumNoPayloads).A => @panic("wrong"),
313 @TagType(UnionEnumNoPayloads).B => {},
313 Tag(UnionEnumNoPayloads).A => @panic("wrong"),
314 Tag(UnionEnumNoPayloads).B => {},
314315 }
315316}
316317
......@@ -325,9 +326,9 @@ test "union with only 1 field casted to its enum type" {
325326 };
326327
327328 var e = Expr{ .Literal = Literal{ .Bool = true } };
328 const Tag = @TagType(Expr);
329 comptime expect(@TagType(Tag) == u0);
330 var t = @as(Tag, e);
329 const ExprTag = Tag(Expr);
330 comptime expect(Tag(ExprTag) == u0);
331 var t = @as(ExprTag, e);
331332 expect(t == Expr.Literal);
332333}
333334
......@@ -337,17 +338,17 @@ test "union with only 1 field casted to its enum type which has enum value speci
337338 Bool: bool,
338339 };
339340
340 const Tag = enum(comptime_int) {
341 const ExprTag = enum(comptime_int) {
341342 Literal = 33,
342343 };
343344
344 const Expr = union(Tag) {
345 const Expr = union(ExprTag) {
345346 Literal: Literal,
346347 };
347348
348349 var e = Expr{ .Literal = Literal{ .Bool = true } };
349 comptime expect(@TagType(Tag) == comptime_int);
350 var t = @as(Tag, e);
350 comptime expect(Tag(ExprTag) == comptime_int);
351 var t = @as(ExprTag, e);
351352 expect(t == Expr.Literal);
352353 expect(@enumToInt(t) == 33);
353354 comptime expect(@enumToInt(t) == 33);
......@@ -501,7 +502,7 @@ test "union with one member defaults to u0 tag type" {
501502 const U0 = union(enum) {
502503 X: u32,
503504 };
504 comptime expect(@TagType(@TagType(U0)) == u0);
505 comptime expect(Tag(Tag(U0)) == u0);
505506}
506507
507508test "union with comptime_int tag" {
......@@ -510,7 +511,7 @@ test "union with comptime_int tag" {
510511 Y: u16,
511512 Z: u8,
512513 };
513 comptime expect(@TagType(@TagType(Union)) == comptime_int);
514 comptime expect(Tag(Tag(Union)) == comptime_int);
514515}
515516
516517test "extern union doesn't trigger field check at comptime" {
......@@ -591,7 +592,7 @@ test "function call result coerces from tagged union to the tag" {
591592 Two: usize,
592593 };
593594
594 const ArchTag = @TagType(Arch);
595 const ArchTag = Tag(Arch);
595596
596597 fn doTheTest() void {
597598 var x: ArchTag = getArch1();
......@@ -696,8 +697,8 @@ test "cast from pointer to anonymous struct to pointer to union" {
696697
697698test "method call on an empty union" {
698699 const S = struct {
699 const MyUnion = union(Tag) {
700 pub const Tag = enum { X1, X2 };
700 const MyUnion = union(MyUnionTag) {
701 pub const MyUnionTag = enum { X1, X2 };
701702 X1: [0]u8,
702703 X2: [0]u8,
703704
......@@ -797,7 +798,7 @@ test "union enum type gets a separate scope" {
797798 };
798799
799800 fn doTheTest() void {
800 expect(!@hasDecl(@TagType(U), "foo"));
801 expect(!@hasDecl(Tag(U), "foo"));
801802 }
802803 };
803804
test/tests.zig+1-1
......@@ -499,7 +499,7 @@ pub fn addPkgTests(
499499 if (skip_single_threaded and test_target.single_threaded)
500500 continue;
501501
502 const ArchTag = @TagType(builtin.Arch);
502 const ArchTag = std.meta.Tag(builtin.Arch);
503503 if (test_target.disable_native and
504504 test_target.target.getOsTag() == std.Target.current.os.tag and
505505 test_target.target.getCpuArch() == std.Target.current.cpu.arch)
tools/process_headers.zig+1-1
......@@ -47,7 +47,7 @@ const MultiAbi = union(enum) {
4747 fn eql(a: MultiAbi, b: MultiAbi) bool {
4848 if (@enumToInt(a) != @enumToInt(b))
4949 return false;
50 if (@TagType(MultiAbi)(a) != .specific)
50 if (std.meta.Tag(MultiAbi)(a) != .specific)
5151 return true;
5252 return a.specific == b.specific;
5353 }