snake_case Node.Tag

author: Veikka Tuominen <git@vexu.eu> 2021-02-12 01:38:10 +0200
committer: Veikka Tuominen <git@vexu.eu> 2021-02-12 02:12:43 +0200
commit: bb22490fcc8ed7c96d665242cd18934f9d547555 (patch)
tree: 5703427c6d2830c87b001fdd8b57fbb63a22a46b /lib/std
parent: e2289961c6b53451e5bdcdfb6eec27e27f6553ca (diff)
download: zig-bb22490fcc8ed7c96d665242cd18934f9d547555.tar.gz
zig-bb22490fcc8ed7c96d665242cd18934f9d547555.zip
3 files changed, 1003 insertions, 1003 deletions
diff --git a/lib/std/zig/ast.zig b/lib/std/zig/ast.zig
index 6a56c0e242..0b6133e789 100644
--- a/lib/std/zig/ast.zig
+++ b/lib/std/zig/ast.zig
@@ -199,148 +199,148 @@ pub const Tree = struct {
         var end_offset: TokenIndex = 0;
         var n = node;
         while (true) switch (tags[n]) {
-            .Root => return 0,
-
-            .UsingNamespace,
-            .TestDecl,
-            .ErrDefer,
-            .Defer,
-            .BoolNot,
-            .Negation,
-            .BitNot,
-            .NegationWrap,
-            .AddressOf,
-            .Try,
-            .Await,
-            .OptionalType,
-            .Switch,
-            .SwitchComma,
-            .IfSimple,
-            .If,
-            .Suspend,
-            .Resume,
-            .Continue,
-            .Break,
-            .Return,
-            .AnyFrameType,
-            .Identifier,
-            .AnyFrameLiteral,
-            .CharLiteral,
-            .IntegerLiteral,
-            .FloatLiteral,
-            .FalseLiteral,
-            .TrueLiteral,
-            .NullLiteral,
-            .UndefinedLiteral,
-            .UnreachableLiteral,
-            .StringLiteral,
-            .GroupedExpression,
-            .BuiltinCallTwo,
-            .BuiltinCallTwoComma,
-            .BuiltinCall,
-            .BuiltinCallComma,
-            .ErrorSetDecl,
-            .AnyType,
-            .Comptime,
-            .Nosuspend,
-            .AsmSimple,
-            .Asm,
-            .FnProtoSimple,
-            .FnProtoMulti,
-            .FnProtoOne,
-            .FnProto,
-            .ArrayType,
-            .ArrayTypeSentinel,
-            .ErrorValue,
+            .root => return 0,
+
+            .@"usingnamespace",
+            .test_decl,
+            .@"errdefer",
+            .@"defer",
+            .bool_not,
+            .negation,
+            .bit_not,
+            .negation_wrap,
+            .address_of,
+            .@"try",
+            .@"await",
+            .optional_type,
+            .@"switch",
+            .switch_comma,
+            .if_simple,
+            .@"if",
+            .@"suspend",
+            .@"resume",
+            .@"continue",
+            .@"break",
+            .@"return",
+            .anyframe_type,
+            .identifier,
+            .anyframe_literal,
+            .char_literal,
+            .integer_literal,
+            .float_literal,
+            .false_literal,
+            .true_literal,
+            .null_literal,
+            .undefined_literal,
+            .unreachable_literal,
+            .string_literal,
+            .grouped_expression,
+            .builtin_call_two,
+            .builtin_call_two_comma,
+            .builtin_call,
+            .builtin_call_comma,
+            .error_set_decl,
+            .@"anytype",
+            .@"comptime",
+            .@"nosuspend",
+            .asm_simple,
+            .@"asm",
+            .fn_proto_simple,
+            .fn_proto_multi,
+            .fn_proto_one,
+            .fn_proto,
+            .array_type,
+            .array_type_sentinel,
+            .error_value,
             => return main_tokens[n] - end_offset,
 
-            .ArrayInitDot,
-            .ArrayInitDotComma,
-            .ArrayInitDotTwo,
-            .ArrayInitDotTwoComma,
-            .StructInitDot,
-            .StructInitDotComma,
-            .StructInitDotTwo,
-            .StructInitDotTwoComma,
-            .EnumLiteral,
+            .array_init_dot,
+            .array_init_dot_comma,
+            .array_init_dot_two,
+            .array_init_dot_two_comma,
+            .struct_init_dot,
+            .struct_init_dot_comma,
+            .struct_init_dot_two,
+            .struct_init_dot_two_comma,
+            .enum_literal,
             => return main_tokens[n] - 1 - end_offset,
 
-            .Catch,
-            .FieldAccess,
-            .UnwrapOptional,
-            .EqualEqual,
-            .BangEqual,
-            .LessThan,
-            .GreaterThan,
-            .LessOrEqual,
-            .GreaterOrEqual,
-            .AssignMul,
-            .AssignDiv,
-            .AssignMod,
-            .AssignAdd,
-            .AssignSub,
-            .AssignBitShiftLeft,
-            .AssignBitShiftRight,
-            .AssignBitAnd,
-            .AssignBitXor,
-            .AssignBitOr,
-            .AssignMulWrap,
-            .AssignAddWrap,
-            .AssignSubWrap,
-            .Assign,
-            .MergeErrorSets,
-            .Mul,
-            .Div,
-            .Mod,
-            .ArrayMult,
-            .MulWrap,
-            .Add,
-            .Sub,
-            .ArrayCat,
-            .AddWrap,
-            .SubWrap,
-            .BitShiftLeft,
-            .BitShiftRight,
-            .BitAnd,
-            .BitXor,
-            .BitOr,
-            .OrElse,
-            .BoolAnd,
-            .BoolOr,
-            .SliceOpen,
-            .Slice,
-            .SliceSentinel,
-            .Deref,
-            .ArrayAccess,
-            .ArrayInitOne,
-            .ArrayInitOneComma,
-            .ArrayInit,
-            .ArrayInitComma,
-            .StructInitOne,
-            .StructInitOneComma,
-            .StructInit,
-            .StructInitComma,
-            .CallOne,
-            .CallOneComma,
-            .Call,
-            .CallComma,
-            .SwitchRange,
-            .FnDecl,
-            .ErrorUnion,
+            .@"catch",
+            .field_access,
+            .unwrap_optional,
+            .equal_equal,
+            .bang_equal,
+            .less_than,
+            .greater_than,
+            .less_or_equal,
+            .greater_or_equal,
+            .assign_mul,
+            .assign_div,
+            .assign_mod,
+            .assign_add,
+            .assign_sub,
+            .assign_bit_shift_left,
+            .assign_bit_shift_right,
+            .assign_bit_and,
+            .assign_bit_xor,
+            .assign_bit_or,
+            .assign_mul_wrap,
+            .assign_add_wrap,
+            .assign_sub_wrap,
+            .assign,
+            .merge_error_sets,
+            .mul,
+            .div,
+            .mod,
+            .array_mult,
+            .mul_wrap,
+            .add,
+            .sub,
+            .array_cat,
+            .add_wrap,
+            .sub_wrap,
+            .bit_shift_left,
+            .bit_shift_right,
+            .bit_and,
+            .bit_xor,
+            .bit_or,
+            .@"orelse",
+            .bool_and,
+            .bool_or,
+            .slice_open,
+            .slice,
+            .slice_sentinel,
+            .deref,
+            .array_access,
+            .array_init_one,
+            .array_init_one_comma,
+            .array_init,
+            .array_init_comma,
+            .struct_init_one,
+            .struct_init_one_comma,
+            .struct_init,
+            .struct_init_comma,
+            .call_one,
+            .call_one_comma,
+            .call,
+            .call_comma,
+            .switch_range,
+            .fn_decl,
+            .error_union,
             => n = datas[n].lhs,
 
-            .AsyncCallOne,
-            .AsyncCallOneComma,
-            .AsyncCall,
-            .AsyncCallComma,
+            .async_call_one,
+            .async_call_one_comma,
+            .async_call,
+            .async_call_comma,
             => {
                 end_offset += 1; // async token
                 n = datas[n].lhs;
             },
 
-            .ContainerFieldInit,
-            .ContainerFieldAlign,
-            .ContainerField,
+            .container_field_init,
+            .container_field_align,
+            .container_field,
             => {
                 const name_token = main_tokens[n];
                 if (name_token > 0 and token_tags[name_token - 1] == .keyword_comptime) {
@@ -349,10 +349,10 @@ pub const Tree = struct {
                 return name_token - end_offset;
             },
 
-            .GlobalVarDecl,
-            .LocalVarDecl,
-            .SimpleVarDecl,
-            .AlignedVarDecl,
+            .global_var_decl,
+            .local_var_decl,
+            .simple_var_decl,
+            .aligned_var_decl,
             => {
                 var i = main_tokens[n]; // mut token
                 while (i > 0) {
@@ -372,10 +372,10 @@ pub const Tree = struct {
                 return i - end_offset;
             },
 
-            .Block,
-            .BlockSemicolon,
-            .BlockTwo,
-            .BlockTwoSemicolon,
+            .block,
+            .block_semicolon,
+            .block_two,
+            .block_two_semicolon,
             => {
                 // Look for a label.
                 const lbrace = main_tokens[n];
@@ -385,18 +385,18 @@ pub const Tree = struct {
                 return lbrace - end_offset;
             },
 
-            .ContainerDecl,
-            .ContainerDeclComma,
-            .ContainerDeclTwo,
-            .ContainerDeclTwoComma,
-            .ContainerDeclArg,
-            .ContainerDeclArgComma,
-            .TaggedUnion,
-            .TaggedUnionComma,
-            .TaggedUnionTwo,
-            .TaggedUnionTwoComma,
-            .TaggedUnionEnumTag,
-            .TaggedUnionEnumTagComma,
+            .container_decl,
+            .container_decl_comma,
+            .container_decl_two,
+            .container_decl_two_comma,
+            .container_decl_arg,
+            .container_decl_arg_comma,
+            .tagged_union,
+            .tagged_union_comma,
+            .tagged_union_two,
+            .tagged_union_two_comma,
+            .tagged_union_enum_tag,
+            .tagged_union_enum_tag_comma,
             => {
                 const main_token = main_tokens[n];
                 switch (token_tags[main_token - 1]) {
@@ -406,10 +406,10 @@ pub const Tree = struct {
                 return main_token - end_offset;
             },
 
-            .PtrTypeAligned,
-            .PtrTypeSentinel,
-            .PtrType,
-            .PtrTypeBitRange,
+            .ptr_type_aligned,
+            .ptr_type_sentinel,
+            .ptr_type,
+            .ptr_type_bit_range,
             => {
                 const main_token = main_tokens[n];
                 return switch (token_tags[main_token]) {
@@ -424,29 +424,29 @@ pub const Tree = struct {
                 } - end_offset;
             },
 
-            .SwitchCaseOne => {
+            .switch_case_one => {
                 if (datas[n].lhs == 0) {
                     return main_tokens[n] - 1 - end_offset; // else token
                 } else {
                     n = datas[n].lhs;
                 }
             },
-            .SwitchCase => {
+            .switch_case => {
                 const extra = tree.extraData(datas[n].lhs, Node.SubRange);
                 assert(extra.end - extra.start > 0);
                 n = extra.start;
             },
 
-            .AsmOutput, .AsmInput => {
+            .asm_output, .asm_input => {
                 assert(token_tags[main_tokens[n] - 1] == .l_bracket);
                 return main_tokens[n] - 1 - end_offset;
             },
 
-            .WhileSimple,
-            .WhileCont,
-            .While,
-            .ForSimple,
-            .For,
+            .while_simple,
+            .while_cont,
+            .@"while",
+            .for_simple,
+            .@"for",
             => {
                 const main_token = main_tokens[n];
                 return switch (token_tags[main_token - 1]) {
@@ -465,115 +465,115 @@ pub const Tree = struct {
         var n = node;
         var end_offset: TokenIndex = 0;
         while (true) switch (tags[n]) {
-            .Root => return @intCast(TokenIndex, tree.tokens.len - 1),
-
-            .UsingNamespace,
-            .BoolNot,
-            .Negation,
-            .BitNot,
-            .NegationWrap,
-            .AddressOf,
-            .Try,
-            .Await,
-            .OptionalType,
-            .Resume,
-            .Nosuspend,
-            .Comptime,
+            .root => return @intCast(TokenIndex, tree.tokens.len - 1),
+
+            .@"usingnamespace",
+            .bool_not,
+            .negation,
+            .bit_not,
+            .negation_wrap,
+            .address_of,
+            .@"try",
+            .@"await",
+            .optional_type,
+            .@"resume",
+            .@"nosuspend",
+            .@"comptime",
             => n = datas[n].lhs,
 
-            .TestDecl,
-            .ErrDefer,
-            .Defer,
-            .Catch,
-            .EqualEqual,
-            .BangEqual,
-            .LessThan,
-            .GreaterThan,
-            .LessOrEqual,
-            .GreaterOrEqual,
-            .AssignMul,
-            .AssignDiv,
-            .AssignMod,
-            .AssignAdd,
-            .AssignSub,
-            .AssignBitShiftLeft,
-            .AssignBitShiftRight,
-            .AssignBitAnd,
-            .AssignBitXor,
-            .AssignBitOr,
-            .AssignMulWrap,
-            .AssignAddWrap,
-            .AssignSubWrap,
-            .Assign,
-            .MergeErrorSets,
-            .Mul,
-            .Div,
-            .Mod,
-            .ArrayMult,
-            .MulWrap,
-            .Add,
-            .Sub,
-            .ArrayCat,
-            .AddWrap,
-            .SubWrap,
-            .BitShiftLeft,
-            .BitShiftRight,
-            .BitAnd,
-            .BitXor,
-            .BitOr,
-            .OrElse,
-            .BoolAnd,
-            .BoolOr,
-            .AnyFrameType,
-            .ErrorUnion,
-            .IfSimple,
-            .WhileSimple,
-            .ForSimple,
-            .FnProtoSimple,
-            .FnProtoMulti,
-            .PtrTypeAligned,
-            .PtrTypeSentinel,
-            .PtrType,
-            .PtrTypeBitRange,
-            .ArrayType,
-            .SwitchCaseOne,
-            .SwitchCase,
-            .SwitchRange,
+            .test_decl,
+            .@"errdefer",
+            .@"defer",
+            .@"catch",
+            .equal_equal,
+            .bang_equal,
+            .less_than,
+            .greater_than,
+            .less_or_equal,
+            .greater_or_equal,
+            .assign_mul,
+            .assign_div,
+            .assign_mod,
+            .assign_add,
+            .assign_sub,
+            .assign_bit_shift_left,
+            .assign_bit_shift_right,
+            .assign_bit_and,
+            .assign_bit_xor,
+            .assign_bit_or,
+            .assign_mul_wrap,
+            .assign_add_wrap,
+            .assign_sub_wrap,
+            .assign,
+            .merge_error_sets,
+            .mul,
+            .div,
+            .mod,
+            .array_mult,
+            .mul_wrap,
+            .add,
+            .sub,
+            .array_cat,
+            .add_wrap,
+            .sub_wrap,
+            .bit_shift_left,
+            .bit_shift_right,
+            .bit_and,
+            .bit_xor,
+            .bit_or,
+            .@"orelse",
+            .bool_and,
+            .bool_or,
+            .anyframe_type,
+            .error_union,
+            .if_simple,
+            .while_simple,
+            .for_simple,
+            .fn_proto_simple,
+            .fn_proto_multi,
+            .ptr_type_aligned,
+            .ptr_type_sentinel,
+            .ptr_type,
+            .ptr_type_bit_range,
+            .array_type,
+            .switch_case_one,
+            .switch_case,
+            .switch_range,
             => n = datas[n].rhs,
 
-            .FieldAccess,
-            .UnwrapOptional,
-            .GroupedExpression,
-            .StringLiteral,
-            .ErrorSetDecl,
-            .AsmSimple,
-            .AsmOutput,
-            .AsmInput,
-            .ErrorValue,
+            .field_access,
+            .unwrap_optional,
+            .grouped_expression,
+            .string_literal,
+            .error_set_decl,
+            .asm_simple,
+            .asm_output,
+            .asm_input,
+            .error_value,
             => return datas[n].rhs + end_offset,
 
-            .AnyType,
-            .AnyFrameLiteral,
-            .CharLiteral,
-            .IntegerLiteral,
-            .FloatLiteral,
-            .FalseLiteral,
-            .TrueLiteral,
-            .NullLiteral,
-            .UndefinedLiteral,
-            .UnreachableLiteral,
-            .Identifier,
-            .Deref,
-            .EnumLiteral,
+            .@"anytype",
+            .anyframe_literal,
+            .char_literal,
+            .integer_literal,
+            .float_literal,
+            .false_literal,
+            .true_literal,
+            .null_literal,
+            .undefined_literal,
+            .unreachable_literal,
+            .identifier,
+            .deref,
+            .enum_literal,
             => return main_tokens[n] + end_offset,
 
-            .Return => if (datas[n].lhs != 0) {
+            .@"return" => if (datas[n].lhs != 0) {
                 n = datas[n].lhs;
             } else {
                 return main_tokens[n] + end_offset;
             },
 
-            .Call, .AsyncCall => {
+            .call, .async_call => {
                 end_offset += 1; // for the rparen
                 const params = tree.extraData(datas[n].rhs, Node.SubRange);
                 if (params.end - params.start == 0) {
@@ -581,7 +581,7 @@ pub const Tree = struct {
                 }
                 n = tree.extra_data[params.end - 1]; // last parameter
             },
-            .TaggedUnionEnumTag => {
+            .tagged_union_enum_tag => {
                 const members = tree.extraData(datas[n].rhs, Node.SubRange);
                 if (members.end - members.start == 0) {
                     end_offset += 4; // for the rparen + rparen + lbrace + rbrace
@@ -591,16 +591,16 @@ pub const Tree = struct {
                     n = tree.extra_data[members.end - 1]; // last parameter
                 }
             },
-            .CallComma,
-            .AsyncCallComma,
-            .TaggedUnionEnumTagComma,
+            .call_comma,
+            .async_call_comma,
+            .tagged_union_enum_tag_comma,
             => {
                 end_offset += 2; // for the comma + rparen/rbrace
                 const params = tree.extraData(datas[n].rhs, Node.SubRange);
                 assert(params.end > params.start);
                 n = tree.extra_data[params.end - 1]; // last parameter
             },
-            .Switch => {
+            .@"switch" => {
                 const cases = tree.extraData(datas[n].rhs, Node.SubRange);
                 if (cases.end - cases.start == 0) {
                     end_offset += 3; // rparen, lbrace, rbrace
@@ -610,7 +610,7 @@ pub const Tree = struct {
                     n = tree.extra_data[cases.end - 1]; // last case
                 }
             },
-            .ContainerDeclArg => {
+            .container_decl_arg => {
                 const members = tree.extraData(datas[n].rhs, Node.SubRange);
                 if (members.end - members.start == 0) {
                     end_offset += 1; // for the rparen
@@ -620,53 +620,53 @@ pub const Tree = struct {
                     n = tree.extra_data[members.end - 1]; // last parameter
                 }
             },
-            .Asm => {
+            .@"asm" => {
                 const extra = tree.extraData(datas[n].rhs, Node.Asm);
                 return extra.rparen + end_offset;
             },
-            .ArrayInit,
-            .StructInit,
+            .array_init,
+            .struct_init,
             => {
                 const elements = tree.extraData(datas[n].rhs, Node.SubRange);
                 assert(elements.end - elements.start > 0);
                 end_offset += 1; // for the rbrace
                 n = tree.extra_data[elements.end - 1]; // last element
             },
-            .ArrayInitComma,
-            .StructInitComma,
-            .ContainerDeclArgComma,
-            .SwitchComma,
+            .array_init_comma,
+            .struct_init_comma,
+            .container_decl_arg_comma,
+            .switch_comma,
             => {
                 const members = tree.extraData(datas[n].rhs, Node.SubRange);
                 assert(members.end - members.start > 0);
                 end_offset += 2; // for the comma + rbrace
                 n = tree.extra_data[members.end - 1]; // last parameter
             },
-            .ArrayInitDot,
-            .StructInitDot,
-            .Block,
-            .ContainerDecl,
-            .TaggedUnion,
-            .BuiltinCall,
+            .array_init_dot,
+            .struct_init_dot,
+            .block,
+            .container_decl,
+            .tagged_union,
+            .builtin_call,
             => {
                 assert(datas[n].rhs - datas[n].lhs > 0);
                 end_offset += 1; // for the rbrace
                 n = tree.extra_data[datas[n].rhs - 1]; // last statement
             },
-            .ArrayInitDotComma,
-            .StructInitDotComma,
-            .BlockSemicolon,
-            .ContainerDeclComma,
-            .TaggedUnionComma,
-            .BuiltinCallComma,
+            .array_init_dot_comma,
+            .struct_init_dot_comma,
+            .block_semicolon,
+            .container_decl_comma,
+            .tagged_union_comma,
+            .builtin_call_comma,
             => {
                 assert(datas[n].rhs - datas[n].lhs > 0);
                 end_offset += 2; // for the comma/semicolon + rbrace/rparen
                 n = tree.extra_data[datas[n].rhs - 1]; // last member
             },
-            .CallOne,
-            .AsyncCallOne,
-            .ArrayAccess,
+            .call_one,
+            .async_call_one,
+            .array_access,
             => {
                 end_offset += 1; // for the rparen/rbracket
                 if (datas[n].rhs == 0) {
@@ -674,12 +674,12 @@ pub const Tree = struct {
                 }
                 n = datas[n].rhs;
             },
-            .ArrayInitDotTwo,
-            .BlockTwo,
-            .BuiltinCallTwo,
-            .StructInitDotTwo,
-            .ContainerDeclTwo,
-            .TaggedUnionTwo,
+            .array_init_dot_two,
+            .block_two,
+            .builtin_call_two,
+            .struct_init_dot_two,
+            .container_decl_two,
+            .tagged_union_two,
             => {
                 if (datas[n].rhs != 0) {
                     end_offset += 1; // for the rparen/rbrace
@@ -689,25 +689,25 @@ pub const Tree = struct {
                     n = datas[n].lhs;
                 } else {
                     switch (tags[n]) {
-                        .ArrayInitDotTwo,
-                        .BlockTwo,
-                        .StructInitDotTwo,
+                        .array_init_dot_two,
+                        .block_two,
+                        .struct_init_dot_two,
                         => end_offset += 1, // rbrace
-                        .BuiltinCallTwo,
-                        .ContainerDeclTwo,
+                        .builtin_call_two,
+                        .container_decl_two,
                         => end_offset += 2, // lparen/lbrace + rparen/rbrace
-                        .TaggedUnionTwo => end_offset += 5, // (enum) {}
+                        .tagged_union_two => end_offset += 5, // (enum) {}
                         else => unreachable,
                     }
                     return main_tokens[n] + end_offset;
                 }
             },
-            .ArrayInitDotTwoComma,
-            .BuiltinCallTwoComma,
-            .BlockTwoSemicolon,
-            .StructInitDotTwoComma,
-            .ContainerDeclTwoComma,
-            .TaggedUnionTwoComma,
+            .array_init_dot_two_comma,
+            .builtin_call_two_comma,
+            .block_two_semicolon,
+            .struct_init_dot_two_comma,
+            .container_decl_two_comma,
+            .tagged_union_two_comma,
             => {
                 end_offset += 2; // for the comma/semicolon + rbrace/rparen
                 if (datas[n].rhs != 0) {
@@ -718,7 +718,7 @@ pub const Tree = struct {
                     unreachable;
                 }
             },
-            .SimpleVarDecl => {
+            .simple_var_decl => {
                 if (datas[n].rhs != 0) {
                     n = datas[n].rhs;
                 } else if (datas[n].lhs != 0) {
@@ -728,7 +728,7 @@ pub const Tree = struct {
                     return main_tokens[n] + end_offset;
                 }
             },
-            .AlignedVarDecl => {
+            .aligned_var_decl => {
                 if (datas[n].rhs != 0) {
                     n = datas[n].rhs;
                 } else if (datas[n].lhs != 0) {
@@ -739,7 +739,7 @@ pub const Tree = struct {
                     return main_tokens[n] + end_offset;
                 }
             },
-            .GlobalVarDecl => {
+            .global_var_decl => {
                 if (datas[n].rhs != 0) {
                     n = datas[n].rhs;
                 } else {
@@ -758,7 +758,7 @@ pub const Tree = struct {
                     }
                 }
             },
-            .LocalVarDecl => {
+            .local_var_decl => {
                 if (datas[n].rhs != 0) {
                     n = datas[n].rhs;
                 } else {
@@ -774,7 +774,7 @@ pub const Tree = struct {
                     }
                 }
             },
-            .ContainerFieldInit => {
+            .container_field_init => {
                 if (datas[n].rhs != 0) {
                     n = datas[n].rhs;
                 } else if (datas[n].lhs != 0) {
@@ -783,7 +783,7 @@ pub const Tree = struct {
                     return main_tokens[n] + end_offset;
                 }
             },
-            .ContainerFieldAlign => {
+            .container_field_align => {
                 if (datas[n].rhs != 0) {
                     end_offset += 1; // for the rparen
                     n = datas[n].rhs;
@@ -793,7 +793,7 @@ pub const Tree = struct {
                     return main_tokens[n] + end_offset;
                 }
             },
-            .ContainerField => {
+            .container_field => {
                 const extra = tree.extraData(datas[n].rhs, Node.ContainerField);
                 if (extra.value_expr != 0) {
                     n = extra.value_expr;
@@ -807,8 +807,8 @@ pub const Tree = struct {
                 }
             },
 
-            .ArrayInitOne,
-            .StructInitOne,
+            .array_init_one,
+            .struct_init_one,
             => {
                 end_offset += 1; // rbrace
                 if (datas[n].rhs == 0) {
@@ -817,37 +817,37 @@ pub const Tree = struct {
                     n = datas[n].rhs;
                 }
             },
-            .SliceOpen,
-            .CallOneComma,
-            .AsyncCallOneComma,
-            .ArrayInitOneComma,
-            .StructInitOneComma,
+            .slice_open,
+            .call_one_comma,
+            .async_call_one_comma,
+            .array_init_one_comma,
+            .struct_init_one_comma,
             => {
                 end_offset += 2; // ellipsis2 + rbracket, or comma + rparen
                 n = datas[n].rhs;
                 assert(n != 0);
             },
-            .Slice => {
+            .slice => {
                 const extra = tree.extraData(datas[n].rhs, Node.Slice);
                 assert(extra.end != 0); // should have used SliceOpen
                 end_offset += 1; // rbracket
                 n = extra.end;
             },
-            .SliceSentinel => {
+            .slice_sentinel => {
                 const extra = tree.extraData(datas[n].rhs, Node.SliceSentinel);
                 assert(extra.sentinel != 0); // should have used Slice
                 end_offset += 1; // rbracket
                 n = extra.sentinel;
             },
 
-            .Continue => {
+            .@"continue" => {
                 if (datas[n].lhs != 0) {
                     return datas[n].lhs + end_offset;
                 } else {
                     return main_tokens[n] + end_offset;
                 }
             },
-            .Break => {
+            .@"break" => {
                 if (datas[n].rhs != 0) {
                     n = datas[n].rhs;
                 } else if (datas[n].lhs != 0) {
@@ -856,14 +856,14 @@ pub const Tree = struct {
                     return main_tokens[n] + end_offset;
                 }
             },
-            .FnDecl => {
+            .fn_decl => {
                 if (datas[n].rhs != 0) {
                     n = datas[n].rhs;
                 } else {
                     n = datas[n].lhs;
                 }
             },
-            .FnProtoOne => {
+            .fn_proto_one => {
                 const extra = tree.extraData(datas[n].lhs, Node.FnProtoOne);
                 // linksection, callconv, align can appear in any order, so we
                 // find the last one here.
@@ -897,7 +897,7 @@ pub const Tree = struct {
                 n = max_node;
                 end_offset += max_offset;
             },
-            .FnProto => {
+            .fn_proto => {
                 const extra = tree.extraData(datas[n].lhs, Node.FnProto);
                 // linksection, callconv, align can appear in any order, so we
                 // find the last one here.
@@ -931,29 +931,29 @@ pub const Tree = struct {
                 n = max_node;
                 end_offset += max_offset;
             },
-            .WhileCont => {
+            .while_cont => {
                 const extra = tree.extraData(datas[n].rhs, Node.WhileCont);
                 assert(extra.then_expr != 0);
                 n = extra.then_expr;
             },
-            .While => {
+            .@"while" => {
                 const extra = tree.extraData(datas[n].rhs, Node.While);
                 assert(extra.else_expr != 0);
                 n = extra.else_expr;
             },
-            .If, .For => {
+            .@"if", .@"for" => {
                 const extra = tree.extraData(datas[n].rhs, Node.If);
                 assert(extra.else_expr != 0);
                 n = extra.else_expr;
             },
-            .Suspend => {
+            .@"suspend" => {
                 if (datas[n].lhs != 0) {
                     n = datas[n].lhs;
                 } else {
                     return main_tokens[n] + end_offset;
                 }
             },
-            .ArrayTypeSentinel => {
+            .array_type_sentinel => {
                 const extra = tree.extraData(datas[n].rhs, Node.ArrayTypeSentinel);
                 n = extra.elem_type;
             },
@@ -967,7 +967,7 @@ pub const Tree = struct {
     }
 
     pub fn globalVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
-        assert(tree.nodes.items(.tag)[node] == .GlobalVarDecl);
+        assert(tree.nodes.items(.tag)[node] == .global_var_decl);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.lhs, Node.GlobalVarDecl);
         return tree.fullVarDecl(.{
@@ -980,7 +980,7 @@ pub const Tree = struct {
     }
 
     pub fn localVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
-        assert(tree.nodes.items(.tag)[node] == .LocalVarDecl);
+        assert(tree.nodes.items(.tag)[node] == .local_var_decl);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.lhs, Node.LocalVarDecl);
         return tree.fullVarDecl(.{
@@ -993,7 +993,7 @@ pub const Tree = struct {
     }
 
     pub fn simpleVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
-        assert(tree.nodes.items(.tag)[node] == .SimpleVarDecl);
+        assert(tree.nodes.items(.tag)[node] == .simple_var_decl);
         const data = tree.nodes.items(.data)[node];
         return tree.fullVarDecl(.{
             .type_node = data.lhs,
@@ -1005,7 +1005,7 @@ pub const Tree = struct {
     }
 
     pub fn alignedVarDecl(tree: Tree, node: Node.Index) full.VarDecl {
-        assert(tree.nodes.items(.tag)[node] == .AlignedVarDecl);
+        assert(tree.nodes.items(.tag)[node] == .aligned_var_decl);
         const data = tree.nodes.items(.data)[node];
         return tree.fullVarDecl(.{
             .type_node = 0,
@@ -1017,7 +1017,7 @@ pub const Tree = struct {
     }
 
     pub fn ifSimple(tree: Tree, node: Node.Index) full.If {
-        assert(tree.nodes.items(.tag)[node] == .IfSimple);
+        assert(tree.nodes.items(.tag)[node] == .if_simple);
         const data = tree.nodes.items(.data)[node];
         return tree.fullIf(.{
             .cond_expr = data.lhs,
@@ -1028,7 +1028,7 @@ pub const Tree = struct {
     }
 
     pub fn ifFull(tree: Tree, node: Node.Index) full.If {
-        assert(tree.nodes.items(.tag)[node] == .If);
+        assert(tree.nodes.items(.tag)[node] == .@"if");
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.rhs, Node.If);
         return tree.fullIf(.{
@@ -1040,7 +1040,7 @@ pub const Tree = struct {
     }
 
     pub fn containerField(tree: Tree, node: Node.Index) full.ContainerField {
-        assert(tree.nodes.items(.tag)[node] == .ContainerField);
+        assert(tree.nodes.items(.tag)[node] == .container_field);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.rhs, Node.ContainerField);
         return tree.fullContainerField(.{
@@ -1052,7 +1052,7 @@ pub const Tree = struct {
     }
 
     pub fn containerFieldInit(tree: Tree, node: Node.Index) full.ContainerField {
-        assert(tree.nodes.items(.tag)[node] == .ContainerFieldInit);
+        assert(tree.nodes.items(.tag)[node] == .container_field_init);
         const data = tree.nodes.items(.data)[node];
         return tree.fullContainerField(.{
             .name_token = tree.nodes.items(.main_token)[node],
@@ -1063,7 +1063,7 @@ pub const Tree = struct {
     }
 
     pub fn containerFieldAlign(tree: Tree, node: Node.Index) full.ContainerField {
-        assert(tree.nodes.items(.tag)[node] == .ContainerFieldAlign);
+        assert(tree.nodes.items(.tag)[node] == .container_field_align);
         const data = tree.nodes.items(.data)[node];
         return tree.fullContainerField(.{
             .name_token = tree.nodes.items(.main_token)[node],
@@ -1074,7 +1074,7 @@ pub const Tree = struct {
     }
 
     pub fn fnProtoSimple(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.FnProto {
-        assert(tree.nodes.items(.tag)[node] == .FnProtoSimple);
+        assert(tree.nodes.items(.tag)[node] == .fn_proto_simple);
         const data = tree.nodes.items(.data)[node];
         buffer[0] = data.lhs;
         const params = if (data.lhs == 0) buffer[0..0] else buffer[0..1];
@@ -1089,7 +1089,7 @@ pub const Tree = struct {
     }
 
     pub fn fnProtoMulti(tree: Tree, node: Node.Index) full.FnProto {
-        assert(tree.nodes.items(.tag)[node] == .FnProtoMulti);
+        assert(tree.nodes.items(.tag)[node] == .fn_proto_multi);
         const data = tree.nodes.items(.data)[node];
         const params_range = tree.extraData(data.lhs, Node.SubRange);
         const params = tree.extra_data[params_range.start..params_range.end];
@@ -1104,7 +1104,7 @@ pub const Tree = struct {
     }
 
     pub fn fnProtoOne(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.FnProto {
-        assert(tree.nodes.items(.tag)[node] == .FnProtoOne);
+        assert(tree.nodes.items(.tag)[node] == .fn_proto_one);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.lhs, Node.FnProtoOne);
         buffer[0] = extra.param;
@@ -1120,7 +1120,7 @@ pub const Tree = struct {
     }
 
     pub fn fnProto(tree: Tree, node: Node.Index) full.FnProto {
-        assert(tree.nodes.items(.tag)[node] == .FnProto);
+        assert(tree.nodes.items(.tag)[node] == .fn_proto);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.lhs, Node.FnProto);
         const params = tree.extra_data[extra.params_start..extra.params_end];
@@ -1135,8 +1135,8 @@ pub const Tree = struct {
     }
 
     pub fn structInitOne(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.StructInit {
-        assert(tree.nodes.items(.tag)[node] == .StructInitOne or
-            tree.nodes.items(.tag)[node] == .StructInitOneComma);
+        assert(tree.nodes.items(.tag)[node] == .struct_init_one or
+            tree.nodes.items(.tag)[node] == .struct_init_one_comma);
         const data = tree.nodes.items(.data)[node];
         buffer[0] = data.rhs;
         const fields = if (data.rhs == 0) buffer[0..0] else buffer[0..1];
@@ -1148,8 +1148,8 @@ pub const Tree = struct {
     }
 
     pub fn structInitDotTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.StructInit {
-        assert(tree.nodes.items(.tag)[node] == .StructInitDotTwo or
-            tree.nodes.items(.tag)[node] == .StructInitDotTwoComma);
+        assert(tree.nodes.items(.tag)[node] == .struct_init_dot_two or
+            tree.nodes.items(.tag)[node] == .struct_init_dot_two_comma);
         const data = tree.nodes.items(.data)[node];
         buffer.* = .{ data.lhs, data.rhs };
         const fields = if (data.rhs != 0)
@@ -1166,8 +1166,8 @@ pub const Tree = struct {
     }
 
     pub fn structInitDot(tree: Tree, node: Node.Index) full.StructInit {
-        assert(tree.nodes.items(.tag)[node] == .StructInitDot or
-            tree.nodes.items(.tag)[node] == .StructInitDotComma);
+        assert(tree.nodes.items(.tag)[node] == .struct_init_dot or
+            tree.nodes.items(.tag)[node] == .struct_init_dot_comma);
         const data = tree.nodes.items(.data)[node];
         return tree.fullStructInit(.{
             .lbrace = tree.nodes.items(.main_token)[node],
@@ -1177,8 +1177,8 @@ pub const Tree = struct {
     }
 
     pub fn structInit(tree: Tree, node: Node.Index) full.StructInit {
-        assert(tree.nodes.items(.tag)[node] == .StructInit or
-            tree.nodes.items(.tag)[node] == .StructInitComma);
+        assert(tree.nodes.items(.tag)[node] == .struct_init or
+            tree.nodes.items(.tag)[node] == .struct_init_comma);
         const data = tree.nodes.items(.data)[node];
         const fields_range = tree.extraData(data.rhs, Node.SubRange);
         return tree.fullStructInit(.{
@@ -1189,8 +1189,8 @@ pub const Tree = struct {
     }
 
     pub fn arrayInitOne(tree: Tree, buffer: *[1]Node.Index, node: Node.Index) full.ArrayInit {
-        assert(tree.nodes.items(.tag)[node] == .ArrayInitOne or
-            tree.nodes.items(.tag)[node] == .ArrayInitOneComma);
+        assert(tree.nodes.items(.tag)[node] == .array_init_one or
+            tree.nodes.items(.tag)[node] == .array_init_one_comma);
         const data = tree.nodes.items(.data)[node];
         buffer[0] = data.rhs;
         const elements = if (data.rhs == 0) buffer[0..0] else buffer[0..1];
@@ -1204,8 +1204,8 @@ pub const Tree = struct {
     }
 
     pub fn arrayInitDotTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.ArrayInit {
-        assert(tree.nodes.items(.tag)[node] == .ArrayInitDotTwo or
-            tree.nodes.items(.tag)[node] == .ArrayInitDotTwoComma);
+        assert(tree.nodes.items(.tag)[node] == .array_init_dot_two or
+            tree.nodes.items(.tag)[node] == .array_init_dot_two_comma);
         const data = tree.nodes.items(.data)[node];
         buffer.* = .{ data.lhs, data.rhs };
         const elements = if (data.rhs != 0)
@@ -1224,8 +1224,8 @@ pub const Tree = struct {
     }
 
     pub fn arrayInitDot(tree: Tree, node: Node.Index) full.ArrayInit {
-        assert(tree.nodes.items(.tag)[node] == .ArrayInitDot or
-            tree.nodes.items(.tag)[node] == .ArrayInitDotComma);
+        assert(tree.nodes.items(.tag)[node] == .array_init_dot or
+            tree.nodes.items(.tag)[node] == .array_init_dot_comma);
         const data = tree.nodes.items(.data)[node];
         return .{
             .ast = .{
@@ -1237,8 +1237,8 @@ pub const Tree = struct {
     }
 
     pub fn arrayInit(tree: Tree, node: Node.Index) full.ArrayInit {
-        assert(tree.nodes.items(.tag)[node] == .ArrayInit or
-            tree.nodes.items(.tag)[node] == .ArrayInitComma);
+        assert(tree.nodes.items(.tag)[node] == .array_init or
+            tree.nodes.items(.tag)[node] == .array_init_comma);
         const data = tree.nodes.items(.data)[node];
         const elem_range = tree.extraData(data.rhs, Node.SubRange);
         return .{
@@ -1251,7 +1251,7 @@ pub const Tree = struct {
     }
 
     pub fn arrayType(tree: Tree, node: Node.Index) full.ArrayType {
-        assert(tree.nodes.items(.tag)[node] == .ArrayType);
+        assert(tree.nodes.items(.tag)[node] == .array_type);
         const data = tree.nodes.items(.data)[node];
         return .{
             .ast = .{
@@ -1264,7 +1264,7 @@ pub const Tree = struct {
     }
 
     pub fn arrayTypeSentinel(tree: Tree, node: Node.Index) full.ArrayType {
-        assert(tree.nodes.items(.tag)[node] == .ArrayTypeSentinel);
+        assert(tree.nodes.items(.tag)[node] == .array_type_sentinel);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.rhs, Node.ArrayTypeSentinel);
         return .{
@@ -1278,7 +1278,7 @@ pub const Tree = struct {
     }
 
     pub fn ptrTypeAligned(tree: Tree, node: Node.Index) full.PtrType {
-        assert(tree.nodes.items(.tag)[node] == .PtrTypeAligned);
+        assert(tree.nodes.items(.tag)[node] == .ptr_type_aligned);
         const data = tree.nodes.items(.data)[node];
         return tree.fullPtrType(.{
             .main_token = tree.nodes.items(.main_token)[node],
@@ -1291,7 +1291,7 @@ pub const Tree = struct {
     }
 
     pub fn ptrTypeSentinel(tree: Tree, node: Node.Index) full.PtrType {
-        assert(tree.nodes.items(.tag)[node] == .PtrTypeSentinel);
+        assert(tree.nodes.items(.tag)[node] == .ptr_type_sentinel);
         const data = tree.nodes.items(.data)[node];
         return tree.fullPtrType(.{
             .main_token = tree.nodes.items(.main_token)[node],
@@ -1304,7 +1304,7 @@ pub const Tree = struct {
     }
 
     pub fn ptrType(tree: Tree, node: Node.Index) full.PtrType {
-        assert(tree.nodes.items(.tag)[node] == .PtrType);
+        assert(tree.nodes.items(.tag)[node] == .ptr_type);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.lhs, Node.PtrType);
         return tree.fullPtrType(.{
@@ -1318,7 +1318,7 @@ pub const Tree = struct {
     }
 
     pub fn ptrTypeBitRange(tree: Tree, node: Node.Index) full.PtrType {
-        assert(tree.nodes.items(.tag)[node] == .PtrTypeBitRange);
+        assert(tree.nodes.items(.tag)[node] == .ptr_type_bit_range);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.lhs, Node.PtrTypeBitRange);
         return tree.fullPtrType(.{
@@ -1332,7 +1332,7 @@ pub const Tree = struct {
     }
 
     pub fn sliceOpen(tree: Tree, node: Node.Index) full.Slice {
-        assert(tree.nodes.items(.tag)[node] == .SliceOpen);
+        assert(tree.nodes.items(.tag)[node] == .slice_open);
         const data = tree.nodes.items(.data)[node];
         return .{
             .ast = .{
@@ -1346,7 +1346,7 @@ pub const Tree = struct {
     }
 
     pub fn slice(tree: Tree, node: Node.Index) full.Slice {
-        assert(tree.nodes.items(.tag)[node] == .Slice);
+        assert(tree.nodes.items(.tag)[node] == .slice);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.rhs, Node.Slice);
         return .{
@@ -1361,7 +1361,7 @@ pub const Tree = struct {
     }
 
     pub fn sliceSentinel(tree: Tree, node: Node.Index) full.Slice {
-        assert(tree.nodes.items(.tag)[node] == .SliceSentinel);
+        assert(tree.nodes.items(.tag)[node] == .slice_sentinel);
         const data = tree.nodes.items(.data)[node];
         const extra = tree.extraData(data.rhs, Node.SliceSentinel);
         return .{
@@ -1376,8 +1376,8 @@ pub const Tree = struct {
     }
 
     pub fn containerDeclTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl {
-        assert(tree.nodes.items(.tag)[node] == .ContainerDeclTwo or
-            tree.nodes.items(.tag)[node] == .ContainerDeclTwoComma);
+        assert(tree.nodes.items(.tag)[node] == .container_decl_two or
+            tree.nodes.items(.tag)[node] == .container_decl_two_comma);
         const data = tree.nodes.items(.data)[node];
         buffer.* = .{ data.lhs, data.rhs };
         const members = if (data.rhs != 0)
@@ -1395,8 +1395,8 @@ pub const Tree = struct {
     }
 
     pub fn containerDecl(tree: Tree, node: Node.Index) full.ContainerDecl {
-        assert(tree.nodes.items(.tag)[node] == .ContainerDecl or
-            tree.nodes.items(.tag)[node] == .ContainerDeclComma);
+        assert(tree.nodes.items(.tag)[node] == .container_decl or
+            tree.nodes.items(.tag)[node] == .container_decl_comma);
         const data = tree.nodes.items(.data)[node];
         return tree.fullContainerDecl(.{
             .main_token = tree.nodes.items(.main_token)[node],
@@ -1407,8 +1407,8 @@ pub const Tree = struct {
     }
 
     pub fn containerDeclArg(tree: Tree, node: Node.Index) full.ContainerDecl {
-        assert(tree.nodes.items(.tag)[node] == .ContainerDeclArg or
-            tree.nodes.items(.tag)[node] == .ContainerDeclArgComma);
+        assert(tree.nodes.items(.tag)[node] == .container_decl_arg or
+            tree.nodes.items(.tag)[node] == .container_decl_arg_comma);
         const data = tree.nodes.items(.data)[node];
         const members_range = tree.extraData(data.rhs, Node.SubRange);
         return tree.fullContainerDecl(.{
@@ -1420,8 +1420,8 @@ pub const Tree = struct {
     }
 
     pub fn taggedUnionTwo(tree: Tree, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl {
-        assert(tree.nodes.items(.tag)[node] == .TaggedUnionTwo or
-            tree.nodes.items(.tag)[node] == .TaggedUnionTwoComma);
+        assert(tree.nodes.items(.tag)[node] == .tagged_union_two or
+            tree.nodes.items(.tag)[node] == .tagged_union_two_comma);
         const data = tree.nodes.items(.data)[node];
         buffer.* = .{ data.lhs, data.rhs };
         const members = if (data.rhs != 0)
@@ -1440,8 +1440,8 @@ pub const Tree = struct {
     }
 
     pub fn taggedUnion(tree: Tree, node: Node.Index) full.ContainerDecl {
-        assert(tree.nodes.items(.tag)[node] == .TaggedUnion or
-            tree.nodes.items(.tag)[node] == .TaggedUnionComma);
+        assert(tree.nodes.items(.tag)[node] == .tagged_union or
+            tree.nodes.items(.tag)[node] == .tagged_union_comma);
         const data = tree.nodes.items(.data)[node];
         const main_token = tree.nodes.items(.main_token)[node];
         return tree.fullContainerDecl(.{
@@ -1453,8 +1453,8 @@ pub const Tree = struct {
     }
 
     pub fn taggedUnionEnumTag(tree: Tree, node: Node.Index) full.ContainerDecl {
-        assert(tree.nodes.items(.tag)[node] == .TaggedUnionEnumTag or
-            tree.nodes.items(.tag)[node] == .TaggedUnionEnumTagComma);
+        assert(tree.nodes.items(.tag)[node] == .tagged_union_enum_tag or
+            tree.nodes.items(.tag)[node] == .tagged_union_enum_tag_comma);
         const data = tree.nodes.items(.data)[node];
         const members_range = tree.extraData(data.rhs, Node.SubRange);
         const main_token = tree.nodes.items(.main_token)[node];
@@ -1765,7 +1765,7 @@ pub const Tree = struct {
         }
         const outputs_end: usize = for (info.items) |item, i| {
             switch (node_tags[item]) {
-                .AsmOutput => continue,
+                .asm_output => continue,
                 else => break i,
             }
         } else info.items.len;
@@ -2162,7 +2162,7 @@ pub const Error = union(enum) {
 
         pub fn render(self: ExpectedCall, tree: Tree, stream: anytype) !void {
             const node_tag = tree.nodes.items(.tag)[self.node];
-            return stream.print("expected " ++ @tagName(Node.Tag.Call) ++ ", found {s}", .{
+            return stream.print("expected " ++ @tagName(Node.Tag.call) ++ ", found {s}", .{
                 @tagName(node_tag),
             });
         }
@@ -2173,8 +2173,8 @@ pub const Error = union(enum) {
 
         pub fn render(self: ExpectedCallOrFnProto, tree: Tree, stream: anytype) !void {
             const node_tag = tree.nodes.items(.tag)[self.node];
-            return stream.print("expected " ++ @tagName(Node.Tag.Call) ++ " or " ++
-                @tagName(Node.Tag.FnProto) ++ ", found {s}", .{@tagName(node_tag)});
+            return stream.print("expected " ++ @tagName(Node.Tag.call) ++ " or " ++
+                @tagName(Node.Tag.fn_proto) ++ ", found {s}", .{@tagName(node_tag)});
         }
     };
 
@@ -2305,433 +2305,433 @@ pub const Node = struct {
     /// Tree.lastToken()
     pub const Tag = enum {
         /// sub_list[lhs...rhs]
-        Root,
+        root,
         /// `usingnamespace lhs;`. rhs unused. main_token is `usingnamespace`.
-        UsingNamespace,
+        @"usingnamespace",
         /// lhs is test name token (must be string literal), if any.
         /// rhs is the body node.
-        TestDecl,
+        test_decl,
         /// lhs is the index into extra_data.
         /// rhs is the initialization expression, if any.
         /// main_token is `var` or `const`.
-        GlobalVarDecl,
+        global_var_decl,
         /// `var a: x align(y) = rhs`
         /// lhs is the index into extra_data.
         /// main_token is `var` or `const`.
-        LocalVarDecl,
+        local_var_decl,
         /// `var a: lhs = rhs`. lhs and rhs may be unused.
         /// Can be local or global.
         /// main_token is `var` or `const`.
-        SimpleVarDecl,
+        simple_var_decl,
         /// `var a align(lhs) = rhs`. lhs and rhs may be unused.
         /// Can be local or global.
         /// main_token is `var` or `const`.
-        AlignedVarDecl,
+        aligned_var_decl,
         /// lhs is the identifier token payload if any,
         /// rhs is the deferred expression.
-        ErrDefer,
+        @"errdefer",
         /// lhs is unused.
         /// rhs is the deferred expression.
-        Defer,
+        @"defer",
         /// lhs catch rhs
         /// lhs catch |err| rhs
         /// main_token is the catch
         /// payload is determined by looking at the prev tokens before rhs.
-        Catch,
+        @"catch",
         /// `lhs.a`. main_token is the dot. rhs is the identifier token index.
-        FieldAccess,
+        field_access,
         /// `lhs.?`. main_token is the dot. rhs is the `?` token index.
-        UnwrapOptional,
+        unwrap_optional,
         /// `lhs == rhs`. main_token is op.
-        EqualEqual,
+        equal_equal,
         /// `lhs != rhs`. main_token is op.
-        BangEqual,
+        bang_equal,
         /// `lhs < rhs`. main_token is op.
-        LessThan,
+        less_than,
         /// `lhs > rhs`. main_token is op.
-        GreaterThan,
+        greater_than,
         /// `lhs <= rhs`. main_token is op.
-        LessOrEqual,
+        less_or_equal,
         /// `lhs >= rhs`. main_token is op.
-        GreaterOrEqual,
+        greater_or_equal,
         /// `lhs *= rhs`. main_token is op.
-        AssignMul,
+        assign_mul,
         /// `lhs /= rhs`. main_token is op.
-        AssignDiv,
+        assign_div,
         /// `lhs *= rhs`. main_token is op.
-        AssignMod,
+        assign_mod,
         /// `lhs += rhs`. main_token is op.
-        AssignAdd,
+        assign_add,
         /// `lhs -= rhs`. main_token is op.
-        AssignSub,
+        assign_sub,
         /// `lhs <<= rhs`. main_token is op.
-        AssignBitShiftLeft,
+        assign_bit_shift_left,
         /// `lhs >>= rhs`. main_token is op.
-        AssignBitShiftRight,
+        assign_bit_shift_right,
         /// `lhs &= rhs`. main_token is op.
-        AssignBitAnd,
+        assign_bit_and,
         /// `lhs ^= rhs`. main_token is op.
-        AssignBitXor,
+        assign_bit_xor,
         /// `lhs |= rhs`. main_token is op.
-        AssignBitOr,
+        assign_bit_or,
         /// `lhs *%= rhs`. main_token is op.
-        AssignMulWrap,
+        assign_mul_wrap,
         /// `lhs +%= rhs`. main_token is op.
-        AssignAddWrap,
+        assign_add_wrap,
         /// `lhs -%= rhs`. main_token is op.
-        AssignSubWrap,
+        assign_sub_wrap,
         /// `lhs = rhs`. main_token is op.
-        Assign,
+        assign,
         /// `lhs || rhs`. main_token is the `||`.
-        MergeErrorSets,
+        merge_error_sets,
         /// `lhs * rhs`. main_token is the `*`.
-        Mul,
+        mul,
         /// `lhs / rhs`. main_token is the `/`.
-        Div,
+        div,
         /// `lhs % rhs`. main_token is the `%`.
-        Mod,
+        mod,
         /// `lhs ** rhs`. main_token is the `**`.
-        ArrayMult,
+        array_mult,
         /// `lhs *% rhs`. main_token is the `*%`.
-        MulWrap,
+        mul_wrap,
         /// `lhs + rhs`. main_token is the `+`.
-        Add,
+        add,
         /// `lhs - rhs`. main_token is the `-`.
-        Sub,
+        sub,
         /// `lhs ++ rhs`. main_token is the `++`.
-        ArrayCat,
+        array_cat,
         /// `lhs +% rhs`. main_token is the `+%`.
-        AddWrap,
+        add_wrap,
         /// `lhs -% rhs`. main_token is the `-%`.
-        SubWrap,
+        sub_wrap,
         /// `lhs << rhs`. main_token is the `<<`.
-        BitShiftLeft,
+        bit_shift_left,
         /// `lhs >> rhs`. main_token is the `>>`.
-        BitShiftRight,
+        bit_shift_right,
         /// `lhs & rhs`. main_token is the `&`.
-        BitAnd,
+        bit_and,
         /// `lhs ^ rhs`. main_token is the `^`.
-        BitXor,
+        bit_xor,
         /// `lhs | rhs`. main_token is the `|`.
-        BitOr,
+        bit_or,
         /// `lhs orelse rhs`. main_token is the `orelse`.
-        OrElse,
+        @"orelse",
         /// `lhs and rhs`. main_token is the `and`.
-        BoolAnd,
+        bool_and,
         /// `lhs or rhs`. main_token is the `or`.
-        BoolOr,
+        bool_or,
         /// `op lhs`. rhs unused. main_token is op.
-        BoolNot,
+        bool_not,
         /// `op lhs`. rhs unused. main_token is op.
-        Negation,
+        negation,
         /// `op lhs`. rhs unused. main_token is op.
-        BitNot,
+        bit_not,
         /// `op lhs`. rhs unused. main_token is op.
-        NegationWrap,
+        negation_wrap,
         /// `op lhs`. rhs unused. main_token is op.
-        AddressOf,
+        address_of,
         /// `op lhs`. rhs unused. main_token is op.
-        Try,
+        @"try",
         /// `op lhs`. rhs unused. main_token is op.
-        Await,
+        @"await",
         /// `?lhs`. rhs unused. main_token is the `?`.
-        OptionalType,
+        optional_type,
         /// `[lhs]rhs`. lhs can be omitted to make it a slice.
-        ArrayType,
-        /// `[lhs:a]b`. `ArrayTypeSentinel[rhs]`.
-        ArrayTypeSentinel,
+        array_type,
+        /// `[lhs:a]b`. `array_type_sentinel[rhs]`.
+        array_type_sentinel,
         /// `[*]align(lhs) rhs`. lhs can be omitted.
         /// `*align(lhs) rhs`. lhs can be omitted.
         /// `[]rhs`.
         /// main_token is the asterisk if a pointer or the lbracket if a slice
         /// main_token might be a ** token, which is shared with a parent/child
         /// pointer type and may require special handling.
-        PtrTypeAligned,
+        ptr_type_aligned,
         /// `[*:lhs]rhs`. lhs can be omitted.
         /// `*rhs`.
         /// `[:lhs]rhs`.
         /// main_token is the asterisk if a pointer or the lbracket if a slice
         /// main_token might be a ** token, which is shared with a parent/child
         /// pointer type and may require special handling.
-        PtrTypeSentinel,
-        /// lhs is index into PtrType. rhs is the element type expression.
+        ptr_type_sentinel,
+        /// lhs is index into ptr_type. rhs is the element type expression.
         /// main_token is the asterisk if a pointer or the lbracket if a slice
         /// main_token might be a ** token, which is shared with a parent/child
         /// pointer type and may require special handling.
-        PtrType,
-        /// lhs is index into PtrTypeBitRange. rhs is the element type expression.
+        ptr_type,
+        /// lhs is index into ptr_type_bit_range. rhs is the element type expression.
         /// main_token is the asterisk if a pointer or the lbracket if a slice
         /// main_token might be a ** token, which is shared with a parent/child
         /// pointer type and may require special handling.
-        PtrTypeBitRange,
+        ptr_type_bit_range,
         /// `lhs[rhs..]`
         /// main_token is the lbracket.
-        SliceOpen,
+        slice_open,
         /// `lhs[b..c]`. rhs is index into Slice
         /// main_token is the lbracket.
-        Slice,
+        slice,
         /// `lhs[b..c :d]`. rhs is index into SliceSentinel
         /// main_token is the lbracket.
-        SliceSentinel,
+        slice_sentinel,
         /// `lhs.*`. rhs is unused.
-        Deref,
+        deref,
         /// `lhs[rhs]`.
-        ArrayAccess,
+        array_access,
         /// `lhs{rhs}`. rhs can be omitted.
-        ArrayInitOne,
+        array_init_one,
         /// `lhs{rhs,}`. rhs can *not* be omitted
-        ArrayInitOneComma,
+        array_init_one_comma,
         /// `.{lhs, rhs}`. lhs and rhs can be omitted.
-        ArrayInitDotTwo,
-        /// Same as `ArrayInitDotTwo` except there is known to be a trailing comma
+        array_init_dot_two,
+        /// Same as `array_init_dot_two` except there is known to be a trailing comma
         /// before the final rbrace.
-        ArrayInitDotTwoComma,
+        array_init_dot_two_comma,
         /// `.{a, b}`. `sub_list[lhs..rhs]`.
-        ArrayInitDot,
-        /// Same as `ArrayInitDot` except there is known to be a trailing comma
+        array_init_dot,
+        /// Same as `array_init_dot` except there is known to be a trailing comma
         /// before the final rbrace.
-        ArrayInitDotComma,
+        array_init_dot_comma,
         /// `lhs{a, b}`. `sub_range_list[rhs]`. lhs can be omitted which means `.{a, b}`.
-        ArrayInit,
-        /// Same as `ArrayInit` except there is known to be a trailing comma
+        array_init,
+        /// Same as `array_init` except there is known to be a trailing comma
         /// before the final rbrace.
-        ArrayInitComma,
+        array_init_comma,
         /// `lhs{.a = rhs}`. rhs can be omitted making it empty.
         /// main_token is the lbrace.
-        StructInitOne,
+        struct_init_one,
         /// `lhs{.a = rhs,}`. rhs can *not* be omitted.
         /// main_token is the lbrace.
-        StructInitOneComma,
+        struct_init_one_comma,
         /// `.{.a = lhs, .b = rhs}`. lhs and rhs can be omitted.
         /// main_token is the lbrace.
         /// No trailing comma before the rbrace.
-        StructInitDotTwo,
-        /// Same as `StructInitDotTwo` except there is known to be a trailing comma
+        struct_init_dot_two,
+        /// Same as `struct_init_dot_two` except there is known to be a trailing comma
         /// before the final rbrace.
-        StructInitDotTwoComma,
+        struct_init_dot_two_comma,
         /// `.{.a = b, .c = d}`. `sub_list[lhs..rhs]`.
         /// main_token is the lbrace.
-        StructInitDot,
-        /// Same as `StructInitDot` except there is known to be a trailing comma
+        struct_init_dot,
+        /// Same as `struct_init_dot` except there is known to be a trailing comma
         /// before the final rbrace.
-        StructInitDotComma,
+        struct_init_dot_comma,
         /// `lhs{.a = b, .c = d}`. `sub_range_list[rhs]`.
         /// lhs can be omitted which means `.{.a = b, .c = d}`.
         /// main_token is the lbrace.
-        StructInit,
-        /// Same as `StructInit` except there is known to be a trailing comma
+        struct_init,
+        /// Same as `struct_init` except there is known to be a trailing comma
         /// before the final rbrace.
-        StructInitComma,
+        struct_init_comma,
         /// `lhs(rhs)`. rhs can be omitted.
-        CallOne,
+        call_one,
         /// `lhs(rhs,)`. rhs can be omitted.
-        CallOneComma,
+        call_one_comma,
         /// `async lhs(rhs)`. rhs can be omitted.
-        AsyncCallOne,
+        async_call_one,
         /// `async lhs(rhs,)`.
-        AsyncCallOneComma,
+        async_call_one_comma,
         /// `lhs(a, b, c)`. `SubRange[rhs]`.
         /// main_token is the `(`.
-        Call,
+        call,
         /// `lhs(a, b, c,)`. `SubRange[rhs]`.
         /// main_token is the `(`.
-        CallComma,
+        call_comma,
         /// `async lhs(a, b, c)`. `SubRange[rhs]`.
         /// main_token is the `(`.
-        AsyncCall,
+        async_call,
         /// `async lhs(a, b, c,)`. `SubRange[rhs]`.
         /// main_token is the `(`.
-        AsyncCallComma,
+        async_call_comma,
         /// `switch(lhs) {}`. `SubRange[rhs]`.
-        Switch,
-        /// Same as Switch except there is known to be a trailing comma
+        @"switch",
+        /// Same as switch except there is known to be a trailing comma
         /// before the final rbrace
-        SwitchComma,
+        switch_comma,
         /// `lhs => rhs`. If lhs is omitted it means `else`.
         /// main_token is the `=>`
-        SwitchCaseOne,
+        switch_case_one,
         /// `a, b, c => rhs`. `SubRange[lhs]`.
         /// main_token is the `=>`
-        SwitchCase,
+        switch_case,
         /// `lhs...rhs`.
-        SwitchRange,
+        switch_range,
         /// `while (lhs) rhs`.
         /// `while (lhs) |x| rhs`.
-        WhileSimple,
+        while_simple,
         /// `while (lhs) : (a) b`. `WhileCont[rhs]`.
         /// `while (lhs) : (a) b`. `WhileCont[rhs]`.
-        WhileCont,
+        while_cont,
         /// `while (lhs) : (a) b else c`. `While[rhs]`.
         /// `while (lhs) |x| : (a) b else c`. `While[rhs]`.
         /// `while (lhs) |x| : (a) b else |y| c`. `While[rhs]`.
-        While,
+        @"while",
         /// `for (lhs) rhs`.
-        ForSimple,
+        for_simple,
         /// `for (lhs) a else b`. `if_list[rhs]`.
-        For,
+        @"for",
         /// `if (lhs) rhs`.
         /// `if (lhs) |a| rhs`.
-        IfSimple,
+        if_simple,
         /// `if (lhs) a else b`. `If[rhs]`.
         /// `if (lhs) |x| a else b`. `If[rhs]`.
         /// `if (lhs) |x| a else |y| b`. `If[rhs]`.
-        If,
+        @"if",
         /// `suspend lhs`. lhs can be omitted. rhs is unused.
-        Suspend,
+        @"suspend",
         /// `resume lhs`. rhs is unused.
-        Resume,
+        @"resume",
         /// `continue`. lhs is token index of label if any. rhs is unused.
-        Continue,
+        @"continue",
         /// `break :lhs rhs`
         /// both lhs and rhs may be omitted.
-        Break,
+        @"break",
         /// `return lhs`. lhs can be omitted. rhs is unused.
-        Return,
+        @"return",
         /// `fn(a: lhs) rhs`. lhs can be omitted.
         /// anytype and ... parameters are omitted from the AST tree.
-        FnProtoSimple,
+        fn_proto_simple,
         /// `fn(a: b, c: d) rhs`. `sub_range_list[lhs]`.
         /// anytype and ... parameters are omitted from the AST tree.
-        FnProtoMulti,
+        fn_proto_multi,
         /// `fn(a: b) rhs linksection(e) callconv(f)`. `FnProtoOne[lhs]`.
         /// zero or one parameters.
         /// anytype and ... parameters are omitted from the AST tree.
-        FnProtoOne,
+        fn_proto_one,
         /// `fn(a: b, c: d) rhs linksection(e) callconv(f)`. `FnProto[lhs]`.
         /// anytype and ... parameters are omitted from the AST tree.
-        FnProto,
-        /// lhs is the FnProto.
+        fn_proto,
+        /// lhs is the fn_proto.
         /// rhs is the function body block if non-zero.
-        /// if rhs is zero, the funtion decl has no body (e.g. an extern function)
-        FnDecl,
+        /// if rhs is zero, the function decl has no body (e.g. an extern function)
+        fn_decl,
         /// `anyframe->rhs`. main_token is `anyframe`. `lhs` is arrow token index.
-        AnyFrameType,
+        anyframe_type,
         /// Both lhs and rhs unused.
-        AnyFrameLiteral,
+        anyframe_literal,
         /// Both lhs and rhs unused.
-        CharLiteral,
+        char_literal,
         /// Both lhs and rhs unused.
-        IntegerLiteral,
+        integer_literal,
         /// Both lhs and rhs unused.
-        FloatLiteral,
+        float_literal,
         /// Both lhs and rhs unused.
-        FalseLiteral,
+        false_literal,
         /// Both lhs and rhs unused.
-        TrueLiteral,
+        true_literal,
         /// Both lhs and rhs unused.
-        NullLiteral,
+        null_literal,
         /// Both lhs and rhs unused.
-        UndefinedLiteral,
+        undefined_literal,
         /// Both lhs and rhs unused.
-        UnreachableLiteral,
+        unreachable_literal,
         /// Both lhs and rhs unused.
         /// Most identifiers will not have explicit AST nodes, however for expressions
         /// which could be one of many different kinds of AST nodes, there will be an
-        /// Identifier AST node for it.
-        Identifier,
+        /// identifier AST node for it.
+        identifier,
         /// lhs is the dot token index, rhs unused, main_token is the identifier.
-        EnumLiteral,
+        enum_literal,
         /// main_token is the first token index (redundant with lhs)
         /// lhs is the first token index; rhs is the last token index.
-        /// Could be a series of MultilineStringLiteralLine tokens, or a single
-        /// StringLiteral token.
-        StringLiteral,
+        /// Could be a series of multiline_string_literal_line tokens, or a single
+        /// string_literal token.
+        string_literal,
         /// `(lhs)`. main_token is the `(`; rhs is the token index of the `)`.
-        GroupedExpression,
+        grouped_expression,
         /// `@a(lhs, rhs)`. lhs and rhs may be omitted.
-        BuiltinCallTwo,
-        /// Same as BuiltinCallTwo but there is known to be a trailing comma before the rparen.
-        BuiltinCallTwoComma,
+        builtin_call_two,
+        /// Same as builtin_call_two but there is known to be a trailing comma before the rparen.
+        builtin_call_two_comma,
         /// `@a(b, c)`. `sub_list[lhs..rhs]`.
-        BuiltinCall,
-        /// Same as BuiltinCall but there is known to be a trailing comma before the rparen.
-        BuiltinCallComma,
+        builtin_call,
+        /// Same as builtin_call but there is known to be a trailing comma before the rparen.
+        builtin_call_comma,
         /// `error{a, b}`.
         /// rhs is the rbrace, lhs is unused.
-        ErrorSetDecl,
+        error_set_decl,
         /// `struct {}`, `union {}`, `opaque {}`, `enum {}`. `extra_data[lhs..rhs]`.
         /// main_token is `struct`, `union`, `opaque`, `enum` keyword.
-        ContainerDecl,
+        container_decl,
         /// Same as ContainerDecl but there is known to be a trailing comma before the rbrace.
-        ContainerDeclComma,
+        container_decl_comma,
         /// `struct {lhs, rhs}`, `union {lhs, rhs}`, `opaque {lhs, rhs}`, `enum {lhs, rhs}`.
         /// lhs or rhs can be omitted.
         /// main_token is `struct`, `union`, `opaque`, `enum` keyword.
-        ContainerDeclTwo,
+        container_decl_two,
         /// Same as ContainerDeclTwo except there is known to be a trailing comma
         /// before the rbrace.
-        ContainerDeclTwoComma,
+        container_decl_two_comma,
         /// `union(lhs)` / `enum(lhs)`. `SubRange[rhs]`.
-        ContainerDeclArg,
-        /// Same as ContainerDeclArg but there is known to be a trailing comma before the rbrace.
-        ContainerDeclArgComma,
+        container_decl_arg,
+        /// Same as container_decl_arg but there is known to be a trailing comma before the rbrace.
+        container_decl_arg_comma,
         /// `union(enum) {}`. `sub_list[lhs..rhs]`.
         /// Note that tagged unions with explicitly provided enums are represented
-        /// by `ContainerDeclArg`.
-        TaggedUnion,
-        /// Same as TaggedUnion but there is known to be a trailing comma before the rbrace.
-        TaggedUnionComma,
+        /// by `container_decl_arg`.
+        tagged_union,
+        /// Same as tagged_union but there is known to be a trailing comma before the rbrace.
+        tagged_union_comma,
         /// `union(enum) {lhs, rhs}`. lhs or rhs may be omitted.
         /// Note that tagged unions with explicitly provided enums are represented
-        /// by `ContainerDeclArg`.
-        TaggedUnionTwo,
-        /// Same as TaggedUnionTwo but there is known to be a trailing comma before the rbrace.
-        TaggedUnionTwoComma,
+        /// by `container_decl_arg`.
+        tagged_union_two,
+        /// Same as tagged_union_two but there is known to be a trailing comma before the rbrace.
+        tagged_union_two_comma,
         /// `union(enum(lhs)) {}`. `SubRange[rhs]`.
-        TaggedUnionEnumTag,
-        /// Same as TaggedUnionEnumTag but there is known to be a trailing comma
+        tagged_union_enum_tag,
+        /// Same as tagged_union_enum_tag but there is known to be a trailing comma
         /// before the rbrace.
-        TaggedUnionEnumTagComma,
+        tagged_union_enum_tag_comma,
         /// `a: lhs = rhs,`. lhs and rhs can be omitted.
         /// main_token is the field name identifier.
         /// lastToken() does not include the possible trailing comma.
-        ContainerFieldInit,
+        container_field_init,
         /// `a: lhs align(rhs),`. rhs can be omitted.
         /// main_token is the field name identifier.
         /// lastToken() does not include the possible trailing comma.
-        ContainerFieldAlign,
+        container_field_align,
         /// `a: lhs align(c) = d,`. `container_field_list[rhs]`.
         /// main_token is the field name identifier.
         /// lastToken() does not include the possible trailing comma.
-        ContainerField,
+        container_field,
         /// `anytype`. both lhs and rhs unused.
         /// Used by `ContainerField`.
-        AnyType,
+        @"anytype",
         /// `comptime lhs`. rhs unused.
-        Comptime,
+        @"comptime",
         /// `nosuspend lhs`. rhs unused.
-        Nosuspend,
+        @"nosuspend",
         /// `{lhs rhs}`. rhs or lhs can be omitted.
         /// main_token points at the lbrace.
-        BlockTwo,
-        /// Same as BlockTwo but there is known to be a semicolon before the rbrace.
-        BlockTwoSemicolon,
+        block_two,
+        /// Same as block_two but there is known to be a semicolon before the rbrace.
+        block_two_semicolon,
         /// `{}`. `sub_list[lhs..rhs]`.
         /// main_token points at the lbrace.
-        Block,
-        /// Same as Block but there is known to be a semicolon before the rbrace.
-        BlockSemicolon,
+        block,
+        /// Same as block but there is known to be a semicolon before the rbrace.
+        block_semicolon,
         /// `asm(lhs)`. rhs is the token index of the rparen.
-        AsmSimple,
+        asm_simple,
         /// `asm(lhs, a)`. `Asm[rhs]`.
-        Asm,
+        @"asm",
         /// `[a] "b" (c)`. lhs is 0, rhs is token index of the rparen.
         /// `[a] "b" (-> lhs)`. rhs is token index of the rparen.
         /// main_token is `a`.
-        AsmOutput,
+        asm_output,
         /// `[a] "b" (lhs)`. rhs is token index of the rparen.
         /// main_token is `a`.
-        AsmInput,
+        asm_input,
         /// `error.a`. lhs is token index of `.`. rhs is token index of `a`.
-        ErrorValue,
+        error_value,
         /// `lhs!rhs`. main_token is the `!`.
-        ErrorUnion,
+        error_union,
 
         pub fn isContainerField(tag: Tag) bool {
             return switch (tag) {
-                .ContainerFieldInit,
-                .ContainerFieldAlign,
-                .ContainerField,
+                .container_field_init,
+                .container_field_align,
+                .container_field,
                 => true,
 
                 else => false,
diff --git a/lib/std/zig/parse.zig b/lib/std/zig/parse.zig
index 855f889794..6eb617910c 100644
--- a/lib/std/zig/parse.zig
+++ b/lib/std/zig/parse.zig
@@ -57,7 +57,7 @@ pub fn parse(gpa: *Allocator, source: []const u8) Allocator.Error!Tree {
     // Root node must be index 0.
     // Root <- skip ContainerMembers eof
     parser.nodes.appendAssumeCapacity(.{
-        .tag = .Root,
+        .tag = .root,
         .main_token = 0,
         .data = .{
             .lhs = undefined,
@@ -251,7 +251,7 @@ const Parser = struct {
                         };
                         if (block != 0) {
                             const comptime_node = try p.addNode(.{
-                                .tag = .Comptime,
+                                .tag = .@"comptime",
                                 .main_token = comptime_token,
                                 .data = .{
                                     .lhs = block,
@@ -477,7 +477,7 @@ const Parser = struct {
         const block_node = try p.parseBlock();
         if (block_node == 0) return p.fail(.{ .ExpectedLBrace = .{ .token = p.tok_i } });
         return p.addNode(.{
-            .tag = .TestDecl,
+            .tag = .test_decl,
             .main_token = test_token,
             .data = .{
                 .lhs = name_token orelse 0,
@@ -517,7 +517,7 @@ const Parser = struct {
                     const semicolon_token = p.nextToken();
                     try p.parseAppendedDocComment(semicolon_token);
                     return p.addNode(.{
-                        .tag = .FnDecl,
+                        .tag = .fn_decl,
                         .main_token = p.nodes.items(.main_token)[fn_proto],
                         .data = .{
                             .lhs = fn_proto,
@@ -529,7 +529,7 @@ const Parser = struct {
                     const body_block = try p.parseBlock();
                     assert(body_block != 0);
                     return p.addNode(.{
-                        .tag = .FnDecl,
+                        .tag = .fn_decl,
                         .main_token = p.nodes.items(.main_token)[fn_proto],
                         .data = .{
                             .lhs = fn_proto,
@@ -587,7 +587,7 @@ const Parser = struct {
         const semicolon_token = try p.expectToken(.semicolon);
         try p.parseAppendedDocComment(semicolon_token);
         return p.addNode(.{
-            .tag = .UsingNamespace,
+            .tag = .@"usingnamespace",
             .main_token = usingnamespace_token,
             .data = .{
                 .lhs = expr,
@@ -627,7 +627,7 @@ const Parser = struct {
         if (align_expr == 0 and section_expr == 0 and callconv_expr == 0) {
             switch (params) {
                 .zero_or_one => |param| return p.addNode(.{
-                    .tag = .FnProtoSimple,
+                    .tag = .fn_proto_simple,
                     .main_token = fn_token,
                     .data = .{
                         .lhs = param,
@@ -637,7 +637,7 @@ const Parser = struct {
                 .multi => |list| {
                     const span = try p.listToSpan(list);
                     return p.addNode(.{
-                        .tag = .FnProtoMulti,
+                        .tag = .fn_proto_multi,
                         .main_token = fn_token,
                         .data = .{
                             .lhs = try p.addExtra(Node.SubRange{
@@ -652,7 +652,7 @@ const Parser = struct {
         }
         switch (params) {
             .zero_or_one => |param| return p.addNode(.{
-                .tag = .FnProtoOne,
+                .tag = .fn_proto_one,
                 .main_token = fn_token,
                 .data = .{
                     .lhs = try p.addExtra(Node.FnProtoOne{
@@ -667,7 +667,7 @@ const Parser = struct {
             .multi => |list| {
                 const span = try p.listToSpan(list);
                 return p.addNode(.{
-                    .tag = .FnProto,
+                    .tag = .fn_proto,
                     .main_token = fn_token,
                     .data = .{
                         .lhs = try p.addExtra(Node.FnProto{
@@ -698,7 +698,7 @@ const Parser = struct {
         if (section_node == 0) {
             if (align_node == 0) {
                 return p.addNode(.{
-                    .tag = .SimpleVarDecl,
+                    .tag = .simple_var_decl,
                     .main_token = mut_token,
                     .data = .{
                         .lhs = type_node,
@@ -707,7 +707,7 @@ const Parser = struct {
                 });
             } else if (type_node == 0) {
                 return p.addNode(.{
-                    .tag = .AlignedVarDecl,
+                    .tag = .aligned_var_decl,
                     .main_token = mut_token,
                     .data = .{
                         .lhs = align_node,
@@ -716,7 +716,7 @@ const Parser = struct {
                 });
             } else {
                 return p.addNode(.{
-                    .tag = .LocalVarDecl,
+                    .tag = .local_var_decl,
                     .main_token = mut_token,
                     .data = .{
                         .lhs = try p.addExtra(Node.LocalVarDecl{
@@ -729,7 +729,7 @@ const Parser = struct {
             }
         } else {
             return p.addNode(.{
-                .tag = .GlobalVarDecl,
+                .tag = .global_var_decl,
                 .main_token = mut_token,
                 .data = .{
                     .lhs = try p.addExtra(Node.GlobalVarDecl{
@@ -753,7 +753,7 @@ const Parser = struct {
         if (p.eatToken(.colon)) |_| {
             if (p.eatToken(.keyword_anytype)) |anytype_tok| {
                 type_expr = try p.addNode(.{
-                    .tag = .AnyType,
+                    .tag = .@"anytype",
                     .main_token = anytype_tok,
                     .data = .{
                         .lhs = undefined,
@@ -770,7 +770,7 @@ const Parser = struct {
 
         if (align_expr == 0) {
             return p.addNode(.{
-                .tag = .ContainerFieldInit,
+                .tag = .container_field_init,
                 .main_token = name_token,
                 .data = .{
                     .lhs = type_expr,
@@ -779,7 +779,7 @@ const Parser = struct {
             });
         } else if (value_expr == 0) {
             return p.addNode(.{
-                .tag = .ContainerFieldAlign,
+                .tag = .container_field_align,
                 .main_token = name_token,
                 .data = .{
                     .lhs = type_expr,
@@ -788,7 +788,7 @@ const Parser = struct {
             });
         } else {
             return p.addNode(.{
-                .tag = .ContainerField,
+                .tag = .container_field,
                 .main_token = name_token,
                 .data = .{
                     .lhs = type_expr,
@@ -833,7 +833,7 @@ const Parser = struct {
 
         if (comptime_token) |token| {
             return p.addNode(.{
-                .tag = .Comptime,
+                .tag = .@"comptime",
                 .main_token = token,
                 .data = .{
                     .lhs = try p.expectBlockExprStatement(),
@@ -845,7 +845,7 @@ const Parser = struct {
         switch (p.token_tags[p.tok_i]) {
             .keyword_nosuspend => {
                 return p.addNode(.{
-                    .tag = .Nosuspend,
+                    .tag = .@"nosuspend",
                     .main_token = p.nextToken(),
                     .data = .{
                         .lhs = try p.expectBlockExprStatement(),
@@ -860,7 +860,7 @@ const Parser = struct {
                 else
                     try p.expectBlockExprStatement();
                 return p.addNode(.{
-                    .tag = .Suspend,
+                    .tag = .@"suspend",
                     .main_token = token,
                     .data = .{
                         .lhs = block_expr,
@@ -869,7 +869,7 @@ const Parser = struct {
                 });
             },
             .keyword_defer => return p.addNode(.{
-                .tag = .Defer,
+                .tag = .@"defer",
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -877,7 +877,7 @@ const Parser = struct {
                 },
             }),
             .keyword_errdefer => return p.addNode(.{
-                .tag = .ErrDefer,
+                .tag = .@"errdefer",
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = try p.parsePayload(),
@@ -947,7 +947,7 @@ const Parser = struct {
             }
             if (p.eatToken(.semicolon)) |_| {
                 return p.addNode(.{
-                    .tag = .IfSimple,
+                    .tag = .if_simple,
                     .main_token = if_token,
                     .data = .{
                         .lhs = condition,
@@ -963,7 +963,7 @@ const Parser = struct {
                 return p.fail(.{ .ExpectedSemiOrElse = .{ .token = p.tok_i } });
             }
             return p.addNode(.{
-                .tag = .IfSimple,
+                .tag = .if_simple,
                 .main_token = if_token,
                 .data = .{
                     .lhs = condition,
@@ -974,7 +974,7 @@ const Parser = struct {
         const else_payload = try p.parsePayload();
         const else_expr = try p.expectStatement();
         return p.addNode(.{
-            .tag = .If,
+            .tag = .@"if",
             .main_token = if_token,
             .data = .{
                 .lhs = condition,
@@ -1041,7 +1041,7 @@ const Parser = struct {
             }
             if (p.eatToken(.semicolon)) |_| {
                 return p.addNode(.{
-                    .tag = .ForSimple,
+                    .tag = .for_simple,
                     .main_token = for_token,
                     .data = .{
                         .lhs = array_expr,
@@ -1057,7 +1057,7 @@ const Parser = struct {
                 return p.fail(.{ .ExpectedSemiOrElse = .{ .token = p.tok_i } });
             }
             return p.addNode(.{
-                .tag = .ForSimple,
+                .tag = .for_simple,
                 .main_token = for_token,
                 .data = .{
                     .lhs = array_expr,
@@ -1066,7 +1066,7 @@ const Parser = struct {
             });
         };
         return p.addNode(.{
-            .tag = .For,
+            .tag = .@"for",
             .main_token = for_token,
             .data = .{
                 .lhs = array_expr,
@@ -1103,7 +1103,7 @@ const Parser = struct {
             if (p.eatToken(.semicolon)) |_| {
                 if (cont_expr == 0) {
                     return p.addNode(.{
-                        .tag = .WhileSimple,
+                        .tag = .while_simple,
                         .main_token = while_token,
                         .data = .{
                             .lhs = condition,
@@ -1112,7 +1112,7 @@ const Parser = struct {
                     });
                 } else {
                     return p.addNode(.{
-                        .tag = .WhileCont,
+                        .tag = .while_cont,
                         .main_token = while_token,
                         .data = .{
                             .lhs = condition,
@@ -1133,7 +1133,7 @@ const Parser = struct {
             }
             if (cont_expr == 0) {
                 return p.addNode(.{
-                    .tag = .WhileSimple,
+                    .tag = .while_simple,
                     .main_token = while_token,
                     .data = .{
                         .lhs = condition,
@@ -1142,7 +1142,7 @@ const Parser = struct {
                 });
             } else {
                 return p.addNode(.{
-                    .tag = .WhileCont,
+                    .tag = .while_cont,
                     .main_token = while_token,
                     .data = .{
                         .lhs = condition,
@@ -1157,7 +1157,7 @@ const Parser = struct {
         const else_payload = try p.parsePayload();
         const else_expr = try p.expectStatement();
         return p.addNode(.{
-            .tag = .While,
+            .tag = .@"while",
             .main_token = while_token,
             .data = .{
                 .lhs = condition,
@@ -1233,20 +1233,20 @@ const Parser = struct {
         if (expr == 0) return null_node;
 
         const tag: Node.Tag = switch (p.token_tags[p.tok_i]) {
-            .asterisk_equal => .AssignMul,
-            .slash_equal => .AssignDiv,
-            .percent_equal => .AssignMod,
-            .plus_equal => .AssignAdd,
-            .minus_equal => .AssignSub,
-            .angle_bracket_angle_bracket_left_equal => .AssignBitShiftLeft,
-            .angle_bracket_angle_bracket_right_equal => .AssignBitShiftRight,
-            .ampersand_equal => .AssignBitAnd,
-            .caret_equal => .AssignBitXor,
-            .pipe_equal => .AssignBitOr,
-            .asterisk_percent_equal => .AssignMulWrap,
-            .plus_percent_equal => .AssignAddWrap,
-            .minus_percent_equal => .AssignSubWrap,
-            .equal => .Assign,
+            .asterisk_equal => .assign_mul,
+            .slash_equal => .assign_div,
+            .percent_equal => .assign_mod,
+            .plus_equal => .assign_add,
+            .minus_equal => .assign_sub,
+            .angle_bracket_angle_bracket_left_equal => .assign_bit_shift_left,
+            .angle_bracket_angle_bracket_right_equal => .assign_bit_shift_right,
+            .ampersand_equal => .assign_bit_and,
+            .caret_equal => .assign_bit_xor,
+            .pipe_equal => .assign_bit_or,
+            .asterisk_percent_equal => .assign_mul_wrap,
+            .plus_percent_equal => .assign_add_wrap,
+            .minus_percent_equal => .assign_sub_wrap,
+            .equal => .assign,
             else => return expr,
         };
         return p.addNode(.{
@@ -1295,7 +1295,7 @@ const Parser = struct {
                         return p.fail(.{ .InvalidToken = .{ .token = p.tok_i } });
                     }
                     res = try p.addNode(.{
-                        .tag = .BoolOr,
+                        .tag = .bool_or,
                         .main_token = or_token,
                         .data = .{
                             .lhs = res,
@@ -1322,7 +1322,7 @@ const Parser = struct {
                         return p.fail(.{ .InvalidToken = .{ .token = p.tok_i } });
                     }
                     res = try p.addNode(.{
-                        .tag = .BoolAnd,
+                        .tag = .bool_and,
                         .main_token = and_token,
                         .data = .{
                             .lhs = res,
@@ -1348,12 +1348,12 @@ const Parser = struct {
         if (expr == 0) return null_node;
 
         const tag: Node.Tag = switch (p.token_tags[p.tok_i]) {
-            .equal_equal => .EqualEqual,
-            .bang_equal => .BangEqual,
-            .angle_bracket_left => .LessThan,
-            .angle_bracket_right => .GreaterThan,
-            .angle_bracket_left_equal => .LessOrEqual,
-            .angle_bracket_right_equal => .GreaterOrEqual,
+            .equal_equal => .equal_equal,
+            .bang_equal => .bang_equal,
+            .angle_bracket_left => .less_than,
+            .angle_bracket_right => .greater_than,
+            .angle_bracket_left_equal => .less_or_equal,
+            .angle_bracket_right_equal => .greater_or_equal,
             else => return expr,
         };
         return p.addNode(.{
@@ -1379,10 +1379,10 @@ const Parser = struct {
 
         while (true) {
             const tag: Node.Tag = switch (p.token_tags[p.tok_i]) {
-                .ampersand => .BitAnd,
-                .caret => .BitXor,
-                .pipe => .BitOr,
-                .keyword_orelse => .OrElse,
+                .ampersand => .bit_and,
+                .caret => .bit_xor,
+                .pipe => .bit_or,
+                .keyword_orelse => .@"orelse",
                 .keyword_catch => {
                     const catch_token = p.nextToken();
                     _ = try p.parsePayload();
@@ -1391,7 +1391,7 @@ const Parser = struct {
                         return p.fail(.{ .InvalidToken = .{ .token = p.tok_i } });
                     }
                     res = try p.addNode(.{
-                        .tag = .Catch,
+                        .tag = .@"catch",
                         .main_token = catch_token,
                         .data = .{
                             .lhs = res,
@@ -1432,8 +1432,8 @@ const Parser = struct {
 
         while (true) {
             const tag: Node.Tag = switch (p.token_tags[p.tok_i]) {
-                .angle_bracket_angle_bracket_left => .BitShiftLeft,
-                .angle_bracket_angle_bracket_right => .BitShiftRight,
+                .angle_bracket_angle_bracket_left => .bit_shift_left,
+                .angle_bracket_angle_bracket_right => .bit_shift_right,
                 else => return res,
             };
             res = try p.addNode(.{
@@ -1469,11 +1469,11 @@ const Parser = struct {
 
         while (true) {
             const tag: Node.Tag = switch (p.token_tags[p.tok_i]) {
-                .plus => .Add,
-                .minus => .Sub,
-                .plus_plus => .ArrayCat,
-                .plus_percent => .AddWrap,
-                .minus_percent => .SubWrap,
+                .plus => .add,
+                .minus => .sub,
+                .plus_plus => .array_cat,
+                .plus_percent => .add_wrap,
+                .minus_percent => .sub_wrap,
                 else => return res,
             };
             res = try p.addNode(.{
@@ -1509,12 +1509,12 @@ const Parser = struct {
 
         while (true) {
             const tag: Node.Tag = switch (p.token_tags[p.tok_i]) {
-                .pipe_pipe => .MergeErrorSets,
-                .asterisk => .Mul,
-                .slash => .Div,
-                .percent => .Mod,
-                .asterisk_asterisk => .ArrayMult,
-                .asterisk_percent => .MulWrap,
+                .pipe_pipe => .merge_error_sets,
+                .asterisk => .mul,
+                .slash => .div,
+                .percent => .mod,
+                .asterisk_asterisk => .array_mult,
+                .asterisk_percent => .mul_wrap,
                 else => return res,
             };
             res = try p.addNode(.{
@@ -1547,13 +1547,13 @@ const Parser = struct {
     ///      / KEYWORD_await
     fn parsePrefixExpr(p: *Parser) Error!Node.Index {
         const tag: Node.Tag = switch (p.token_tags[p.tok_i]) {
-            .bang => .BoolNot,
-            .minus => .Negation,
-            .tilde => .BitNot,
-            .minus_percent => .NegationWrap,
-            .ampersand => .AddressOf,
-            .keyword_try => .Try,
-            .keyword_await => .Await,
+            .bang => .bool_not,
+            .minus => .negation,
+            .tilde => .bit_not,
+            .minus_percent => .negation_wrap,
+            .ampersand => .address_of,
+            .keyword_try => .@"try",
+            .keyword_await => .@"await",
             else => return p.parsePrimaryExpr(),
         };
         return p.addNode(.{
@@ -1588,7 +1588,7 @@ const Parser = struct {
     fn parseTypeExpr(p: *Parser) Error!Node.Index {
         switch (p.token_tags[p.tok_i]) {
             .question_mark => return p.addNode(.{
-                .tag = .OptionalType,
+                .tag = .optional_type,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = try p.expectTypeExpr(),
@@ -1597,7 +1597,7 @@ const Parser = struct {
             }),
             .keyword_anyframe => switch (p.token_tags[p.tok_i + 1]) {
                 .arrow => return p.addNode(.{
-                    .tag = .AnyFrameType,
+                    .tag = .anyframe_type,
                     .main_token = p.nextToken(),
                     .data = .{
                         .lhs = p.nextToken(),
@@ -1612,7 +1612,7 @@ const Parser = struct {
                 const elem_type = try p.expectTypeExpr();
                 if (mods.bit_range_start == 0) {
                     return p.addNode(.{
-                        .tag = .PtrTypeAligned,
+                        .tag = .ptr_type_aligned,
                         .main_token = asterisk,
                         .data = .{
                             .lhs = mods.align_node,
@@ -1621,7 +1621,7 @@ const Parser = struct {
                     });
                 } else {
                     return p.addNode(.{
-                        .tag = .PtrTypeBitRange,
+                        .tag = .ptr_type_bit_range,
                         .main_token = asterisk,
                         .data = .{
                             .lhs = try p.addExtra(Node.PtrTypeBitRange{
@@ -1642,7 +1642,7 @@ const Parser = struct {
                 const inner: Node.Index = inner: {
                     if (mods.bit_range_start == 0) {
                         break :inner try p.addNode(.{
-                            .tag = .PtrTypeAligned,
+                            .tag = .ptr_type_aligned,
                             .main_token = asterisk,
                             .data = .{
                                 .lhs = mods.align_node,
@@ -1651,7 +1651,7 @@ const Parser = struct {
                         });
                     } else {
                         break :inner try p.addNode(.{
-                            .tag = .PtrTypeBitRange,
+                            .tag = .ptr_type_bit_range,
                             .main_token = asterisk,
                             .data = .{
                                 .lhs = try p.addExtra(Node.PtrTypeBitRange{
@@ -1666,7 +1666,7 @@ const Parser = struct {
                     }
                 };
                 return p.addNode(.{
-                    .tag = .PtrTypeAligned,
+                    .tag = .ptr_type_aligned,
                     .main_token = asterisk,
                     .data = .{
                         .lhs = 0,
@@ -1698,7 +1698,7 @@ const Parser = struct {
                     if (mods.bit_range_start == 0) {
                         if (sentinel == 0) {
                             return p.addNode(.{
-                                .tag = .PtrTypeAligned,
+                                .tag = .ptr_type_aligned,
                                 .main_token = asterisk,
                                 .data = .{
                                     .lhs = mods.align_node,
@@ -1707,7 +1707,7 @@ const Parser = struct {
                             });
                         } else if (mods.align_node == 0) {
                             return p.addNode(.{
-                                .tag = .PtrTypeSentinel,
+                                .tag = .ptr_type_sentinel,
                                 .main_token = asterisk,
                                 .data = .{
                                     .lhs = sentinel,
@@ -1716,7 +1716,7 @@ const Parser = struct {
                             });
                         } else {
                             return p.addNode(.{
-                                .tag = .PtrType,
+                                .tag = .ptr_type,
                                 .main_token = asterisk,
                                 .data = .{
                                     .lhs = try p.addExtra(Node.PtrType{
@@ -1729,7 +1729,7 @@ const Parser = struct {
                         }
                     } else {
                         return p.addNode(.{
-                            .tag = .PtrTypeBitRange,
+                            .tag = .ptr_type_bit_range,
                             .main_token = asterisk,
                             .data = .{
                                 .lhs = try p.addExtra(Node.PtrTypeBitRange{
@@ -1762,7 +1762,7 @@ const Parser = struct {
                     if (len_expr == 0) {
                         if (sentinel == 0) {
                             return p.addNode(.{
-                                .tag = .PtrTypeAligned,
+                                .tag = .ptr_type_aligned,
                                 .main_token = lbracket,
                                 .data = .{
                                     .lhs = mods.align_node,
@@ -1771,7 +1771,7 @@ const Parser = struct {
                             });
                         } else if (mods.align_node == 0) {
                             return p.addNode(.{
-                                .tag = .PtrTypeSentinel,
+                                .tag = .ptr_type_sentinel,
                                 .main_token = lbracket,
                                 .data = .{
                                     .lhs = sentinel,
@@ -1780,7 +1780,7 @@ const Parser = struct {
                             });
                         } else {
                             return p.addNode(.{
-                                .tag = .PtrType,
+                                .tag = .ptr_type,
                                 .main_token = lbracket,
                                 .data = .{
                                     .lhs = try p.addExtra(Node.PtrType{
@@ -1800,7 +1800,7 @@ const Parser = struct {
                         }
                         if (sentinel == 0) {
                             return p.addNode(.{
-                                .tag = .ArrayType,
+                                .tag = .array_type,
                                 .main_token = lbracket,
                                 .data = .{
                                     .lhs = len_expr,
@@ -1809,7 +1809,7 @@ const Parser = struct {
                             });
                         } else {
                             return p.addNode(.{
-                                .tag = .ArrayTypeSentinel,
+                                .tag = .array_type_sentinel,
                                 .main_token = lbracket,
                                 .data = .{
                                     .lhs = len_expr,
@@ -1854,7 +1854,7 @@ const Parser = struct {
             .keyword_break => {
                 p.tok_i += 1;
                 return p.addNode(.{
-                    .tag = .Break,
+                    .tag = .@"break",
                     .main_token = p.tok_i - 1,
                     .data = .{
                         .lhs = try p.parseBreakLabel(),
@@ -1865,7 +1865,7 @@ const Parser = struct {
             .keyword_continue => {
                 p.tok_i += 1;
                 return p.addNode(.{
-                    .tag = .Continue,
+                    .tag = .@"continue",
                     .main_token = p.tok_i - 1,
                     .data = .{
                         .lhs = try p.parseBreakLabel(),
@@ -1876,7 +1876,7 @@ const Parser = struct {
             .keyword_comptime => {
                 p.tok_i += 1;
                 return p.addNode(.{
-                    .tag = .Comptime,
+                    .tag = .@"comptime",
                     .main_token = p.tok_i - 1,
                     .data = .{
                         .lhs = try p.expectExpr(),
@@ -1887,7 +1887,7 @@ const Parser = struct {
             .keyword_nosuspend => {
                 p.tok_i += 1;
                 return p.addNode(.{
-                    .tag = .Nosuspend,
+                    .tag = .@"nosuspend",
                     .main_token = p.tok_i - 1,
                     .data = .{
                         .lhs = try p.expectExpr(),
@@ -1898,7 +1898,7 @@ const Parser = struct {
             .keyword_resume => {
                 p.tok_i += 1;
                 return p.addNode(.{
-                    .tag = .Resume,
+                    .tag = .@"resume",
                     .main_token = p.tok_i - 1,
                     .data = .{
                         .lhs = try p.expectExpr(),
@@ -1909,7 +1909,7 @@ const Parser = struct {
             .keyword_return => {
                 p.tok_i += 1;
                 return p.addNode(.{
-                    .tag = .Return,
+                    .tag = .@"return",
                     .main_token = p.tok_i - 1,
                     .data = .{
                         .lhs = try p.parseExpr(),
@@ -1976,7 +1976,7 @@ const Parser = struct {
 
         if (p.eatToken(.r_brace)) |_| {
             return p.addNode(.{
-                .tag = .BlockTwo,
+                .tag = .block_two,
                 .main_token = lbrace,
                 .data = .{
                     .lhs = 0,
@@ -1989,7 +1989,7 @@ const Parser = struct {
         if (p.eatToken(.r_brace)) |_| {
             const semicolon = p.token_tags[p.tok_i - 2] == .semicolon;
             return p.addNode(.{
-                .tag = if (semicolon) .BlockTwoSemicolon else .BlockTwo,
+                .tag = if (semicolon) .block_two_semicolon else .block_two,
                 .main_token = lbrace,
                 .data = .{
                     .lhs = stmt_one,
@@ -2001,7 +2001,7 @@ const Parser = struct {
         if (p.eatToken(.r_brace)) |_| {
             const semicolon = p.token_tags[p.tok_i - 2] == .semicolon;
             return p.addNode(.{
-                .tag = if (semicolon) .BlockTwoSemicolon else .BlockTwo,
+                .tag = if (semicolon) .block_two_semicolon else .block_two,
                 .main_token = lbrace,
                 .data = .{
                     .lhs = stmt_one,
@@ -2025,7 +2025,7 @@ const Parser = struct {
         const semicolon = p.token_tags[p.tok_i - 2] == .semicolon;
         const statements_span = try p.listToSpan(statements.items);
         return p.addNode(.{
-            .tag = if (semicolon) .BlockSemicolon else .Block,
+            .tag = if (semicolon) .block_semicolon else .block,
             .main_token = lbrace,
             .data = .{
                 .lhs = statements_span.start,
@@ -2046,7 +2046,7 @@ const Parser = struct {
         const then_expr = try p.expectExpr();
         const else_token = p.eatToken(.keyword_else) orelse {
             return p.addNode(.{
-                .tag = .ForSimple,
+                .tag = .for_simple,
                 .main_token = for_token,
                 .data = .{
                     .lhs = array_expr,
@@ -2056,7 +2056,7 @@ const Parser = struct {
         };
         const else_expr = try p.expectExpr();
         return p.addNode(.{
-            .tag = .For,
+            .tag = .@"for",
             .main_token = for_token,
             .data = .{
                 .lhs = array_expr,
@@ -2082,7 +2082,7 @@ const Parser = struct {
         const else_token = p.eatToken(.keyword_else) orelse {
             if (cont_expr == 0) {
                 return p.addNode(.{
-                    .tag = .WhileSimple,
+                    .tag = .while_simple,
                     .main_token = while_token,
                     .data = .{
                         .lhs = condition,
@@ -2091,7 +2091,7 @@ const Parser = struct {
                 });
             } else {
                 return p.addNode(.{
-                    .tag = .WhileCont,
+                    .tag = .while_cont,
                     .main_token = while_token,
                     .data = .{
                         .lhs = condition,
@@ -2106,7 +2106,7 @@ const Parser = struct {
         const else_payload = try p.parsePayload();
         const else_expr = try p.expectExpr();
         return p.addNode(.{
-            .tag = .While,
+            .tag = .@"while",
             .main_token = while_token,
             .data = .{
                 .lhs = condition,
@@ -2134,7 +2134,7 @@ const Parser = struct {
 
         if (p.eatToken(.r_brace)) |_| {
             return p.addNode(.{
-                .tag = .StructInitOne,
+                .tag = .struct_init_one,
                 .main_token = lbrace,
                 .data = .{
                     .lhs = lhs,
@@ -2147,7 +2147,7 @@ const Parser = struct {
             const comma_one = p.eatToken(.comma);
             if (p.eatToken(.r_brace)) |_| {
                 return p.addNode(.{
-                    .tag = if (comma_one != null) .StructInitOneComma else .StructInitOne,
+                    .tag = if (comma_one != null) .struct_init_one_comma else .struct_init_one,
                     .main_token = lbrace,
                     .data = .{
                         .lhs = lhs,
@@ -2192,7 +2192,7 @@ const Parser = struct {
             }
             const span = try p.listToSpan(init_list.items);
             return p.addNode(.{
-                .tag = if (p.token_tags[p.tok_i - 2] == .comma) .StructInitComma else .StructInit,
+                .tag = if (p.token_tags[p.tok_i - 2] == .comma) .struct_init_comma else .struct_init,
                 .main_token = lbrace,
                 .data = .{
                     .lhs = lhs,
@@ -2208,7 +2208,7 @@ const Parser = struct {
         const comma_one = p.eatToken(.comma);
         if (p.eatToken(.r_brace)) |_| {
             return p.addNode(.{
-                .tag = if (comma_one != null) .ArrayInitOneComma else .ArrayInitOne,
+                .tag = if (comma_one != null) .array_init_one_comma else .array_init_one,
                 .main_token = lbrace,
                 .data = .{
                     .lhs = lhs,
@@ -2239,7 +2239,7 @@ const Parser = struct {
         _ = try p.expectToken(.r_brace);
         const span = try p.listToSpan(init_list.items);
         return p.addNode(.{
-            .tag = if (trailing_comma) .ArrayInitComma else .ArrayInit,
+            .tag = if (trailing_comma) .array_init_comma else .array_init,
             .main_token = lbrace,
             .data = .{
                 .lhs = lhs,
@@ -2257,7 +2257,7 @@ const Parser = struct {
         if (suffix_expr == 0) return null_node;
         const bang = p.eatToken(.bang) orelse return suffix_expr;
         return p.addNode(.{
-            .tag = .ErrorUnion,
+            .tag = .error_union,
             .main_token = bang,
             .data = .{
                 .lhs = suffix_expr,
@@ -2286,7 +2286,7 @@ const Parser = struct {
             };
             if (p.eatToken(.r_paren)) |_| {
                 return p.addNode(.{
-                    .tag = .AsyncCallOne,
+                    .tag = .async_call_one,
                     .main_token = lparen,
                     .data = .{
                         .lhs = res,
@@ -2298,7 +2298,7 @@ const Parser = struct {
             const comma_one = p.eatToken(.comma);
             if (p.eatToken(.r_paren)) |_| {
                 return p.addNode(.{
-                    .tag = if (comma_one == null) .AsyncCallOne else .AsyncCallOneComma,
+                    .tag = if (comma_one == null) .async_call_one else .async_call_one_comma,
                     .main_token = lparen,
                     .data = .{
                         .lhs = res,
@@ -2325,7 +2325,7 @@ const Parser = struct {
                         if (p.eatToken(.r_paren)) |_| {
                             const span = try p.listToSpan(param_list.items);
                             return p.addNode(.{
-                                .tag = .AsyncCallComma,
+                                .tag = .async_call_comma,
                                 .main_token = lparen,
                                 .data = .{
                                     .lhs = res,
@@ -2342,7 +2342,7 @@ const Parser = struct {
                     .r_paren => {
                         const span = try p.listToSpan(param_list.items);
                         return p.addNode(.{
-                            .tag = .AsyncCall,
+                            .tag = .async_call,
                             .main_token = lparen,
                             .data = .{
                                 .lhs = res,
@@ -2387,7 +2387,7 @@ const Parser = struct {
                 const lparen = p.eatToken(.l_paren) orelse return res;
                 if (p.eatToken(.r_paren)) |_| {
                     break :res try p.addNode(.{
-                        .tag = .CallOne,
+                        .tag = .call_one,
                         .main_token = lparen,
                         .data = .{
                             .lhs = res,
@@ -2399,7 +2399,7 @@ const Parser = struct {
                 const comma_one = p.eatToken(.comma);
                 if (p.eatToken(.r_paren)) |_| {
                     break :res try p.addNode(.{
-                        .tag = if (comma_one == null) .CallOne else .CallOneComma,
+                        .tag = if (comma_one == null) .call_one else .call_one_comma,
                         .main_token = lparen,
                         .data = .{
                             .lhs = res,
@@ -2426,7 +2426,7 @@ const Parser = struct {
                             if (p.eatToken(.r_paren)) |_| {
                                 const span = try p.listToSpan(param_list.items);
                                 break :res try p.addNode(.{
-                                    .tag = .CallComma,
+                                    .tag = .call_comma,
                                     .main_token = lparen,
                                     .data = .{
                                         .lhs = res,
@@ -2443,7 +2443,7 @@ const Parser = struct {
                         .r_paren => {
                             const span = try p.listToSpan(param_list.items);
                             break :res try p.addNode(.{
-                                .tag = .Call,
+                                .tag = .call,
                                 .main_token = lparen,
                                 .data = .{
                                     .lhs = res,
@@ -2518,7 +2518,7 @@ const Parser = struct {
     fn parsePrimaryTypeExpr(p: *Parser) !Node.Index {
         switch (p.token_tags[p.tok_i]) {
             .char_literal => return p.addNode(.{
-                .tag = .CharLiteral,
+                .tag = .char_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2526,7 +2526,7 @@ const Parser = struct {
                 },
             }),
             .integer_literal => return p.addNode(.{
-                .tag = .IntegerLiteral,
+                .tag = .integer_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2534,7 +2534,7 @@ const Parser = struct {
                 },
             }),
             .float_literal => return p.addNode(.{
-                .tag = .FloatLiteral,
+                .tag = .float_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2542,7 +2542,7 @@ const Parser = struct {
                 },
             }),
             .keyword_false => return p.addNode(.{
-                .tag = .FalseLiteral,
+                .tag = .false_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2550,7 +2550,7 @@ const Parser = struct {
                 },
             }),
             .keyword_true => return p.addNode(.{
-                .tag = .TrueLiteral,
+                .tag = .true_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2558,7 +2558,7 @@ const Parser = struct {
                 },
             }),
             .keyword_null => return p.addNode(.{
-                .tag = .NullLiteral,
+                .tag = .null_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2566,7 +2566,7 @@ const Parser = struct {
                 },
             }),
             .keyword_undefined => return p.addNode(.{
-                .tag = .UndefinedLiteral,
+                .tag = .undefined_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2574,7 +2574,7 @@ const Parser = struct {
                 },
             }),
             .keyword_unreachable => return p.addNode(.{
-                .tag = .UnreachableLiteral,
+                .tag = .unreachable_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2582,7 +2582,7 @@ const Parser = struct {
                 },
             }),
             .keyword_anyframe => return p.addNode(.{
-                .tag = .AnyFrameLiteral,
+                .tag = .anyframe_literal,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = undefined,
@@ -2592,7 +2592,7 @@ const Parser = struct {
             .string_literal => {
                 const main_token = p.nextToken();
                 return p.addNode(.{
-                    .tag = .StringLiteral,
+                    .tag = .string_literal,
                     .main_token = main_token,
                     .data = .{
                         .lhs = main_token,
@@ -2620,7 +2620,7 @@ const Parser = struct {
             => return p.parseContainerDeclAuto(),
 
             .keyword_comptime => return p.addNode(.{
-                .tag = .Comptime,
+                .tag = .@"comptime",
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = try p.expectTypeExpr(),
@@ -2633,7 +2633,7 @@ const Parser = struct {
                     p.tok_i += 1;
                 }
                 return p.addNode(.{
-                    .tag = .StringLiteral,
+                    .tag = .string_literal,
                     .main_token = first_line,
                     .data = .{
                         .lhs = first_line,
@@ -2662,7 +2662,7 @@ const Parser = struct {
                         return p.parseWhileTypeExpr();
                     },
                     else => return p.addNode(.{
-                        .tag = .Identifier,
+                        .tag = .identifier,
                         .main_token = p.nextToken(),
                         .data = .{
                             .lhs = undefined,
@@ -2671,7 +2671,7 @@ const Parser = struct {
                     }),
                 },
                 else => return p.addNode(.{
-                    .tag = .Identifier,
+                    .tag = .identifier,
                     .main_token = p.nextToken(),
                     .data = .{
                         .lhs = undefined,
@@ -2681,7 +2681,7 @@ const Parser = struct {
             },
             .period => switch (p.token_tags[p.tok_i + 1]) {
                 .identifier => return p.addNode(.{
-                    .tag = .EnumLiteral,
+                    .tag = .enum_literal,
                     .data = .{
                         .lhs = p.nextToken(), // dot
                         .rhs = undefined,
@@ -2697,7 +2697,7 @@ const Parser = struct {
 
                     if (p.eatToken(.r_brace)) |_| {
                         return p.addNode(.{
-                            .tag = .StructInitDotTwo,
+                            .tag = .struct_init_dot_two,
                             .main_token = lbrace,
                             .data = .{
                                 .lhs = 0,
@@ -2710,7 +2710,7 @@ const Parser = struct {
                         const comma_one = p.eatToken(.comma);
                         if (p.eatToken(.r_brace)) |_| {
                             return p.addNode(.{
-                                .tag = if (comma_one != null) .StructInitDotTwoComma else .StructInitDotTwo,
+                                .tag = if (comma_one != null) .struct_init_dot_two_comma else .struct_init_dot_two,
                                 .main_token = lbrace,
                                 .data = .{
                                     .lhs = field_init_one,
@@ -2727,7 +2727,7 @@ const Parser = struct {
                         const comma_two = p.eatToken(.comma);
                         if (p.eatToken(.r_brace)) |_| {
                             return p.addNode(.{
-                                .tag = if (comma_two != null) .StructInitDotTwoComma else .StructInitDotTwo,
+                                .tag = if (comma_two != null) .struct_init_dot_two_comma else .struct_init_dot_two,
                                 .main_token = lbrace,
                                 .data = .{
                                     .lhs = field_init_one,
@@ -2778,7 +2778,7 @@ const Parser = struct {
                         const span = try p.listToSpan(init_list.items);
                         const trailing_comma = p.token_tags[p.tok_i - 2] == .comma;
                         return p.addNode(.{
-                            .tag = if (trailing_comma) .StructInitDotComma else .StructInitDot,
+                            .tag = if (trailing_comma) .struct_init_dot_comma else .struct_init_dot,
                             .main_token = lbrace,
                             .data = .{
                                 .lhs = span.start,
@@ -2791,7 +2791,7 @@ const Parser = struct {
                     const comma_one = p.eatToken(.comma);
                     if (p.eatToken(.r_brace)) |_| {
                         return p.addNode(.{
-                            .tag = if (comma_one != null) .ArrayInitDotTwoComma else .ArrayInitDotTwo,
+                            .tag = if (comma_one != null) .array_init_dot_two_comma else .array_init_dot_two,
                             .main_token = lbrace,
                             .data = .{
                                 .lhs = elem_init_one,
@@ -2808,7 +2808,7 @@ const Parser = struct {
                     const comma_two = p.eatToken(.comma);
                     if (p.eatToken(.r_brace)) |_| {
                         return p.addNode(.{
-                            .tag = if (comma_two != null) .ArrayInitDotTwoComma else .ArrayInitDotTwo,
+                            .tag = if (comma_two != null) .array_init_dot_two_comma else .array_init_dot_two,
                             .main_token = lbrace,
                             .data = .{
                                 .lhs = elem_init_one,
@@ -2858,7 +2858,7 @@ const Parser = struct {
                     }
                     const span = try p.listToSpan(init_list.items);
                     return p.addNode(.{
-                        .tag = if (p.token_tags[p.tok_i - 2] == .comma) .ArrayInitDotComma else .ArrayInitDot,
+                        .tag = if (p.token_tags[p.tok_i - 2] == .comma) .array_init_dot_comma else .array_init_dot,
                         .main_token = lbrace,
                         .data = .{
                             .lhs = span.start,
@@ -2875,7 +2875,7 @@ const Parser = struct {
 
                     if (p.eatToken(.r_brace)) |rbrace| {
                         return p.addNode(.{
-                            .tag = .ErrorSetDecl,
+                            .tag = .error_set_decl,
                             .main_token = error_token,
                             .data = .{
                                 .lhs = undefined,
@@ -2913,7 +2913,7 @@ const Parser = struct {
                         }
                     }
                     return p.addNode(.{
-                        .tag = .ErrorSetDecl,
+                        .tag = .error_set_decl,
                         .main_token = error_token,
                         .data = .{
                             .lhs = undefined,
@@ -2922,7 +2922,7 @@ const Parser = struct {
                     });
                 },
                 else => return p.addNode(.{
-                    .tag = .ErrorValue,
+                    .tag = .error_value,
                     .main_token = p.nextToken(),
                     .data = .{
                         .lhs = try p.expectToken(.period),
@@ -2931,7 +2931,7 @@ const Parser = struct {
                 }),
             },
             .l_paren => return p.addNode(.{
-                .tag = .GroupedExpression,
+                .tag = .grouped_expression,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = try p.expectExpr(),
@@ -2962,7 +2962,7 @@ const Parser = struct {
         const then_expr = try p.expectExpr();
         const else_token = p.eatToken(.keyword_else) orelse {
             return p.addNode(.{
-                .tag = .ForSimple,
+                .tag = .for_simple,
                 .main_token = for_token,
                 .data = .{
                     .lhs = array_expr,
@@ -2972,7 +2972,7 @@ const Parser = struct {
         };
         const else_expr = try p.expectTypeExpr();
         return p.addNode(.{
-            .tag = .For,
+            .tag = .@"for",
             .main_token = for_token,
             .data = .{
                 .lhs = array_expr,
@@ -2998,7 +2998,7 @@ const Parser = struct {
         const else_token = p.eatToken(.keyword_else) orelse {
             if (cont_expr == 0) {
                 return p.addNode(.{
-                    .tag = .WhileSimple,
+                    .tag = .while_simple,
                     .main_token = while_token,
                     .data = .{
                         .lhs = condition,
@@ -3007,7 +3007,7 @@ const Parser = struct {
                 });
             } else {
                 return p.addNode(.{
-                    .tag = .WhileCont,
+                    .tag = .while_cont,
                     .main_token = while_token,
                     .data = .{
                         .lhs = condition,
@@ -3022,7 +3022,7 @@ const Parser = struct {
         const else_payload = try p.parsePayload();
         const else_expr = try p.expectTypeExpr();
         return p.addNode(.{
-            .tag = .While,
+            .tag = .@"while",
             .main_token = while_token,
             .data = .{
                 .lhs = condition,
@@ -3047,7 +3047,7 @@ const Parser = struct {
         _ = try p.expectToken(.r_brace);
 
         return p.addNode(.{
-            .tag = if (trailing_comma) .SwitchComma else .Switch,
+            .tag = if (trailing_comma) .switch_comma else .@"switch",
             .main_token = switch_token,
             .data = .{
                 .lhs = expr_node,
@@ -3074,7 +3074,7 @@ const Parser = struct {
 
         if (p.eatToken(.r_paren)) |rparen| {
             return p.addNode(.{
-                .tag = .AsmSimple,
+                .tag = .asm_simple,
                 .main_token = asm_token,
                 .data = .{
                     .lhs = template,
@@ -3140,7 +3140,7 @@ const Parser = struct {
         const rparen = try p.expectToken(.r_paren);
         const span = try p.listToSpan(list.items);
         return p.addNode(.{
-            .tag = .Asm,
+            .tag = .@"asm",
             .main_token = asm_token,
             .data = .{
                 .lhs = template,
@@ -3170,7 +3170,7 @@ const Parser = struct {
         };
         const rparen = try p.expectToken(.r_paren);
         return p.addNode(.{
-            .tag = .AsmOutput,
+            .tag = .asm_output,
             .main_token = identifier,
             .data = .{
                 .lhs = type_expr,
@@ -3189,7 +3189,7 @@ const Parser = struct {
         const expr = try p.expectExpr();
         const rparen = try p.expectToken(.r_paren);
         return p.addNode(.{
-            .tag = .AsmInput,
+            .tag = .asm_input,
             .main_token = identifier,
             .data = .{
                 .lhs = expr,
@@ -3336,7 +3336,7 @@ const Parser = struct {
             const arrow_token = try p.expectToken(.equal_angle_bracket_right);
             _ = try p.parsePtrPayload();
             return p.addNode(.{
-                .tag = .SwitchCaseOne,
+                .tag = .switch_case_one,
                 .main_token = arrow_token,
                 .data = .{
                     .lhs = 0,
@@ -3350,7 +3350,7 @@ const Parser = struct {
         if (p.eatToken(.equal_angle_bracket_right)) |arrow_token| {
             _ = try p.parsePtrPayload();
             return p.addNode(.{
-                .tag = .SwitchCaseOne,
+                .tag = .switch_case_one,
                 .main_token = arrow_token,
                 .data = .{
                     .lhs = first_item,
@@ -3372,7 +3372,7 @@ const Parser = struct {
         const arrow_token = try p.expectToken(.equal_angle_bracket_right);
         _ = try p.parsePtrPayload();
         return p.addNode(.{
-            .tag = .SwitchCase,
+            .tag = .switch_case,
             .main_token = arrow_token,
             .data = .{
                 .lhs = try p.addExtra(Node.SubRange{
@@ -3391,7 +3391,7 @@ const Parser = struct {
 
         if (p.eatToken(.ellipsis3)) |token| {
             return p.addNode(.{
-                .tag = .SwitchRange,
+                .tag = .switch_range,
                 .main_token = token,
                 .data = .{
                     .lhs = expr,
@@ -3485,7 +3485,7 @@ const Parser = struct {
                     if (end_expr == 0) {
                         _ = try p.expectToken(.r_bracket);
                         return p.addNode(.{
-                            .tag = .SliceOpen,
+                            .tag = .slice_open,
                             .main_token = lbracket,
                             .data = .{
                                 .lhs = lhs,
@@ -3497,7 +3497,7 @@ const Parser = struct {
                         const sentinel = try p.parseExpr();
                         _ = try p.expectToken(.r_bracket);
                         return p.addNode(.{
-                            .tag = .SliceSentinel,
+                            .tag = .slice_sentinel,
                             .main_token = lbracket,
                             .data = .{
                                 .lhs = lhs,
@@ -3511,7 +3511,7 @@ const Parser = struct {
                     } else {
                         _ = try p.expectToken(.r_bracket);
                         return p.addNode(.{
-                            .tag = .Slice,
+                            .tag = .slice,
                             .main_token = lbracket,
                             .data = .{
                                 .lhs = lhs,
@@ -3525,7 +3525,7 @@ const Parser = struct {
                 }
                 _ = try p.expectToken(.r_bracket);
                 return p.addNode(.{
-                    .tag = .ArrayAccess,
+                    .tag = .array_access,
                     .main_token = lbracket,
                     .data = .{
                         .lhs = lhs,
@@ -3534,7 +3534,7 @@ const Parser = struct {
                 });
             },
             .period_asterisk => return p.addNode(.{
-                .tag = .Deref,
+                .tag = .deref,
                 .main_token = p.nextToken(),
                 .data = .{
                     .lhs = lhs,
@@ -3545,7 +3545,7 @@ const Parser = struct {
                 const period_asterisk = p.nextToken();
                 try p.warn(.{ .AsteriskAfterPointerDereference = .{ .token = period_asterisk } });
                 return p.addNode(.{
-                    .tag = .Deref,
+                    .tag = .deref,
                     .main_token = period_asterisk,
                     .data = .{
                         .lhs = lhs,
@@ -3555,7 +3555,7 @@ const Parser = struct {
             },
             .period => switch (p.token_tags[p.tok_i + 1]) {
                 .identifier => return p.addNode(.{
-                    .tag = .FieldAccess,
+                    .tag = .field_access,
                     .main_token = p.nextToken(),
                     .data = .{
                         .lhs = lhs,
@@ -3563,7 +3563,7 @@ const Parser = struct {
                     },
                 }),
                 .question_mark => return p.addNode(.{
-                    .tag = .UnwrapOptional,
+                    .tag = .unwrap_optional,
                     .main_token = p.nextToken(),
                     .data = .{
                         .lhs = lhs,
@@ -3613,8 +3613,8 @@ const Parser = struct {
                             _ = try p.expectToken(.r_brace);
                             return p.addNode(.{
                                 .tag = switch (members.trailing_comma) {
-                                    true => .TaggedUnionEnumTagComma,
-                                    false => .TaggedUnionEnumTag,
+                                    true => .tagged_union_enum_tag_comma,
+                                    false => .tagged_union_enum_tag,
                                 },
                                 .main_token = main_token,
                                 .data = .{
@@ -3631,8 +3631,8 @@ const Parser = struct {
                             if (members.len <= 2) {
                                 return p.addNode(.{
                                     .tag = switch (members.trailing_comma) {
-                                        true => .TaggedUnionTwoComma,
-                                        false => .TaggedUnionTwo,
+                                        true => .tagged_union_two_comma,
+                                        false => .tagged_union_two,
                                     },
                                     .main_token = main_token,
                                     .data = .{
@@ -3644,8 +3644,8 @@ const Parser = struct {
                                 const span = try members.toSpan(p);
                                 return p.addNode(.{
                                     .tag = switch (members.trailing_comma) {
-                                        true => .TaggedUnionComma,
-                                        false => .TaggedUnion,
+                                        true => .tagged_union_comma,
+                                        false => .tagged_union,
                                     },
                                     .main_token = main_token,
                                     .data = .{
@@ -3673,8 +3673,8 @@ const Parser = struct {
             if (members.len <= 2) {
                 return p.addNode(.{
                     .tag = switch (members.trailing_comma) {
-                        true => .ContainerDeclTwoComma,
-                        false => .ContainerDeclTwo,
+                        true => .container_decl_two_comma,
+                        false => .container_decl_two,
                     },
                     .main_token = main_token,
                     .data = .{
@@ -3686,8 +3686,8 @@ const Parser = struct {
                 const span = try members.toSpan(p);
                 return p.addNode(.{
                     .tag = switch (members.trailing_comma) {
-                        true => .ContainerDeclComma,
-                        false => .ContainerDecl,
+                        true => .container_decl_comma,
+                        false => .container_decl,
                     },
                     .main_token = main_token,
                     .data = .{
@@ -3700,8 +3700,8 @@ const Parser = struct {
             const span = try members.toSpan(p);
             return p.addNode(.{
                 .tag = switch (members.trailing_comma) {
-                    true => .ContainerDeclArgComma,
-                    false => .ContainerDeclArg,
+                    true => .container_decl_arg_comma,
+                    false => .container_decl_arg,
                 },
                 .main_token = main_token,
                 .data = .{
@@ -3860,7 +3860,7 @@ const Parser = struct {
             });
             // Pretend this was an identifier so we can continue parsing.
             return p.addNode(.{
-                .tag = .Identifier,
+                .tag = .identifier,
                 .main_token = builtin_token,
                 .data = .{
                     .lhs = undefined,
@@ -3870,7 +3870,7 @@ const Parser = struct {
         };
         if (p.eatToken(.r_paren)) |_| {
             return p.addNode(.{
-                .tag = .BuiltinCallTwo,
+                .tag = .builtin_call_two,
                 .main_token = builtin_token,
                 .data = .{
                     .lhs = 0,
@@ -3883,7 +3883,7 @@ const Parser = struct {
             .comma => {
                 if (p.eatToken(.r_paren)) |_| {
                     return p.addNode(.{
-                        .tag = .BuiltinCallTwoComma,
+                        .tag = .builtin_call_two_comma,
                         .main_token = builtin_token,
                         .data = .{
                             .lhs = param_one,
@@ -3893,7 +3893,7 @@ const Parser = struct {
                 }
             },
             .r_paren => return p.addNode(.{
-                .tag = .BuiltinCallTwo,
+                .tag = .builtin_call_two,
                 .main_token = builtin_token,
                 .data = .{
                     .lhs = param_one,
@@ -3914,7 +3914,7 @@ const Parser = struct {
             .comma => {
                 if (p.eatToken(.r_paren)) |_| {
                     return p.addNode(.{
-                        .tag = .BuiltinCallTwoComma,
+                        .tag = .builtin_call_two_comma,
                         .main_token = builtin_token,
                         .data = .{
                             .lhs = param_one,
@@ -3924,7 +3924,7 @@ const Parser = struct {
                 }
             },
             .r_paren => return p.addNode(.{
-                .tag = .BuiltinCallTwo,
+                .tag = .builtin_call_two,
                 .main_token = builtin_token,
                 .data = .{
                     .lhs = param_one,
@@ -3954,7 +3954,7 @@ const Parser = struct {
                     if (p.eatToken(.r_paren)) |_| {
                         const params = try p.listToSpan(list.items);
                         return p.addNode(.{
-                            .tag = .BuiltinCallComma,
+                            .tag = .builtin_call_comma,
                             .main_token = builtin_token,
                             .data = .{
                                 .lhs = params.start,
@@ -3967,7 +3967,7 @@ const Parser = struct {
                 .r_paren => {
                     const params = try p.listToSpan(list.items);
                     return p.addNode(.{
-                        .tag = .BuiltinCall,
+                        .tag = .builtin_call,
                         .main_token = builtin_token,
                         .data = .{
                             .lhs = params.start,
@@ -3993,7 +3993,7 @@ const Parser = struct {
             .string_literal => {
                 const main_token = p.nextToken();
                 return p.addNode(.{
-                    .tag = .StringLiteral,
+                    .tag = .string_literal,
                     .main_token = main_token,
                     .data = .{
                         .lhs = main_token,
@@ -4007,7 +4007,7 @@ const Parser = struct {
                     p.tok_i += 1;
                 }
                 return p.addNode(.{
-                    .tag = .StringLiteral,
+                    .tag = .string_literal,
                     .main_token = first_line,
                     .data = .{
                         .lhs = first_line,
@@ -4029,7 +4029,7 @@ const Parser = struct {
 
     fn expectIntegerLiteral(p: *Parser) !Node.Index {
         return p.addNode(.{
-            .tag = .IntegerLiteral,
+            .tag = .integer_literal,
             .main_token = try p.expectToken(.integer_literal),
             .data = .{
                 .lhs = undefined,
@@ -4050,7 +4050,7 @@ const Parser = struct {
         if (then_expr == 0) return p.fail(.{ .InvalidToken = .{ .token = p.tok_i } });
 
         const else_token = p.eatToken(.keyword_else) orelse return p.addNode(.{
-            .tag = .IfSimple,
+            .tag = .if_simple,
             .main_token = if_token,
             .data = .{
                 .lhs = condition,
@@ -4062,7 +4062,7 @@ const Parser = struct {
         if (else_expr == 0) return p.fail(.{ .InvalidToken = .{ .token = p.tok_i } });
 
         return p.addNode(.{
-            .tag = .If,
+            .tag = .@"if",
             .main_token = if_token,
             .data = .{
                 .lhs = condition,
diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig
index 0f14856fdf..1510409ae1 100644
--- a/lib/std/zig/render.zig
+++ b/lib/std/zig/render.zig
@@ -96,7 +96,7 @@ fn renderMember(ais: *Ais, tree: ast.Tree, decl: ast.Node.Index, space: Space) E
     const datas = tree.nodes.items(.data);
     try renderDocComments(ais, tree, tree.firstToken(decl));
     switch (tree.nodes.items(.tag)[decl]) {
-        .FnDecl => {
+        .fn_decl => {
             // Some examples:
             // pub extern "foo" fn ...
             // export fn ...
@@ -132,16 +132,16 @@ fn renderMember(ais: *Ais, tree: ast.Tree, decl: ast.Node.Index, space: Space) E
                 return renderToken(ais, tree, tree.lastToken(fn_proto) + 1, space); // semicolon
             }
         },
-        .FnProtoSimple,
-        .FnProtoMulti,
-        .FnProtoOne,
-        .FnProto,
+        .fn_proto_simple,
+        .fn_proto_multi,
+        .fn_proto_one,
+        .fn_proto,
         => {
             try renderExpression(ais, tree, decl, .None);
             return renderToken(ais, tree, tree.lastToken(decl) + 1, space); // semicolon
         },
 
-        .UsingNamespace => {
+        .@"usingnamespace" => {
             const main_token = main_tokens[decl];
             const expr = datas[decl].lhs;
             if (main_token > 0 and token_tags[main_token - 1] == .keyword_pub) {
@@ -152,12 +152,12 @@ fn renderMember(ais: *Ais, tree: ast.Tree, decl: ast.Node.Index, space: Space) E
             return renderToken(ais, tree, tree.lastToken(expr) + 1, space); // ;
         },
 
-        .GlobalVarDecl => return renderVarDecl(ais, tree, tree.globalVarDecl(decl)),
-        .LocalVarDecl => return renderVarDecl(ais, tree, tree.localVarDecl(decl)),
-        .SimpleVarDecl => return renderVarDecl(ais, tree, tree.simpleVarDecl(decl)),
-        .AlignedVarDecl => return renderVarDecl(ais, tree, tree.alignedVarDecl(decl)),
+        .global_var_decl => return renderVarDecl(ais, tree, tree.globalVarDecl(decl)),
+        .local_var_decl => return renderVarDecl(ais, tree, tree.localVarDecl(decl)),
+        .simple_var_decl => return renderVarDecl(ais, tree, tree.simpleVarDecl(decl)),
+        .aligned_var_decl => return renderVarDecl(ais, tree, tree.alignedVarDecl(decl)),
 
-        .TestDecl => {
+        .test_decl => {
             const test_token = main_tokens[decl];
             try renderToken(ais, tree, test_token, .Space);
             if (token_tags[test_token + 1] == .string_literal) {
@@ -166,12 +166,12 @@ fn renderMember(ais: *Ais, tree: ast.Tree, decl: ast.Node.Index, space: Space) E
             try renderExpression(ais, tree, datas[decl].rhs, space);
         },
 
-        .ContainerFieldInit => return renderContainerField(ais, tree, tree.containerFieldInit(decl), space),
-        .ContainerFieldAlign => return renderContainerField(ais, tree, tree.containerFieldAlign(decl), space),
-        .ContainerField => return renderContainerField(ais, tree, tree.containerField(decl), space),
-        .Comptime => return renderExpression(ais, tree, decl, space),
+        .container_field_init => return renderContainerField(ais, tree, tree.containerFieldInit(decl), space),
+        .container_field_align => return renderContainerField(ais, tree, tree.containerFieldAlign(decl), space),
+        .container_field => return renderContainerField(ais, tree, tree.containerField(decl), space),
+        .@"comptime" => return renderExpression(ais, tree, decl, space),
 
-        .Root => unreachable,
+        .root => unreachable,
         else => unreachable,
     }
 }
@@ -182,29 +182,29 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
     const node_tags = tree.nodes.items(.tag);
     const datas = tree.nodes.items(.data);
     switch (node_tags[node]) {
-        .Identifier,
-        .IntegerLiteral,
-        .FloatLiteral,
-        .StringLiteral,
-        .CharLiteral,
-        .TrueLiteral,
-        .FalseLiteral,
-        .NullLiteral,
-        .UnreachableLiteral,
-        .UndefinedLiteral,
-        .AnyFrameLiteral,
+        .identifier,
+        .integer_literal,
+        .float_literal,
+        .string_literal,
+        .char_literal,
+        .true_literal,
+        .false_literal,
+        .null_literal,
+        .unreachable_literal,
+        .undefined_literal,
+        .anyframe_literal,
         => return renderToken(ais, tree, main_tokens[node], space),
 
-        .ErrorValue => {
+        .error_value => {
             try renderToken(ais, tree, main_tokens[node], .None);
             try renderToken(ais, tree, main_tokens[node] + 1, .None);
             return renderToken(ais, tree, main_tokens[node] + 2, space);
         },
 
-        .AnyType => return renderToken(ais, tree, main_tokens[node], space),
+        .@"anytype" => return renderToken(ais, tree, main_tokens[node], space),
 
-        .BlockTwo,
-        .BlockTwoSemicolon,
+        .block_two,
+        .block_two_semicolon,
         => {
             const statements = [2]ast.Node.Index{ datas[node].lhs, datas[node].rhs };
             if (datas[node].lhs == 0) {
@@ -215,14 +215,14 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
                 return renderBlock(ais, tree, node, statements[0..2], space);
             }
         },
-        .Block,
-        .BlockSemicolon,
+        .block,
+        .block_semicolon,
         => {
             const statements = tree.extra_data[datas[node].lhs..datas[node].rhs];
             return renderBlock(ais, tree, node, statements, space);
         },
 
-        .ErrDefer => {
+        .@"errdefer" => {
             const defer_token = main_tokens[node];
             const payload_token = datas[node].lhs;
             const expr = datas[node].rhs;
@@ -236,20 +236,20 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             return renderExpression(ais, tree, expr, space);
         },
 
-        .Defer => {
+        .@"defer" => {
             const defer_token = main_tokens[node];
             const expr = datas[node].rhs;
             try renderToken(ais, tree, defer_token, .Space);
             return renderExpression(ais, tree, expr, space);
         },
-        .Comptime, .Nosuspend => {
+        .@"comptime", .@"nosuspend" => {
             const comptime_token = main_tokens[node];
             const block = datas[node].lhs;
             try renderToken(ais, tree, comptime_token, .Space);
             return renderExpression(ais, tree, block, space);
         },
 
-        .Suspend => {
+        .@"suspend" => {
             const suspend_token = main_tokens[node];
             const body = datas[node].lhs;
             if (body != 0) {
@@ -260,7 +260,7 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             }
         },
 
-        .Catch => {
+        .@"catch" => {
             const main_token = main_tokens[node];
             const fallback_first = tree.firstToken(datas[node].rhs);
 
@@ -283,15 +283,15 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             try renderExpression(ais, tree, datas[node].rhs, space); // fallback
         },
 
-        .FieldAccess => {
+        .field_access => {
             const field_access = datas[node];
             try renderExpression(ais, tree, field_access.lhs, .None);
             try renderToken(ais, tree, main_tokens[node], .None);
             return renderToken(ais, tree, field_access.rhs, space);
         },
 
-        .ErrorUnion,
-        .SwitchRange,
+        .error_union,
+        .switch_range,
         => {
             const infix = datas[node];
             try renderExpression(ais, tree, infix.lhs, .None);
@@ -299,45 +299,45 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             return renderExpression(ais, tree, infix.rhs, space);
         },
 
-        .Add,
-        .AddWrap,
-        .ArrayCat,
-        .ArrayMult,
-        .Assign,
-        .AssignBitAnd,
-        .AssignBitOr,
-        .AssignBitShiftLeft,
-        .AssignBitShiftRight,
-        .AssignBitXor,
-        .AssignDiv,
-        .AssignSub,
-        .AssignSubWrap,
-        .AssignMod,
-        .AssignAdd,
-        .AssignAddWrap,
-        .AssignMul,
-        .AssignMulWrap,
-        .BangEqual,
-        .BitAnd,
-        .BitOr,
-        .BitShiftLeft,
-        .BitShiftRight,
-        .BitXor,
-        .BoolAnd,
-        .BoolOr,
-        .Div,
-        .EqualEqual,
-        .GreaterOrEqual,
-        .GreaterThan,
-        .LessOrEqual,
-        .LessThan,
-        .MergeErrorSets,
-        .Mod,
-        .Mul,
-        .MulWrap,
-        .Sub,
-        .SubWrap,
-        .OrElse,
+        .add,
+        .add_wrap,
+        .array_cat,
+        .array_mult,
+        .assign,
+        .assign_bit_and,
+        .assign_bit_or,
+        .assign_bit_shift_left,
+        .assign_bit_shift_right,
+        .assign_bit_xor,
+        .assign_div,
+        .assign_sub,
+        .assign_sub_wrap,
+        .assign_mod,
+        .assign_add,
+        .assign_add_wrap,
+        .assign_mul,
+        .assign_mul_wrap,
+        .bang_equal,
+        .bit_and,
+        .bit_or,
+        .bit_shift_left,
+        .bit_shift_right,
+        .bit_xor,
+        .bool_and,
+        .bool_or,
+        .div,
+        .equal_equal,
+        .greater_or_equal,
+        .greater_than,
+        .less_or_equal,
+        .less_than,
+        .merge_error_sets,
+        .mod,
+        .mul,
+        .mul_wrap,
+        .sub,
+        .sub_wrap,
+        .@"orelse",
         => {
             const infix = datas[node];
             try renderExpression(ais, tree, infix.lhs, .Space);
@@ -353,75 +353,75 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             return renderExpression(ais, tree, infix.rhs, space);
         },
 
-        .BitNot,
-        .BoolNot,
-        .Negation,
-        .NegationWrap,
-        .OptionalType,
-        .AddressOf,
+        .bit_not,
+        .bool_not,
+        .negation,
+        .negation_wrap,
+        .optional_type,
+        .address_of,
         => {
             try renderToken(ais, tree, main_tokens[node], .None);
             return renderExpression(ais, tree, datas[node].lhs, space);
         },
 
-        .Try,
-        .Resume,
-        .Await,
+        .@"try",
+        .@"resume",
+        .@"await",
         => {
             try renderToken(ais, tree, main_tokens[node], .Space);
             return renderExpression(ais, tree, datas[node].lhs, space);
         },
 
-        .ArrayType => return renderArrayType(ais, tree, tree.arrayType(node), space),
-        .ArrayTypeSentinel => return renderArrayType(ais, tree, tree.arrayTypeSentinel(node), space),
+        .array_type => return renderArrayType(ais, tree, tree.arrayType(node), space),
+        .array_type_sentinel => return renderArrayType(ais, tree, tree.arrayTypeSentinel(node), space),
 
-        .PtrTypeAligned => return renderPtrType(ais, tree, tree.ptrTypeAligned(node), space),
-        .PtrTypeSentinel => return renderPtrType(ais, tree, tree.ptrTypeSentinel(node), space),
-        .PtrType => return renderPtrType(ais, tree, tree.ptrType(node), space),
-        .PtrTypeBitRange => return renderPtrType(ais, tree, tree.ptrTypeBitRange(node), space),
+        .ptr_type_aligned => return renderPtrType(ais, tree, tree.ptrTypeAligned(node), space),
+        .ptr_type_sentinel => return renderPtrType(ais, tree, tree.ptrTypeSentinel(node), space),
+        .ptr_type => return renderPtrType(ais, tree, tree.ptrType(node), space),
+        .ptr_type_bit_range => return renderPtrType(ais, tree, tree.ptrTypeBitRange(node), space),
 
-        .ArrayInitOne, .ArrayInitOneComma => {
+        .array_init_one, .array_init_one_comma => {
             var elements: [1]ast.Node.Index = undefined;
             return renderArrayInit(ais, tree, tree.arrayInitOne(&elements, node), space);
         },
-        .ArrayInitDotTwo, .ArrayInitDotTwoComma => {
+        .array_init_dot_two, .array_init_dot_two_comma => {
             var elements: [2]ast.Node.Index = undefined;
             return renderArrayInit(ais, tree, tree.arrayInitDotTwo(&elements, node), space);
         },
-        .ArrayInitDot,
-        .ArrayInitDotComma,
+        .array_init_dot,
+        .array_init_dot_comma,
         => return renderArrayInit(ais, tree, tree.arrayInitDot(node), space),
-        .ArrayInit,
-        .ArrayInitComma,
+        .array_init,
+        .array_init_comma,
         => return renderArrayInit(ais, tree, tree.arrayInit(node), space),
 
-        .StructInitOne, .StructInitOneComma => {
+        .struct_init_one, .struct_init_one_comma => {
             var fields: [1]ast.Node.Index = undefined;
             return renderStructInit(ais, tree, tree.structInitOne(&fields, node), space);
         },
-        .StructInitDotTwo, .StructInitDotTwoComma => {
+        .struct_init_dot_two, .struct_init_dot_two_comma => {
             var fields: [2]ast.Node.Index = undefined;
             return renderStructInit(ais, tree, tree.structInitDotTwo(&fields, node), space);
         },
-        .StructInitDot,
-        .StructInitDotComma,
+        .struct_init_dot,
+        .struct_init_dot_comma,
         => return renderStructInit(ais, tree, tree.structInitDot(node), space),
-        .StructInit,
-        .StructInitComma,
+        .struct_init,
+        .struct_init_comma,
         => return renderStructInit(ais, tree, tree.structInit(node), space),
 
-        .CallOne, .CallOneComma, .AsyncCallOne, .AsyncCallOneComma => {
+        .call_one, .call_one_comma, .async_call_one, .async_call_one_comma => {
             var params: [1]ast.Node.Index = undefined;
             return renderCall(ais, tree, tree.callOne(&params, node), space);
         },
 
-        .Call,
-        .CallComma,
-        .AsyncCall,
-        .AsyncCallComma,
+        .call,
+        .call_comma,
+        .async_call,
+        .async_call_comma,
         => return renderCall(ais, tree, tree.callFull(node), space),
 
-        .ArrayAccess => {
+        .array_access => {
             const suffix = datas[node];
             const lbracket = tree.firstToken(suffix.rhs) - 1;
             const rbracket = tree.lastToken(suffix.rhs) + 1;
@@ -431,22 +431,22 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             return renderToken(ais, tree, rbracket, space); // ]
         },
 
-        .SliceOpen => try renderSlice(ais, tree, tree.sliceOpen(node), space),
-        .Slice => try renderSlice(ais, tree, tree.slice(node), space),
-        .SliceSentinel => try renderSlice(ais, tree, tree.sliceSentinel(node), space),
+        .slice_open => try renderSlice(ais, tree, tree.sliceOpen(node), space),
+        .slice => try renderSlice(ais, tree, tree.slice(node), space),
+        .slice_sentinel => try renderSlice(ais, tree, tree.sliceSentinel(node), space),
 
-        .Deref => {
+        .deref => {
             try renderExpression(ais, tree, datas[node].lhs, .None);
             return renderToken(ais, tree, main_tokens[node], space);
         },
 
-        .UnwrapOptional => {
+        .unwrap_optional => {
             try renderExpression(ais, tree, datas[node].lhs, .None);
             try renderToken(ais, tree, main_tokens[node], .None);
             return renderToken(ais, tree, datas[node].rhs, space);
         },
 
-        .Break => {
+        .@"break" => {
             const main_token = main_tokens[node];
             const label_token = datas[node].lhs;
             const target = datas[node].rhs;
@@ -467,7 +467,7 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             }
         },
 
-        .Continue => {
+        .@"continue" => {
             const main_token = main_tokens[node];
             const label = datas[node].lhs;
             if (label != 0) {
@@ -479,7 +479,7 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             }
         },
 
-        .Return => {
+        .@"return" => {
             if (datas[node].lhs != 0) {
                 try renderToken(ais, tree, main_tokens[node], .Space);
                 try renderExpression(ais, tree, datas[node].lhs, space);
@@ -488,7 +488,7 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             }
         },
 
-        .GroupedExpression => {
+        .grouped_expression => {
             ais.pushIndentNextLine();
             try renderToken(ais, tree, main_tokens[node], .None); // lparen
             try renderExpression(ais, tree, datas[node].lhs, .None);
@@ -496,32 +496,32 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             return renderToken(ais, tree, datas[node].rhs, space); // rparen
         },
 
-        .ContainerDecl,
-        .ContainerDeclComma,
+        .container_decl,
+        .container_decl_comma,
         => return renderContainerDecl(ais, tree, tree.containerDecl(node), space),
 
-        .ContainerDeclTwo, .ContainerDeclTwoComma => {
+        .container_decl_two, .container_decl_two_comma => {
             var buffer: [2]ast.Node.Index = undefined;
             return renderContainerDecl(ais, tree, tree.containerDeclTwo(&buffer, node), space);
         },
-        .ContainerDeclArg,
-        .ContainerDeclArgComma,
+        .container_decl_arg,
+        .container_decl_arg_comma,
         => return renderContainerDecl(ais, tree, tree.containerDeclArg(node), space),
 
-        .TaggedUnion,
-        .TaggedUnionComma,
+        .tagged_union,
+        .tagged_union_comma,
         => return renderContainerDecl(ais, tree, tree.taggedUnion(node), space),
 
-        .TaggedUnionTwo, .TaggedUnionTwoComma => {
+        .tagged_union_two, .tagged_union_two_comma => {
             var buffer: [2]ast.Node.Index = undefined;
             return renderContainerDecl(ais, tree, tree.taggedUnionTwo(&buffer, node), space);
         },
-        .TaggedUnionEnumTag,
-        .TaggedUnionEnumTagComma,
+        .tagged_union_enum_tag,
+        .tagged_union_enum_tag_comma,
         => return renderContainerDecl(ais, tree, tree.taggedUnionEnumTag(node), space),
 
         // TODO: handle comments properly
-        .ErrorSetDecl => {
+        .error_set_decl => {
             const error_token = main_tokens[node];
             const lbrace = error_token + 1;
             const rbrace = datas[node].rhs;
@@ -569,7 +569,7 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             }
         },
 
-        .BuiltinCallTwo, .BuiltinCallTwoComma => {
+        .builtin_call_two, .builtin_call_two_comma => {
             if (datas[node].lhs == 0) {
                 const params = [_]ast.Node.Index{};
                 return renderBuiltinCall(ais, tree, main_tokens[node], &params, space);
@@ -581,23 +581,23 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
                 return renderBuiltinCall(ais, tree, main_tokens[node], &params, space);
             }
         },
-        .BuiltinCall, .BuiltinCallComma => {
+        .builtin_call, .builtin_call_comma => {
             const params = tree.extra_data[datas[node].lhs..datas[node].rhs];
             return renderBuiltinCall(ais, tree, main_tokens[node], params, space);
         },
 
-        .FnProtoSimple => {
+        .fn_proto_simple => {
             var params: [1]ast.Node.Index = undefined;
             return renderFnProto(ais, tree, tree.fnProtoSimple(&params, node), space);
         },
-        .FnProtoMulti => return renderFnProto(ais, tree, tree.fnProtoMulti(node), space),
-        .FnProtoOne => {
+        .fn_proto_multi => return renderFnProto(ais, tree, tree.fnProtoMulti(node), space),
+        .fn_proto_one => {
             var params: [1]ast.Node.Index = undefined;
             return renderFnProto(ais, tree, tree.fnProtoOne(&params, node), space);
         },
-        .FnProto => return renderFnProto(ais, tree, tree.fnProto(node), space),
+        .fn_proto => return renderFnProto(ais, tree, tree.fnProto(node), space),
 
-        .AnyFrameType => {
+        .anyframe_type => {
             const main_token = main_tokens[node];
             if (datas[node].rhs != 0) {
                 try renderToken(ais, tree, main_token, .None); // anyframe
@@ -608,8 +608,8 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             }
         },
 
-        .Switch,
-        .SwitchComma,
+        .@"switch",
+        .switch_comma,
         => {
             const switch_token = main_tokens[node];
             const condition = datas[node].lhs;
@@ -635,39 +635,39 @@ fn renderExpression(ais: *Ais, tree: ast.Tree, node: ast.Node.Index, space: Spac
             return renderToken(ais, tree, tree.lastToken(node), space); // rbrace
         },
 
-        .SwitchCaseOne => return renderSwitchCase(ais, tree, tree.switchCaseOne(node), space),
-        .SwitchCase => return renderSwitchCase(ais, tree, tree.switchCase(node), space),
+        .switch_case_one => return renderSwitchCase(ais, tree, tree.switchCaseOne(node), space),
+        .switch_case => return renderSwitchCase(ais, tree, tree.switchCase(node), space),
 
-        .WhileSimple => return renderWhile(ais, tree, tree.whileSimple(node), space),
-        .WhileCont => return renderWhile(ais, tree, tree.whileCont(node), space),
-        .While => return renderWhile(ais, tree, tree.whileFull(node), space),
-        .ForSimple => return renderWhile(ais, tree, tree.forSimple(node), space),
-        .For => return renderWhile(ais, tree, tree.forFull(node), space),
+        .while_simple => return renderWhile(ais, tree, tree.whileSimple(node), space),
+        .while_cont => return renderWhile(ais, tree, tree.whileCont(node), space),
+        .@"while" => return renderWhile(ais, tree, tree.whileFull(node), space),
+        .for_simple => return renderWhile(ais, tree, tree.forSimple(node), space),
+        .@"for" => return renderWhile(ais, tree, tree.forFull(node), space),
 
-        .IfSimple => return renderIf(ais, tree, tree.ifSimple(node), space),
-        .If => return renderIf(ais, tree, tree.ifFull(node), space),
+        .if_simple => return renderIf(ais, tree, tree.ifSimple(node), space),
+        .@"if" => return renderIf(ais, tree, tree.ifFull(node), space),
 
-        .AsmSimple => return renderAsm(ais, tree, tree.asmSimple(node), space),
-        .Asm => return renderAsm(ais, tree, tree.asmFull(node), space),
+        .asm_simple => return renderAsm(ais, tree, tree.asmSimple(node), space),
+        .@"asm" => return renderAsm(ais, tree, tree.asmFull(node), space),
 
-        .EnumLiteral => {
+        .enum_literal => {
             try renderToken(ais, tree, main_tokens[node] - 1, .None); // .
             return renderToken(ais, tree, main_tokens[node], space); // name
         },
 
-        .FnDecl => unreachable,
-        .ContainerField => unreachable,
-        .ContainerFieldInit => unreachable,
-        .ContainerFieldAlign => unreachable,
-        .Root => unreachable,
-        .GlobalVarDecl => unreachable,
-        .LocalVarDecl => unreachable,
-        .SimpleVarDecl => unreachable,
-        .AlignedVarDecl => unreachable,
-        .UsingNamespace => unreachable,
-        .TestDecl => unreachable,
-        .AsmOutput => unreachable,
-        .AsmInput => unreachable,
+        .fn_decl => unreachable,
+        .container_field => unreachable,
+        .container_field_init => unreachable,
+        .container_field_align => unreachable,
+        .root => unreachable,
+        .global_var_decl => unreachable,
+        .local_var_decl => unreachable,
+        .simple_var_decl => unreachable,
+        .aligned_var_decl => unreachable,
+        .@"usingnamespace" => unreachable,
+        .test_decl => unreachable,
+        .asm_output => unreachable,
+        .asm_input => unreachable,
     }
 }
 
@@ -814,7 +814,7 @@ fn renderAsmOutput(
     const node_tags = tree.nodes.items(.tag);
     const main_tokens = tree.nodes.items(.main_token);
     const datas = tree.nodes.items(.data);
-    assert(node_tags[asm_output] == .AsmOutput);
+    assert(node_tags[asm_output] == .asm_output);
     const symbolic_name = main_tokens[asm_output];
 
     try renderToken(ais, tree, symbolic_name - 1, .None); // lbracket
@@ -842,7 +842,7 @@ fn renderAsmInput(
     const node_tags = tree.nodes.items(.tag);
     const main_tokens = tree.nodes.items(.main_token);
     const datas = tree.nodes.items(.data);
-    assert(node_tags[asm_input] == .AsmInput);
+    assert(node_tags[asm_input] == .asm_input);
     const symbolic_name = main_tokens[asm_input];
 
     try renderToken(ais, tree, symbolic_name - 1, .None); // lbracket
@@ -1516,10 +1516,10 @@ fn renderBlock(
     try renderToken(ais, tree, lbrace, .Newline);
     for (statements) |stmt, i| {
         switch (node_tags[stmt]) {
-            .GlobalVarDecl => try renderVarDecl(ais, tree, tree.globalVarDecl(stmt)),
-            .LocalVarDecl => try renderVarDecl(ais, tree, tree.localVarDecl(stmt)),
-            .SimpleVarDecl => try renderVarDecl(ais, tree, tree.simpleVarDecl(stmt)),
-            .AlignedVarDecl => try renderVarDecl(ais, tree, tree.alignedVarDecl(stmt)),
+            .global_var_decl => try renderVarDecl(ais, tree, tree.globalVarDecl(stmt)),
+            .local_var_decl => try renderVarDecl(ais, tree, tree.localVarDecl(stmt)),
+            .simple_var_decl => try renderVarDecl(ais, tree, tree.simpleVarDecl(stmt)),
+            .aligned_var_decl => try renderVarDecl(ais, tree, tree.alignedVarDecl(stmt)),
             else => try renderExpression(ais, tree, stmt, .Semicolon),
         }
     }
@@ -1867,7 +1867,7 @@ fn renderCall(
                 try renderExpression(ais, tree, param_node, Space.None);
 
                 // Unindent the comma for multiline string literals
-                const is_multiline_string = node_tags[param_node] == .StringLiteral and
+                const is_multiline_string = node_tags[param_node] == .string_literal and
                     token_tags[main_tokens[param_node]] == .multiline_string_literal_line;
                 if (is_multiline_string) ais.popIndent();
 
@@ -2031,19 +2031,19 @@ fn renderDocComments(ais: *Ais, tree: ast.Tree, end_token: ast.TokenIndex) Error
 
 fn nodeIsBlock(tag: ast.Node.Tag) bool {
     return switch (tag) {
-        .Block,
-        .BlockSemicolon,
-        .BlockTwo,
-        .BlockTwoSemicolon,
-        .If,
-        .IfSimple,
-        .For,
-        .ForSimple,
-        .While,
-        .WhileSimple,
-        .WhileCont,
-        .Switch,
-        .SwitchComma,
+        .block,
+        .block_semicolon,
+        .block_two,
+        .block_two_semicolon,
+        .@"if",
+        .if_simple,
+        .@"for",
+        .for_simple,
+        .@"while",
+        .while_simple,
+        .while_cont,
+        .@"switch",
+        .switch_comma,
         => true,
         else => false,
     };
@@ -2051,47 +2051,47 @@ fn nodeIsBlock(tag: ast.Node.Tag) bool {
 
 fn nodeCausesSliceOpSpace(tag: ast.Node.Tag) bool {
     return switch (tag) {
-        .Catch,
-        .Add,
-        .AddWrap,
-        .ArrayCat,
-        .ArrayMult,
-        .Assign,
-        .AssignBitAnd,
-        .AssignBitOr,
-        .AssignBitShiftLeft,
-        .AssignBitShiftRight,
-        .AssignBitXor,
-        .AssignDiv,
-        .AssignSub,
-        .AssignSubWrap,
-        .AssignMod,
-        .AssignAdd,
-        .AssignAddWrap,
-        .AssignMul,
-        .AssignMulWrap,
-        .BangEqual,
-        .BitAnd,
-        .BitOr,
-        .BitShiftLeft,
-        .BitShiftRight,
-        .BitXor,
-        .BoolAnd,
-        .BoolOr,
-        .Div,
-        .EqualEqual,
-        .ErrorUnion,
-        .GreaterOrEqual,
-        .GreaterThan,
-        .LessOrEqual,
-        .LessThan,
-        .MergeErrorSets,
-        .Mod,
-        .Mul,
-        .MulWrap,
-        .Sub,
-        .SubWrap,
-        .OrElse,
+        .@"catch",
+        .add,
+        .add_wrap,
+        .array_cat,
+        .array_mult,
+        .assign,
+        .assign_bit_and,
+        .assign_bit_or,
+        .assign_bit_shift_left,
+        .assign_bit_shift_right,
+        .assign_bit_xor,
+        .assign_div,
+        .assign_sub,
+        .assign_sub_wrap,
+        .assign_mod,
+        .assign_add,
+        .assign_add_wrap,
+        .assign_mul,
+        .assign_mul_wrap,
+        .bang_equal,
+        .bit_and,
+        .bit_or,
+        .bit_shift_left,
+        .bit_shift_right,
+        .bit_xor,
+        .bool_and,
+        .bool_or,
+        .div,
+        .equal_equal,
+        .error_union,
+        .greater_or_equal,
+        .greater_than,
+        .less_or_equal,
+        .less_than,
+        .merge_error_sets,
+        .mod,
+        .mul,
+        .mul_wrap,
+        .sub,
+        .sub_wrap,
+        .@"orelse",
         => true,
 
         else => false,
author	Veikka Tuominen <git@vexu.eu>	2021-02-12 01:38:10 +0200
committer	Veikka Tuominen <git@vexu.eu>	2021-02-12 02:12:43 +0200
commit	bb22490fcc8ed7c96d665242cd18934f9d547555 (patch)
tree	5703427c6d2830c87b001fdd8b57fbb63a22a46b /lib/std
parent	e2289961c6b53451e5bdcdfb6eec27e27f6553ca (diff)
download	zig-bb22490fcc8ed7c96d665242cd18934f9d547555.tar.gz zig-bb22490fcc8ed7c96d665242cd18934f9d547555.zip