Commit bb22490fcc
Changed files (3)
lib
std
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,
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,
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(¶ms, 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], ¶ms, 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], ¶ms, 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(¶ms, 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(¶ms, 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,