From 1884ad0ea37fcb01f763987a930715ba6ab737c7 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sun, 18 May 2025 12:47:16 -0700 Subject: [PATCH] wip --- lib/std/zig/Ast.zig | 728 +++++++++++++++++----------------- lib/std/zig/AstGen.zig | 353 +++++++++-------- lib/std/zig/AstRlAnnotate.zig | 88 ++-- lib/std/zig/ZonGen.zig | 56 +-- lib/std/zig/render.zig | 180 ++++----- lib/std/zon/parse.zig | 10 +- src/Package/Manifest.zig | 72 ++-- src/Sema.zig | 4 +- src/Zcu.zig | 102 ++--- src/Zcu/PerThread.zig | 2 +- src/fmt.zig | 8 +- src/main.zig | 2 +- 12 files changed, 803 insertions(+), 802 deletions(-) diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig index d0e819e943..dee180404c 100644 --- a/lib/std/zig/Ast.zig +++ b/lib/std/zig/Ast.zig @@ -83,18 +83,6 @@ pub fn tokenStart(tree: *const Ast, token_index: TokenIndex) ByteOffset { return tree.tokens.items(.start)[token_index]; } -pub fn nodeTag(tree: *const Ast, node: Node.Index) Node.Tag { - return tree.nodes.items(.tag)[@intFromEnum(node)]; -} - -pub fn nodeMainToken(tree: *const Ast, node: Node.Index) TokenIndex { - return tree.nodes.items(.main_token)[@intFromEnum(node)]; -} - -pub fn nodeData(tree: *const Ast, node: Node.Index) Node.Data { - return tree.nodes.items(.data)[@intFromEnum(node)]; -} - pub fn isTokenPrecededByTags( tree: *const Ast, ti: TokenIndex, @@ -199,7 +187,7 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A /// `gpa` is used for allocating the resulting formatted source code. /// Caller owns the returned slice of bytes, allocated with `gpa`. -pub fn render(tree: Ast, gpa: Allocator) RenderError![]u8 { +pub fn render(tree: *const Ast, gpa: Allocator) RenderError![]u8 { var buffer = std.ArrayList(u8).init(gpa); defer buffer.deinit(); @@ -209,20 +197,20 @@ pub fn render(tree: Ast, gpa: Allocator) RenderError![]u8 { pub const Fixups = private_render.Fixups; -pub fn renderToArrayList(tree: Ast, buffer: *std.ArrayList(u8), fixups: Fixups) RenderError!void { +pub fn renderToArrayList(tree: *const Ast, buffer: *std.ArrayList(u8), fixups: Fixups) RenderError!void { return @import("./render.zig").renderTree(buffer, tree, fixups); } /// Returns an extra offset for column and byte offset of errors that /// should point after the token in the error message. -pub fn errorOffset(tree: Ast, parse_error: Error) u32 { +pub fn errorOffset(tree: *const Ast, parse_error: Error) u32 { return if (parse_error.token_is_prev) @as(u32, @intCast(tree.tokenSlice(parse_error.token).len)) else 0; } -pub fn tokenLocation(self: Ast, start_offset: ByteOffset, token_index: TokenIndex) Location { +pub fn tokenLocation(self: *const Ast, start_offset: ByteOffset, token_index: TokenIndex) Location { var loc = Location{ .line = 0, .column = 0, @@ -260,7 +248,7 @@ pub fn tokenLocation(self: Ast, start_offset: ByteOffset, token_index: TokenInde return loc; } -pub fn tokenSlice(tree: Ast, token_index: TokenIndex) []const u8 { +pub fn tokenSlice(tree: *const Ast, token_index: TokenIndex) []const u8 { const token_tag = tree.tokenTag(token_index); // Many tokens can be determined entirely by their tag. @@ -278,15 +266,15 @@ pub fn tokenSlice(tree: Ast, token_index: TokenIndex) []const u8 { return tree.source[token.loc.start..token.loc.end]; } -pub fn extraDataSlice(tree: Ast, range: Node.SubRange, comptime T: type) []const T { +pub fn extraDataSlice(tree: *const Ast, range: Node.SubRange, comptime T: type) []const T { return @ptrCast(tree.extra_data[@intFromEnum(range.start)..@intFromEnum(range.end)]); } -pub fn extraDataSliceWithLen(tree: Ast, start: ExtraIndex, len: u32, comptime T: type) []const T { +pub fn extraDataSliceWithLen(tree: *const Ast, start: ExtraIndex, len: u32, comptime T: type) []const T { return @ptrCast(tree.extra_data[@intFromEnum(start)..][0..len]); } -pub fn extraData(tree: Ast, index: ExtraIndex, comptime T: type) T { +pub fn extraData(tree: *const Ast, index: ExtraIndex, comptime T: type) T { const fields = std.meta.fields(T); var result: T = undefined; inline for (fields, 0..) |field, i| { @@ -310,15 +298,15 @@ fn loadOptionalNodesIntoBuffer(comptime size: usize, buffer: *[size]Node.Index, return buffer[0..]; } -pub fn rootDecls(tree: Ast) []const Node.Index { +pub fn rootDecls(tree: *const Ast) []const Node.Index { switch (tree.mode) { - .zig => return tree.extraDataSlice(tree.nodeData(.root).extra_range, Node.Index), + .zig => return tree.extraDataSlice(Node.Index.root.data(tree).extra_range, Node.Index), // Ensure that the returned slice points into the existing memory of the Ast .zon => return (&tree.nodes.items(.data)[@intFromEnum(Node.Index.root)].node)[0..1], } } -pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void { +pub fn renderError(tree: *const Ast, parse_error: Error, stream: anytype) !void { switch (parse_error.tag) { .asterisk_after_ptr_deref => { // Note that the token will point at the `.*` but ideally the source @@ -591,10 +579,10 @@ pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void { } } -pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { +pub fn firstToken(tree: *const Ast, node: Node.Index) TokenIndex { var end_offset: u32 = 0; var n = node; - while (true) switch (tree.nodeTag(n)) { + while (true) switch (n.tag(tree)) { .root => return 0, .test_decl, @@ -638,7 +626,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .array_type, .array_type_sentinel, .error_value, - => return tree.nodeMainToken(n) - end_offset, + => return n.mainToken(tree) - end_offset, .array_init_dot, .array_init_dot_comma, @@ -649,7 +637,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .struct_init_dot_two, .struct_init_dot_two_comma, .enum_literal, - => return tree.nodeMainToken(n) - 1 - end_offset, + => return n.mainToken(tree) - 1 - end_offset, .@"catch", .equal_equal, @@ -705,18 +693,18 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .array_init_one_comma, .switch_range, .error_union, - => n = tree.nodeData(n).node_and_node[0], + => n = n.data(tree).node_and_node[0], .for_range, .call_one, .call_one_comma, .struct_init_one, .struct_init_one_comma, - => n = tree.nodeData(n).node_and_opt_node[0], + => n = n.data(tree).node_and_opt_node[0], .field_access, .unwrap_optional, - => n = tree.nodeData(n).node_and_token[0], + => n = n.data(tree).node_and_token[0], .slice, .slice_sentinel, @@ -726,9 +714,9 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .struct_init_comma, .call, .call_comma, - => n = tree.nodeData(n).node_and_extra[0], + => n = n.data(tree).node_and_extra[0], - .deref => n = tree.nodeData(n).node, + .deref => n = n.data(tree).node, .assign_destructure => n = tree.assignDestructure(n).ast.variables[0], @@ -738,7 +726,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .fn_proto_one, .fn_proto, => { - var i = tree.nodeMainToken(n); // fn token + var i = n.mainToken(tree); // fn token while (i > 0) { i -= 1; switch (tree.tokenTag(i)) { @@ -757,7 +745,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { }, .@"usingnamespace" => { - const main_token: TokenIndex = tree.nodeMainToken(n); + const main_token: TokenIndex = n.mainToken(tree); const has_visib_token = tree.isTokenPrecededByTags(main_token, &.{.keyword_pub}); end_offset += @intFromBool(has_visib_token); return main_token - end_offset; @@ -767,21 +755,21 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .async_call_one_comma, => { end_offset += 1; // async token - n = tree.nodeData(n).node_and_opt_node[0]; + n = n.data(tree).node_and_opt_node[0]; }, .async_call, .async_call_comma, => { end_offset += 1; // async token - n = tree.nodeData(n).node_and_extra[0]; + n = n.data(tree).node_and_extra[0]; }, .container_field_init, .container_field_align, .container_field, => { - const name_token = tree.nodeMainToken(n); + const name_token = n.mainToken(tree); const has_comptime_token = tree.isTokenPrecededByTags(name_token, &.{.keyword_comptime}); end_offset += @intFromBool(has_comptime_token); return name_token - end_offset; @@ -792,7 +780,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .simple_var_decl, .aligned_var_decl, => { - var i = tree.nodeMainToken(n); // mut token + var i = n.mainToken(tree); // mut token while (i > 0) { i -= 1; switch (tree.tokenTag(i)) { @@ -816,7 +804,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .block_two_semicolon, => { // Look for a label. - const lbrace = tree.nodeMainToken(n); + const lbrace = n.mainToken(tree); if (tree.isTokenPrecededByTags(lbrace, &.{ .identifier, .colon })) { end_offset += 2; } @@ -836,7 +824,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .tagged_union_enum_tag, .tagged_union_enum_tag_trailing, => { - const main_token = tree.nodeMainToken(n); + const main_token = n.mainToken(tree); switch (tree.tokenTag(main_token -| 1)) { .keyword_packed, .keyword_extern => end_offset += 1, else => {}, @@ -848,7 +836,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .ptr_type_sentinel, .ptr_type, .ptr_type_bit_range, - => return tree.nodeMainToken(n) - end_offset, + => return n.mainToken(tree) - end_offset, .switch_case_one, .switch_case_inline_one, @@ -866,8 +854,8 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { }, .asm_output, .asm_input => { - assert(tree.tokenTag(tree.nodeMainToken(n) - 1) == .l_bracket); - return tree.nodeMainToken(n) - 1 - end_offset; + assert(tree.tokenTag(n.mainToken(tree) - 1) == .l_bracket); + return n.mainToken(tree) - 1 - end_offset; }, .while_simple, @@ -877,7 +865,7 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { .@"for", => { // Look for a label and inline. - const main_token = tree.nodeMainToken(n); + const main_token = n.mainToken(tree); var result = main_token; if (tree.isTokenPrecededByTags(result, &.{.keyword_inline})) { result = result - 1; @@ -890,10 +878,10 @@ pub fn firstToken(tree: Ast, node: Node.Index) TokenIndex { }; } -pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { +pub fn lastToken(tree: *const Ast, node: Node.Index) TokenIndex { var n = node; var end_offset: u32 = 0; - while (true) switch (tree.nodeTag(n)) { + while (true) switch (n.tag(tree)) { .root => return @intCast(tree.tokens.len - 1), .@"usingnamespace", @@ -909,7 +897,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .@"resume", .@"nosuspend", .@"comptime", - => n = tree.nodeData(n).node, + => n = n.data(tree).node, .@"catch", .equal_equal, @@ -966,45 +954,45 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .fn_decl, .array_type, .switch_range, - => n = tree.nodeData(n).node_and_node[1], + => n = n.data(tree).node_and_node[1], - .test_decl, .@"errdefer" => n = tree.nodeData(n).opt_token_and_node[1], - .@"defer" => n = tree.nodeData(n).node, - .anyframe_type => n = tree.nodeData(n).token_and_node[1], + .test_decl, .@"errdefer" => n = n.data(tree).opt_token_and_node[1], + .@"defer" => n = n.data(tree).node, + .anyframe_type => n = n.data(tree).token_and_node[1], .switch_case_one, .switch_case_inline_one, .ptr_type_aligned, .ptr_type_sentinel, - => n = tree.nodeData(n).opt_node_and_node[1], + => n = n.data(tree).opt_node_and_node[1], .assign_destructure, .ptr_type, .ptr_type_bit_range, .switch_case, .switch_case_inline, - => n = tree.nodeData(n).extra_and_node[1], + => n = n.data(tree).extra_and_node[1], - .fn_proto_simple => n = tree.nodeData(n).opt_node_and_opt_node[1].unwrap().?, + .fn_proto_simple => n = n.data(tree).opt_node_and_opt_node[1].unwrap().?, .fn_proto_multi, .fn_proto_one, .fn_proto, - => n = tree.nodeData(n).extra_and_opt_node[1].unwrap().?, + => n = n.data(tree).extra_and_opt_node[1].unwrap().?, .for_range => { - n = tree.nodeData(n).node_and_opt_node[1].unwrap() orelse { - return tree.nodeMainToken(n) + end_offset; + n = n.data(tree).node_and_opt_node[1].unwrap() orelse { + return n.mainToken(tree) + end_offset; }; }, .field_access, .unwrap_optional, .asm_simple, - => return tree.nodeData(n).node_and_token[1] + end_offset, - .grouped_expression, .asm_input => return tree.nodeData(n).node_and_token[1] + end_offset, - .multiline_string_literal, .error_set_decl => return tree.nodeData(n).token_and_token[1] + end_offset, - .asm_output => return tree.nodeData(n).opt_node_and_token[1] + end_offset, - .error_value => return tree.nodeMainToken(n) + 2 + end_offset, + => return n.data(tree).node_and_token[1] + end_offset, + .grouped_expression, .asm_input => return n.data(tree).node_and_token[1] + end_offset, + .multiline_string_literal, .error_set_decl => return n.data(tree).token_and_token[1] + end_offset, + .asm_output => return n.data(tree).opt_node_and_token[1] + end_offset, + .error_value => return n.mainToken(tree) + 2 + end_offset, .anyframe_literal, .char_literal, @@ -1014,23 +1002,23 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .deref, .enum_literal, .string_literal, - => return tree.nodeMainToken(n) + end_offset, + => return n.mainToken(tree) + end_offset, .@"return" => { - n = tree.nodeData(n).opt_node.unwrap() orelse { - return tree.nodeMainToken(n) + end_offset; + n = n.data(tree).opt_node.unwrap() orelse { + return n.mainToken(tree) + end_offset; }; }, .call, .async_call => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const params = tree.extraData(extra_index, Node.SubRange); assert(params.start != params.end); end_offset += 1; // for the rparen n = @enumFromInt(tree.extra_data[@intFromEnum(params.end) - 1]); // last parameter }, .tagged_union_enum_tag => { - const arg, const extra_index = tree.nodeData(n).node_and_extra; + const arg, const extra_index = n.data(tree).node_and_extra; const members = tree.extraData(extra_index, Node.SubRange); if (members.start == members.end) { end_offset += 4; // for the rparen + rparen + lbrace + rbrace @@ -1044,14 +1032,14 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .async_call_comma, .tagged_union_enum_tag_trailing, => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const params = tree.extraData(extra_index, Node.SubRange); assert(params.start != params.end); end_offset += 2; // for the comma/semicolon + rparen/rbrace n = @enumFromInt(tree.extra_data[@intFromEnum(params.end) - 1]); // last parameter }, .@"switch" => { - const condition, const extra_index = tree.nodeData(n).node_and_extra; + const condition, const extra_index = n.data(tree).node_and_extra; const cases = tree.extraData(extra_index, Node.SubRange); if (cases.start == cases.end) { end_offset += 3; // rparen, lbrace, rbrace @@ -1062,7 +1050,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { } }, .container_decl_arg => { - const arg, const extra_index = tree.nodeData(n).node_and_extra; + const arg, const extra_index = n.data(tree).node_and_extra; const members = tree.extraData(extra_index, Node.SubRange); if (members.end == members.start) { end_offset += 3; // for the rparen + lbrace + rbrace @@ -1073,14 +1061,14 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { } }, .@"asm" => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.Asm); return extra.rparen + end_offset; }, .array_init, .struct_init, => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const elements = tree.extraData(extra_index, Node.SubRange); assert(elements.start != elements.end); end_offset += 1; // for the rbrace @@ -1091,7 +1079,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .container_decl_arg_trailing, .switch_comma, => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const members = tree.extraData(extra_index, Node.SubRange); assert(members.start != members.end); end_offset += 2; // for the comma + rbrace @@ -1104,7 +1092,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .tagged_union, .builtin_call, => { - const range = tree.nodeData(n).extra_range; + const range = n.data(tree).extra_range; assert(range.start != range.end); end_offset += 1; // for the rbrace n = @enumFromInt(tree.extra_data[@intFromEnum(range.end) - 1]); // last statement @@ -1116,7 +1104,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .tagged_union_trailing, .builtin_call_comma, => { - const range = tree.nodeData(n).extra_range; + const range = n.data(tree).extra_range; assert(range.start != range.end); end_offset += 2; // for the comma/semicolon + rbrace/rparen n = @enumFromInt(tree.extra_data[@intFromEnum(range.end) - 1]); // last member @@ -1124,10 +1112,10 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .call_one, .async_call_one, => { - _, const first_param = tree.nodeData(n).node_and_opt_node; + _, const first_param = n.data(tree).node_and_opt_node; end_offset += 1; // for the rparen n = first_param.unwrap() orelse { - return tree.nodeMainToken(n) + end_offset; + return n.mainToken(tree) + end_offset; }; }, @@ -1138,7 +1126,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .container_decl_two, .tagged_union_two, => { - const opt_lhs, const opt_rhs = tree.nodeData(n).opt_node_and_opt_node; + const opt_lhs, const opt_rhs = n.data(tree).opt_node_and_opt_node; if (opt_rhs.unwrap()) |rhs| { end_offset += 1; // for the rparen/rbrace n = rhs; @@ -1146,7 +1134,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { end_offset += 1; // for the rparen/rbrace n = lhs; } else { - switch (tree.nodeTag(n)) { + switch (n.tag(tree)) { .array_init_dot_two, .block_two, .struct_init_dot_two, @@ -1154,17 +1142,17 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .builtin_call_two => end_offset += 2, // lparen/lbrace + rparen/rbrace .container_decl_two => { var i: u32 = 2; // lbrace + rbrace - while (tree.tokenTag(tree.nodeMainToken(n) + i) == .container_doc_comment) i += 1; + while (tree.tokenTag(n.mainToken(tree) + i) == .container_doc_comment) i += 1; end_offset += i; }, .tagged_union_two => { var i: u32 = 5; // (enum) {} - while (tree.tokenTag(tree.nodeMainToken(n) + i) == .container_doc_comment) i += 1; + while (tree.tokenTag(n.mainToken(tree) + i) == .container_doc_comment) i += 1; end_offset += i; }, else => unreachable, } - return tree.nodeMainToken(n) + end_offset; + return n.mainToken(tree) + end_offset; } }, .array_init_dot_two_comma, @@ -1174,7 +1162,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .container_decl_two_trailing, .tagged_union_two_trailing, => { - const opt_lhs, const opt_rhs = tree.nodeData(n).opt_node_and_opt_node; + const opt_lhs, const opt_rhs = n.data(tree).opt_node_and_opt_node; end_offset += 2; // for the comma/semicolon + rbrace/rparen if (opt_rhs.unwrap()) |rhs| { n = rhs; @@ -1185,18 +1173,18 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { } }, .simple_var_decl => { - const type_node, const init_node = tree.nodeData(n).opt_node_and_opt_node; + const type_node, const init_node = n.data(tree).opt_node_and_opt_node; if (init_node.unwrap()) |rhs| { n = rhs; } else if (type_node.unwrap()) |lhs| { n = lhs; } else { end_offset += 1; // from mut token to name - return tree.nodeMainToken(n) + end_offset; + return n.mainToken(tree) + end_offset; } }, .aligned_var_decl => { - const align_node, const init_node = tree.nodeData(n).node_and_opt_node; + const align_node, const init_node = n.data(tree).node_and_opt_node; if (init_node.unwrap()) |rhs| { n = rhs; } else { @@ -1205,7 +1193,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { } }, .global_var_decl => { - const extra_index, const init_node = tree.nodeData(n).extra_and_opt_node; + const extra_index, const init_node = n.data(tree).extra_and_opt_node; if (init_node.unwrap()) |rhs| { n = rhs; } else { @@ -1220,12 +1208,12 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { n = type_node; } else { end_offset += 1; // from mut token to name - return tree.nodeMainToken(n) + end_offset; + return n.mainToken(tree) + end_offset; } } }, .local_var_decl => { - const extra_index, const init_node = tree.nodeData(n).extra_and_opt_node; + const extra_index, const init_node = n.data(tree).extra_and_opt_node; if (init_node.unwrap()) |rhs| { n = rhs; } else { @@ -1235,7 +1223,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { } }, .container_field_init => { - const type_expr, const value_expr = tree.nodeData(n).node_and_opt_node; + const type_expr, const value_expr = n.data(tree).node_and_opt_node; n = value_expr.unwrap() orelse type_expr; }, @@ -1243,30 +1231,30 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .array_init_one, .container_field_align, => { - _, const rhs = tree.nodeData(n).node_and_node; + _, const rhs = n.data(tree).node_and_node; end_offset += 1; // for the rbracket/rbrace/rparen n = rhs; }, .container_field => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.ContainerField); n = extra.value_expr; }, .struct_init_one => { - _, const first_field = tree.nodeData(n).node_and_opt_node; + _, const first_field = n.data(tree).node_and_opt_node; end_offset += 1; // rbrace n = first_field.unwrap() orelse { - return tree.nodeMainToken(n) + end_offset; + return n.mainToken(tree) + end_offset; }; }, .slice_open => { - _, const start_node = tree.nodeData(n).node_and_node; + _, const start_node = n.data(tree).node_and_node; end_offset += 2; // ellipsis2 + rbracket, or comma + rparen n = start_node; }, .array_init_one_comma => { - _, const first_element = tree.nodeData(n).node_and_node; + _, const first_element = n.data(tree).node_and_node; end_offset += 2; // comma + rbrace n = first_element; }, @@ -1274,67 +1262,67 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { .async_call_one_comma, .struct_init_one_comma, => { - _, const first_field = tree.nodeData(n).node_and_opt_node; + _, const first_field = n.data(tree).node_and_opt_node; end_offset += 2; // ellipsis2 + rbracket, or comma + rparen n = first_field.unwrap().?; }, .slice => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.Slice); end_offset += 1; // rbracket n = extra.end; }, .slice_sentinel => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.SliceSentinel); end_offset += 1; // rbracket n = extra.sentinel; }, .@"continue", .@"break" => { - const opt_label, const opt_rhs = tree.nodeData(n).opt_token_and_opt_node; + const opt_label, const opt_rhs = n.data(tree).opt_token_and_opt_node; if (opt_rhs.unwrap()) |rhs| { n = rhs; } else if (opt_label.unwrap()) |lhs| { return lhs + end_offset; } else { - return tree.nodeMainToken(n) + end_offset; + return n.mainToken(tree) + end_offset; } }, .while_cont => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.WhileCont); n = extra.then_expr; }, .@"while" => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.While); n = extra.else_expr; }, .@"if" => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.If); n = extra.else_expr; }, .@"for" => { - const extra_index, const extra = tree.nodeData(n).@"for"; + const extra_index, const extra = n.data(tree).@"for"; const index = @intFromEnum(extra_index) + extra.inputs + @intFromBool(extra.has_else); n = @enumFromInt(tree.extra_data[index]); }, .array_type_sentinel => { - _, const extra_index = tree.nodeData(n).node_and_extra; + _, const extra_index = n.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.ArrayTypeSentinel); n = extra.elem_type; }, }; } -pub fn tokensOnSameLine(tree: Ast, token1: TokenIndex, token2: TokenIndex) bool { +pub fn tokensOnSameLine(tree: *const Ast, token1: TokenIndex, token2: TokenIndex) bool { const source = tree.source[tree.tokenStart(token1)..tree.tokenStart(token2)]; return mem.indexOfScalar(u8, source, '\n') == null; } -pub fn getNodeSource(tree: Ast, node: Node.Index) []const u8 { +pub fn getNodeSource(tree: *const Ast, node: Node.Index) []const u8 { const first_token = tree.firstToken(node); const last_token = tree.lastToken(node); const start = tree.tokenStart(first_token); @@ -1342,9 +1330,9 @@ pub fn getNodeSource(tree: Ast, node: Node.Index) []const u8 { return tree.source[start..end]; } -pub fn globalVarDecl(tree: Ast, node: Node.Index) full.VarDecl { - assert(tree.nodeTag(node) == .global_var_decl); - const extra_index, const init_node = tree.nodeData(node).extra_and_opt_node; +pub fn globalVarDecl(tree: *const Ast, node: Node.Index) full.VarDecl { + assert(node.tag(tree) == .global_var_decl); + const extra_index, const init_node = node.data(tree).extra_and_opt_node; const extra = tree.extraData(extra_index, Node.GlobalVarDecl); return tree.fullVarDeclComponents(.{ .type_node = extra.type_node, @@ -1352,13 +1340,13 @@ pub fn globalVarDecl(tree: Ast, node: Node.Index) full.VarDecl { .addrspace_node = extra.addrspace_node, .section_node = extra.section_node, .init_node = init_node, - .mut_token = tree.nodeMainToken(node), + .mut_token = node.mainToken(tree), }); } -pub fn localVarDecl(tree: Ast, node: Node.Index) full.VarDecl { - assert(tree.nodeTag(node) == .local_var_decl); - const extra_index, const init_node = tree.nodeData(node).extra_and_opt_node; +pub fn localVarDecl(tree: *const Ast, node: Node.Index) full.VarDecl { + assert(node.tag(tree) == .local_var_decl); + const extra_index, const init_node = node.data(tree).extra_and_opt_node; const extra = tree.extraData(extra_index, Node.LocalVarDecl); return tree.fullVarDeclComponents(.{ .type_node = extra.type_node.toOptional(), @@ -1366,74 +1354,74 @@ pub fn localVarDecl(tree: Ast, node: Node.Index) full.VarDecl { .addrspace_node = .none, .section_node = .none, .init_node = init_node, - .mut_token = tree.nodeMainToken(node), + .mut_token = node.mainToken(tree), }); } -pub fn simpleVarDecl(tree: Ast, node: Node.Index) full.VarDecl { - assert(tree.nodeTag(node) == .simple_var_decl); - const type_node, const init_node = tree.nodeData(node).opt_node_and_opt_node; +pub fn simpleVarDecl(tree: *const Ast, node: Node.Index) full.VarDecl { + assert(node.tag(tree) == .simple_var_decl); + const type_node, const init_node = node.data(tree).opt_node_and_opt_node; return tree.fullVarDeclComponents(.{ .type_node = type_node, .align_node = .none, .addrspace_node = .none, .section_node = .none, .init_node = init_node, - .mut_token = tree.nodeMainToken(node), + .mut_token = node.mainToken(tree), }); } -pub fn alignedVarDecl(tree: Ast, node: Node.Index) full.VarDecl { - assert(tree.nodeTag(node) == .aligned_var_decl); - const align_node, const init_node = tree.nodeData(node).node_and_opt_node; +pub fn alignedVarDecl(tree: *const Ast, node: Node.Index) full.VarDecl { + assert(node.tag(tree) == .aligned_var_decl); + const align_node, const init_node = node.data(tree).node_and_opt_node; return tree.fullVarDeclComponents(.{ .type_node = .none, .align_node = align_node.toOptional(), .addrspace_node = .none, .section_node = .none, .init_node = init_node, - .mut_token = tree.nodeMainToken(node), + .mut_token = node.mainToken(tree), }); } -pub fn assignDestructure(tree: Ast, node: Node.Index) full.AssignDestructure { - const extra_index, const value_expr = tree.nodeData(node).extra_and_node; +pub fn assignDestructure(tree: *const Ast, node: Node.Index) full.AssignDestructure { + const extra_index, const value_expr = node.data(tree).extra_and_node; const variable_count = tree.extra_data[@intFromEnum(extra_index)]; return tree.fullAssignDestructureComponents(.{ .variables = tree.extraDataSliceWithLen(@enumFromInt(@intFromEnum(extra_index) + 1), variable_count, Node.Index), - .equal_token = tree.nodeMainToken(node), + .equal_token = node.mainToken(tree), .value_expr = value_expr, }); } -pub fn ifSimple(tree: Ast, node: Node.Index) full.If { - assert(tree.nodeTag(node) == .if_simple); - const cond_expr, const then_expr = tree.nodeData(node).node_and_node; +pub fn ifSimple(tree: *const Ast, node: Node.Index) full.If { + assert(node.tag(tree) == .if_simple); + const cond_expr, const then_expr = node.data(tree).node_and_node; return tree.fullIfComponents(.{ .cond_expr = cond_expr, .then_expr = then_expr, .else_expr = .none, - .if_token = tree.nodeMainToken(node), + .if_token = node.mainToken(tree), }); } -pub fn ifFull(tree: Ast, node: Node.Index) full.If { - assert(tree.nodeTag(node) == .@"if"); - const cond_expr, const extra_index = tree.nodeData(node).node_and_extra; +pub fn ifFull(tree: *const Ast, node: Node.Index) full.If { + assert(node.tag(tree) == .@"if"); + const cond_expr, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.If); return tree.fullIfComponents(.{ .cond_expr = cond_expr, .then_expr = extra.then_expr, .else_expr = extra.else_expr.toOptional(), - .if_token = tree.nodeMainToken(node), + .if_token = node.mainToken(tree), }); } -pub fn containerField(tree: Ast, node: Node.Index) full.ContainerField { - assert(tree.nodeTag(node) == .container_field); - const type_expr, const extra_index = tree.nodeData(node).node_and_extra; +pub fn containerField(tree: *const Ast, node: Node.Index) full.ContainerField { + assert(node.tag(tree) == .container_field); + const type_expr, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.ContainerField); - const main_token = tree.nodeMainToken(node); + const main_token = node.mainToken(tree); return tree.fullContainerFieldComponents(.{ .main_token = main_token, .type_expr = type_expr.toOptional(), @@ -1444,10 +1432,10 @@ pub fn containerField(tree: Ast, node: Node.Index) full.ContainerField { }); } -pub fn containerFieldInit(tree: Ast, node: Node.Index) full.ContainerField { - assert(tree.nodeTag(node) == .container_field_init); - const type_expr, const value_expr = tree.nodeData(node).node_and_opt_node; - const main_token = tree.nodeMainToken(node); +pub fn containerFieldInit(tree: *const Ast, node: Node.Index) full.ContainerField { + assert(node.tag(tree) == .container_field_init); + const type_expr, const value_expr = node.data(tree).node_and_opt_node; + const main_token = node.mainToken(tree); return tree.fullContainerFieldComponents(.{ .main_token = main_token, .type_expr = type_expr.toOptional(), @@ -1458,10 +1446,10 @@ pub fn containerFieldInit(tree: Ast, node: Node.Index) full.ContainerField { }); } -pub fn containerFieldAlign(tree: Ast, node: Node.Index) full.ContainerField { - assert(tree.nodeTag(node) == .container_field_align); - const type_expr, const align_expr = tree.nodeData(node).node_and_node; - const main_token = tree.nodeMainToken(node); +pub fn containerFieldAlign(tree: *const Ast, node: Node.Index) full.ContainerField { + assert(node.tag(tree) == .container_field_align); + const type_expr, const align_expr = node.data(tree).node_and_node; + const main_token = node.mainToken(tree); return tree.fullContainerFieldComponents(.{ .main_token = main_token, .type_expr = type_expr.toOptional(), @@ -1472,13 +1460,13 @@ pub fn containerFieldAlign(tree: Ast, node: Node.Index) full.ContainerField { }); } -pub fn fnProtoSimple(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.FnProto { - assert(tree.nodeTag(node) == .fn_proto_simple); - const first_param, const return_type = tree.nodeData(node).opt_node_and_opt_node; +pub fn fnProtoSimple(tree: *const Ast, buffer: *[1]Node.Index, node: Node.Index) full.FnProto { + assert(node.tag(tree) == .fn_proto_simple); + const first_param, const return_type = node.data(tree).opt_node_and_opt_node; const params = loadOptionalNodesIntoBuffer(1, buffer, .{first_param}); return tree.fullFnProtoComponents(.{ .proto_node = node, - .fn_token = tree.nodeMainToken(node), + .fn_token = node.mainToken(tree), .return_type = return_type, .params = params, .align_expr = .none, @@ -1488,13 +1476,13 @@ pub fn fnProtoSimple(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.F }); } -pub fn fnProtoMulti(tree: Ast, node: Node.Index) full.FnProto { - assert(tree.nodeTag(node) == .fn_proto_multi); - const extra_index, const return_type = tree.nodeData(node).extra_and_opt_node; +pub fn fnProtoMulti(tree: *const Ast, node: Node.Index) full.FnProto { + assert(node.tag(tree) == .fn_proto_multi); + const extra_index, const return_type = node.data(tree).extra_and_opt_node; const params = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index); return tree.fullFnProtoComponents(.{ .proto_node = node, - .fn_token = tree.nodeMainToken(node), + .fn_token = node.mainToken(tree), .return_type = return_type, .params = params, .align_expr = .none, @@ -1504,14 +1492,14 @@ pub fn fnProtoMulti(tree: Ast, node: Node.Index) full.FnProto { }); } -pub fn fnProtoOne(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.FnProto { - assert(tree.nodeTag(node) == .fn_proto_one); - const extra_index, const return_type = tree.nodeData(node).extra_and_opt_node; +pub fn fnProtoOne(tree: *const Ast, buffer: *[1]Node.Index, node: Node.Index) full.FnProto { + assert(node.tag(tree) == .fn_proto_one); + const extra_index, const return_type = node.data(tree).extra_and_opt_node; const extra = tree.extraData(extra_index, Node.FnProtoOne); const params = loadOptionalNodesIntoBuffer(1, buffer, .{extra.param}); return tree.fullFnProtoComponents(.{ .proto_node = node, - .fn_token = tree.nodeMainToken(node), + .fn_token = node.mainToken(tree), .return_type = return_type, .params = params, .align_expr = extra.align_expr, @@ -1521,14 +1509,14 @@ pub fn fnProtoOne(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.FnPr }); } -pub fn fnProto(tree: Ast, node: Node.Index) full.FnProto { - assert(tree.nodeTag(node) == .fn_proto); - const extra_index, const return_type = tree.nodeData(node).extra_and_opt_node; +pub fn fnProto(tree: *const Ast, node: Node.Index) full.FnProto { + assert(node.tag(tree) == .fn_proto); + const extra_index, const return_type = node.data(tree).extra_and_opt_node; const extra = tree.extraData(extra_index, Node.FnProto); const params = tree.extraDataSlice(.{ .start = extra.params_start, .end = extra.params_end }, Node.Index); return tree.fullFnProtoComponents(.{ .proto_node = node, - .fn_token = tree.nodeMainToken(node), + .fn_token = node.mainToken(tree), .return_type = return_type, .params = params, .align_expr = extra.align_expr, @@ -1538,119 +1526,119 @@ pub fn fnProto(tree: Ast, node: Node.Index) full.FnProto { }); } -pub fn structInitOne(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.StructInit { - assert(tree.nodeTag(node) == .struct_init_one or - tree.nodeTag(node) == .struct_init_one_comma); - const type_expr, const first_field = tree.nodeData(node).node_and_opt_node; +pub fn structInitOne(tree: *const Ast, buffer: *[1]Node.Index, node: Node.Index) full.StructInit { + assert(node.tag(tree) == .struct_init_one or + node.tag(tree) == .struct_init_one_comma); + const type_expr, const first_field = node.data(tree).node_and_opt_node; const fields = loadOptionalNodesIntoBuffer(1, buffer, .{first_field}); return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .fields = fields, .type_expr = type_expr.toOptional(), }, }; } -pub fn structInitDotTwo(tree: Ast, buffer: *[2]Node.Index, node: Node.Index) full.StructInit { - assert(tree.nodeTag(node) == .struct_init_dot_two or - tree.nodeTag(node) == .struct_init_dot_two_comma); - const fields = loadOptionalNodesIntoBuffer(2, buffer, tree.nodeData(node).opt_node_and_opt_node); +pub fn structInitDotTwo(tree: *const Ast, buffer: *[2]Node.Index, node: Node.Index) full.StructInit { + assert(node.tag(tree) == .struct_init_dot_two or + node.tag(tree) == .struct_init_dot_two_comma); + const fields = loadOptionalNodesIntoBuffer(2, buffer, node.data(tree).opt_node_and_opt_node); return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .fields = fields, .type_expr = .none, }, }; } -pub fn structInitDot(tree: Ast, node: Node.Index) full.StructInit { - assert(tree.nodeTag(node) == .struct_init_dot or - tree.nodeTag(node) == .struct_init_dot_comma); - const fields = tree.extraDataSlice(tree.nodeData(node).extra_range, Node.Index); +pub fn structInitDot(tree: *const Ast, node: Node.Index) full.StructInit { + assert(node.tag(tree) == .struct_init_dot or + node.tag(tree) == .struct_init_dot_comma); + const fields = tree.extraDataSlice(node.data(tree).extra_range, Node.Index); return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .fields = fields, .type_expr = .none, }, }; } -pub fn structInit(tree: Ast, node: Node.Index) full.StructInit { - assert(tree.nodeTag(node) == .struct_init or - tree.nodeTag(node) == .struct_init_comma); - const type_expr, const extra_index = tree.nodeData(node).node_and_extra; +pub fn structInit(tree: *const Ast, node: Node.Index) full.StructInit { + assert(node.tag(tree) == .struct_init or + node.tag(tree) == .struct_init_comma); + const type_expr, const extra_index = node.data(tree).node_and_extra; const fields = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index); return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .fields = fields, .type_expr = type_expr.toOptional(), }, }; } -pub fn arrayInitOne(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.ArrayInit { - assert(tree.nodeTag(node) == .array_init_one or - tree.nodeTag(node) == .array_init_one_comma); - const type_expr, buffer[0] = tree.nodeData(node).node_and_node; +pub fn arrayInitOne(tree: *const Ast, buffer: *[1]Node.Index, node: Node.Index) full.ArrayInit { + assert(node.tag(tree) == .array_init_one or + node.tag(tree) == .array_init_one_comma); + const type_expr, buffer[0] = node.data(tree).node_and_node; return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .elements = buffer[0..1], .type_expr = type_expr.toOptional(), }, }; } -pub fn arrayInitDotTwo(tree: Ast, buffer: *[2]Node.Index, node: Node.Index) full.ArrayInit { - assert(tree.nodeTag(node) == .array_init_dot_two or - tree.nodeTag(node) == .array_init_dot_two_comma); - const elements = loadOptionalNodesIntoBuffer(2, buffer, tree.nodeData(node).opt_node_and_opt_node); +pub fn arrayInitDotTwo(tree: *const Ast, buffer: *[2]Node.Index, node: Node.Index) full.ArrayInit { + assert(node.tag(tree) == .array_init_dot_two or + node.tag(tree) == .array_init_dot_two_comma); + const elements = loadOptionalNodesIntoBuffer(2, buffer, node.data(tree).opt_node_and_opt_node); return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .elements = elements, .type_expr = .none, }, }; } -pub fn arrayInitDot(tree: Ast, node: Node.Index) full.ArrayInit { - assert(tree.nodeTag(node) == .array_init_dot or - tree.nodeTag(node) == .array_init_dot_comma); - const elements = tree.extraDataSlice(tree.nodeData(node).extra_range, Node.Index); +pub fn arrayInitDot(tree: *const Ast, node: Node.Index) full.ArrayInit { + assert(node.tag(tree) == .array_init_dot or + node.tag(tree) == .array_init_dot_comma); + const elements = tree.extraDataSlice(node.data(tree).extra_range, Node.Index); return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .elements = elements, .type_expr = .none, }, }; } -pub fn arrayInit(tree: Ast, node: Node.Index) full.ArrayInit { - assert(tree.nodeTag(node) == .array_init or - tree.nodeTag(node) == .array_init_comma); - const type_expr, const extra_index = tree.nodeData(node).node_and_extra; +pub fn arrayInit(tree: *const Ast, node: Node.Index) full.ArrayInit { + assert(node.tag(tree) == .array_init or + node.tag(tree) == .array_init_comma); + const type_expr, const extra_index = node.data(tree).node_and_extra; const elements = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index); return .{ .ast = .{ - .lbrace = tree.nodeMainToken(node), + .lbrace = node.mainToken(tree), .elements = elements, .type_expr = type_expr.toOptional(), }, }; } -pub fn arrayType(tree: Ast, node: Node.Index) full.ArrayType { - assert(tree.nodeTag(node) == .array_type); - const elem_count, const elem_type = tree.nodeData(node).node_and_node; +pub fn arrayType(tree: *const Ast, node: Node.Index) full.ArrayType { + assert(node.tag(tree) == .array_type); + const elem_count, const elem_type = node.data(tree).node_and_node; return .{ .ast = .{ - .lbracket = tree.nodeMainToken(node), + .lbracket = node.mainToken(tree), .elem_count = elem_count, .sentinel = .none, .elem_type = elem_type, @@ -1658,13 +1646,13 @@ pub fn arrayType(tree: Ast, node: Node.Index) full.ArrayType { }; } -pub fn arrayTypeSentinel(tree: Ast, node: Node.Index) full.ArrayType { - assert(tree.nodeTag(node) == .array_type_sentinel); - const elem_count, const extra_index = tree.nodeData(node).node_and_extra; +pub fn arrayTypeSentinel(tree: *const Ast, node: Node.Index) full.ArrayType { + assert(node.tag(tree) == .array_type_sentinel); + const elem_count, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.ArrayTypeSentinel); return .{ .ast = .{ - .lbracket = tree.nodeMainToken(node), + .lbracket = node.mainToken(tree), .elem_count = elem_count, .sentinel = extra.sentinel.toOptional(), .elem_type = extra.elem_type, @@ -1672,11 +1660,11 @@ pub fn arrayTypeSentinel(tree: Ast, node: Node.Index) full.ArrayType { }; } -pub fn ptrTypeAligned(tree: Ast, node: Node.Index) full.PtrType { - assert(tree.nodeTag(node) == .ptr_type_aligned); - const align_node, const child_type = tree.nodeData(node).opt_node_and_node; +pub fn ptrTypeAligned(tree: *const Ast, node: Node.Index) full.PtrType { + assert(node.tag(tree) == .ptr_type_aligned); + const align_node, const child_type = node.data(tree).opt_node_and_node; return tree.fullPtrTypeComponents(.{ - .main_token = tree.nodeMainToken(node), + .main_token = node.mainToken(tree), .align_node = align_node, .addrspace_node = .none, .sentinel = .none, @@ -1686,11 +1674,11 @@ pub fn ptrTypeAligned(tree: Ast, node: Node.Index) full.PtrType { }); } -pub fn ptrTypeSentinel(tree: Ast, node: Node.Index) full.PtrType { - assert(tree.nodeTag(node) == .ptr_type_sentinel); - const sentinel, const child_type = tree.nodeData(node).opt_node_and_node; +pub fn ptrTypeSentinel(tree: *const Ast, node: Node.Index) full.PtrType { + assert(node.tag(tree) == .ptr_type_sentinel); + const sentinel, const child_type = node.data(tree).opt_node_and_node; return tree.fullPtrTypeComponents(.{ - .main_token = tree.nodeMainToken(node), + .main_token = node.mainToken(tree), .align_node = .none, .addrspace_node = .none, .sentinel = sentinel, @@ -1700,12 +1688,12 @@ pub fn ptrTypeSentinel(tree: Ast, node: Node.Index) full.PtrType { }); } -pub fn ptrType(tree: Ast, node: Node.Index) full.PtrType { - assert(tree.nodeTag(node) == .ptr_type); - const extra_index, const child_type = tree.nodeData(node).extra_and_node; +pub fn ptrType(tree: *const Ast, node: Node.Index) full.PtrType { + assert(node.tag(tree) == .ptr_type); + const extra_index, const child_type = node.data(tree).extra_and_node; const extra = tree.extraData(extra_index, Node.PtrType); return tree.fullPtrTypeComponents(.{ - .main_token = tree.nodeMainToken(node), + .main_token = node.mainToken(tree), .align_node = extra.align_node, .addrspace_node = extra.addrspace_node, .sentinel = extra.sentinel, @@ -1715,12 +1703,12 @@ pub fn ptrType(tree: Ast, node: Node.Index) full.PtrType { }); } -pub fn ptrTypeBitRange(tree: Ast, node: Node.Index) full.PtrType { - assert(tree.nodeTag(node) == .ptr_type_bit_range); - const extra_index, const child_type = tree.nodeData(node).extra_and_node; +pub fn ptrTypeBitRange(tree: *const Ast, node: Node.Index) full.PtrType { + assert(node.tag(tree) == .ptr_type_bit_range); + const extra_index, const child_type = node.data(tree).extra_and_node; const extra = tree.extraData(extra_index, Node.PtrTypeBitRange); return tree.fullPtrTypeComponents(.{ - .main_token = tree.nodeMainToken(node), + .main_token = node.mainToken(tree), .align_node = extra.align_node.toOptional(), .addrspace_node = extra.addrspace_node, .sentinel = extra.sentinel, @@ -1730,13 +1718,13 @@ pub fn ptrTypeBitRange(tree: Ast, node: Node.Index) full.PtrType { }); } -pub fn sliceOpen(tree: Ast, node: Node.Index) full.Slice { - assert(tree.nodeTag(node) == .slice_open); - const sliced, const start = tree.nodeData(node).node_and_node; +pub fn sliceOpen(tree: *const Ast, node: Node.Index) full.Slice { + assert(node.tag(tree) == .slice_open); + const sliced, const start = node.data(tree).node_and_node; return .{ .ast = .{ .sliced = sliced, - .lbracket = tree.nodeMainToken(node), + .lbracket = node.mainToken(tree), .start = start, .end = .none, .sentinel = .none, @@ -1744,14 +1732,14 @@ pub fn sliceOpen(tree: Ast, node: Node.Index) full.Slice { }; } -pub fn slice(tree: Ast, node: Node.Index) full.Slice { - assert(tree.nodeTag(node) == .slice); - const sliced, const extra_index = tree.nodeData(node).node_and_extra; +pub fn slice(tree: *const Ast, node: Node.Index) full.Slice { + assert(node.tag(tree) == .slice); + const sliced, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.Slice); return .{ .ast = .{ .sliced = sliced, - .lbracket = tree.nodeMainToken(node), + .lbracket = node.mainToken(tree), .start = extra.start, .end = extra.end.toOptional(), .sentinel = .none, @@ -1759,14 +1747,14 @@ pub fn slice(tree: Ast, node: Node.Index) full.Slice { }; } -pub fn sliceSentinel(tree: Ast, node: Node.Index) full.Slice { - assert(tree.nodeTag(node) == .slice_sentinel); - const sliced, const extra_index = tree.nodeData(node).node_and_extra; +pub fn sliceSentinel(tree: *const Ast, node: Node.Index) full.Slice { + assert(node.tag(tree) == .slice_sentinel); + const sliced, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.SliceSentinel); return .{ .ast = .{ .sliced = sliced, - .lbracket = tree.nodeMainToken(node), + .lbracket = node.mainToken(tree), .start = extra.start, .end = extra.end, .sentinel = extra.sentinel.toOptional(), @@ -1774,44 +1762,44 @@ pub fn sliceSentinel(tree: Ast, node: Node.Index) full.Slice { }; } -pub fn containerDeclTwo(tree: Ast, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl { - assert(tree.nodeTag(node) == .container_decl_two or - tree.nodeTag(node) == .container_decl_two_trailing); - const members = loadOptionalNodesIntoBuffer(2, buffer, tree.nodeData(node).opt_node_and_opt_node); +pub fn containerDeclTwo(tree: *const Ast, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl { + assert(node.tag(tree) == .container_decl_two or + node.tag(tree) == .container_decl_two_trailing); + const members = loadOptionalNodesIntoBuffer(2, buffer, node.data(tree).opt_node_and_opt_node); return tree.fullContainerDeclComponents(.{ - .main_token = tree.nodeMainToken(node), + .main_token = node.mainToken(tree), .enum_token = null, .members = members, .arg = .none, }); } -pub fn containerDecl(tree: Ast, node: Node.Index) full.ContainerDecl { - assert(tree.nodeTag(node) == .container_decl or - tree.nodeTag(node) == .container_decl_trailing); - const members = tree.extraDataSlice(tree.nodeData(node).extra_range, Node.Index); +pub fn containerDecl(tree: *const Ast, node: Node.Index) full.ContainerDecl { + assert(node.tag(tree) == .container_decl or + node.tag(tree) == .container_decl_trailing); + const members = tree.extraDataSlice(node.data(tree).extra_range, Node.Index); return tree.fullContainerDeclComponents(.{ - .main_token = tree.nodeMainToken(node), + .main_token = node.mainToken(tree), .enum_token = null, .members = members, .arg = .none, }); } -pub fn containerDeclArg(tree: Ast, node: Node.Index) full.ContainerDecl { - assert(tree.nodeTag(node) == .container_decl_arg or - tree.nodeTag(node) == .container_decl_arg_trailing); - const arg, const extra_index = tree.nodeData(node).node_and_extra; +pub fn containerDeclArg(tree: *const Ast, node: Node.Index) full.ContainerDecl { + assert(node.tag(tree) == .container_decl_arg or + node.tag(tree) == .container_decl_arg_trailing); + const arg, const extra_index = node.data(tree).node_and_extra; const members = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index); return tree.fullContainerDeclComponents(.{ - .main_token = tree.nodeMainToken(node), + .main_token = node.mainToken(tree), .enum_token = null, .members = members, .arg = arg.toOptional(), }); } -pub fn containerDeclRoot(tree: Ast) full.ContainerDecl { +pub fn containerDeclRoot(tree: *const Ast) full.ContainerDecl { return .{ .layout_token = null, .ast = .{ @@ -1823,11 +1811,11 @@ pub fn containerDeclRoot(tree: Ast) full.ContainerDecl { }; } -pub fn taggedUnionTwo(tree: Ast, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl { - assert(tree.nodeTag(node) == .tagged_union_two or - tree.nodeTag(node) == .tagged_union_two_trailing); - const members = loadOptionalNodesIntoBuffer(2, buffer, tree.nodeData(node).opt_node_and_opt_node); - const main_token = tree.nodeMainToken(node); +pub fn taggedUnionTwo(tree: *const Ast, buffer: *[2]Node.Index, node: Node.Index) full.ContainerDecl { + assert(node.tag(tree) == .tagged_union_two or + node.tag(tree) == .tagged_union_two_trailing); + const members = loadOptionalNodesIntoBuffer(2, buffer, node.data(tree).opt_node_and_opt_node); + const main_token = node.mainToken(tree); return tree.fullContainerDeclComponents(.{ .main_token = main_token, .enum_token = main_token + 2, // union lparen enum @@ -1836,11 +1824,11 @@ pub fn taggedUnionTwo(tree: Ast, buffer: *[2]Node.Index, node: Node.Index) full. }); } -pub fn taggedUnion(tree: Ast, node: Node.Index) full.ContainerDecl { - assert(tree.nodeTag(node) == .tagged_union or - tree.nodeTag(node) == .tagged_union_trailing); - const members = tree.extraDataSlice(tree.nodeData(node).extra_range, Node.Index); - const main_token = tree.nodeMainToken(node); +pub fn taggedUnion(tree: *const Ast, node: Node.Index) full.ContainerDecl { + assert(node.tag(tree) == .tagged_union or + node.tag(tree) == .tagged_union_trailing); + const members = tree.extraDataSlice(node.data(tree).extra_range, Node.Index); + const main_token = node.mainToken(tree); return tree.fullContainerDeclComponents(.{ .main_token = main_token, .enum_token = main_token + 2, // union lparen enum @@ -1849,12 +1837,12 @@ pub fn taggedUnion(tree: Ast, node: Node.Index) full.ContainerDecl { }); } -pub fn taggedUnionEnumTag(tree: Ast, node: Node.Index) full.ContainerDecl { - assert(tree.nodeTag(node) == .tagged_union_enum_tag or - tree.nodeTag(node) == .tagged_union_enum_tag_trailing); - const arg, const extra_index = tree.nodeData(node).node_and_extra; +pub fn taggedUnionEnumTag(tree: *const Ast, node: Node.Index) full.ContainerDecl { + assert(node.tag(tree) == .tagged_union_enum_tag or + node.tag(tree) == .tagged_union_enum_tag_trailing); + const arg, const extra_index = node.data(tree).node_and_extra; const members = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index); - const main_token = tree.nodeMainToken(node); + const main_token = node.mainToken(tree); return tree.fullContainerDeclComponents(.{ .main_token = main_token, .enum_token = main_token + 2, // union lparen enum @@ -1863,14 +1851,14 @@ pub fn taggedUnionEnumTag(tree: Ast, node: Node.Index) full.ContainerDecl { }); } -pub fn switchFull(tree: Ast, node: Node.Index) full.Switch { - const main_token = tree.nodeMainToken(node); +pub fn switchFull(tree: *const Ast, node: Node.Index) full.Switch { + const main_token = node.mainToken(tree); const switch_token: TokenIndex, const label_token: ?TokenIndex = switch (tree.tokenTag(main_token)) { .identifier => .{ main_token + 2, main_token }, .keyword_switch => .{ main_token, null }, else => unreachable, }; - const condition, const extra_index = tree.nodeData(node).node_and_extra; + const condition, const extra_index = node.data(tree).node_and_extra; const cases = tree.extraDataSlice(tree.extraData(extra_index, Ast.Node.SubRange), Node.Index); return .{ .ast = .{ @@ -1882,55 +1870,55 @@ pub fn switchFull(tree: Ast, node: Node.Index) full.Switch { }; } -pub fn switchCaseOne(tree: Ast, node: Node.Index) full.SwitchCase { - const first_value, const target_expr = tree.nodeData(node).opt_node_and_node; +pub fn switchCaseOne(tree: *const Ast, node: Node.Index) full.SwitchCase { + const first_value, const target_expr = node.data(tree).opt_node_and_node; return tree.fullSwitchCaseComponents(.{ .values = if (first_value == .none) &.{} else // Ensure that the returned slice points into the existing memory of the Ast (@as(*const Node.Index, @ptrCast(&tree.nodes.items(.data)[@intFromEnum(node)].opt_node_and_node[0])))[0..1], - .arrow_token = tree.nodeMainToken(node), + .arrow_token = node.mainToken(tree), .target_expr = target_expr, }, node); } -pub fn switchCase(tree: Ast, node: Node.Index) full.SwitchCase { - const extra_index, const target_expr = tree.nodeData(node).extra_and_node; +pub fn switchCase(tree: *const Ast, node: Node.Index) full.SwitchCase { + const extra_index, const target_expr = node.data(tree).extra_and_node; const values = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index); return tree.fullSwitchCaseComponents(.{ .values = values, - .arrow_token = tree.nodeMainToken(node), + .arrow_token = node.mainToken(tree), .target_expr = target_expr, }, node); } -pub fn asmSimple(tree: Ast, node: Node.Index) full.Asm { - const template, const rparen = tree.nodeData(node).node_and_token; +pub fn asmSimple(tree: *const Ast, node: Node.Index) full.Asm { + const template, const rparen = node.data(tree).node_and_token; return tree.fullAsmComponents(.{ - .asm_token = tree.nodeMainToken(node), + .asm_token = node.mainToken(tree), .template = template, .items = &.{}, .rparen = rparen, }); } -pub fn asmFull(tree: Ast, node: Node.Index) full.Asm { - const template, const extra_index = tree.nodeData(node).node_and_extra; +pub fn asmFull(tree: *const Ast, node: Node.Index) full.Asm { + const template, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.Asm); const items = tree.extraDataSlice(.{ .start = extra.items_start, .end = extra.items_end }, Node.Index); return tree.fullAsmComponents(.{ - .asm_token = tree.nodeMainToken(node), + .asm_token = node.mainToken(tree), .template = template, .items = items, .rparen = extra.rparen, }); } -pub fn whileSimple(tree: Ast, node: Node.Index) full.While { - const cond_expr, const then_expr = tree.nodeData(node).node_and_node; +pub fn whileSimple(tree: *const Ast, node: Node.Index) full.While { + const cond_expr, const then_expr = node.data(tree).node_and_node; return tree.fullWhileComponents(.{ - .while_token = tree.nodeMainToken(node), + .while_token = node.mainToken(tree), .cond_expr = cond_expr, .cont_expr = .none, .then_expr = then_expr, @@ -1938,11 +1926,11 @@ pub fn whileSimple(tree: Ast, node: Node.Index) full.While { }); } -pub fn whileCont(tree: Ast, node: Node.Index) full.While { - const cond_expr, const extra_index = tree.nodeData(node).node_and_extra; +pub fn whileCont(tree: *const Ast, node: Node.Index) full.While { + const cond_expr, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.WhileCont); return tree.fullWhileComponents(.{ - .while_token = tree.nodeMainToken(node), + .while_token = node.mainToken(tree), .cond_expr = cond_expr, .cont_expr = extra.cont_expr.toOptional(), .then_expr = extra.then_expr, @@ -1950,11 +1938,11 @@ pub fn whileCont(tree: Ast, node: Node.Index) full.While { }); } -pub fn whileFull(tree: Ast, node: Node.Index) full.While { - const cond_expr, const extra_index = tree.nodeData(node).node_and_extra; +pub fn whileFull(tree: *const Ast, node: Node.Index) full.While { + const cond_expr, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Node.While); return tree.fullWhileComponents(.{ - .while_token = tree.nodeMainToken(node), + .while_token = node.mainToken(tree), .cond_expr = cond_expr, .cont_expr = extra.cont_expr, .then_expr = extra.then_expr, @@ -1962,50 +1950,50 @@ pub fn whileFull(tree: Ast, node: Node.Index) full.While { }); } -pub fn forSimple(tree: Ast, node: Node.Index) full.For { +pub fn forSimple(tree: *const Ast, node: Node.Index) full.For { const data = &tree.nodes.items(.data)[@intFromEnum(node)].node_and_node; return tree.fullForComponents(.{ - .for_token = tree.nodeMainToken(node), + .for_token = node.mainToken(tree), .inputs = (&data[0])[0..1], .then_expr = data[1], .else_expr = .none, }); } -pub fn forFull(tree: Ast, node: Node.Index) full.For { - const extra_index, const extra = tree.nodeData(node).@"for"; +pub fn forFull(tree: *const Ast, node: Node.Index) full.For { + const extra_index, const extra = node.data(tree).@"for"; const inputs = tree.extraDataSliceWithLen(extra_index, extra.inputs, Node.Index); const then_expr: Node.Index = @enumFromInt(tree.extra_data[@intFromEnum(extra_index) + extra.inputs]); const else_expr: Node.OptionalIndex = if (extra.has_else) @enumFromInt(tree.extra_data[@intFromEnum(extra_index) + extra.inputs + 1]) else .none; return tree.fullForComponents(.{ - .for_token = tree.nodeMainToken(node), + .for_token = node.mainToken(tree), .inputs = inputs, .then_expr = then_expr, .else_expr = else_expr, }); } -pub fn callOne(tree: Ast, buffer: *[1]Node.Index, node: Node.Index) full.Call { - const fn_expr, const first_param = tree.nodeData(node).node_and_opt_node; +pub fn callOne(tree: *const Ast, buffer: *[1]Node.Index, node: Node.Index) full.Call { + const fn_expr, const first_param = node.data(tree).node_and_opt_node; const params = loadOptionalNodesIntoBuffer(1, buffer, .{first_param}); return tree.fullCallComponents(.{ - .lparen = tree.nodeMainToken(node), + .lparen = node.mainToken(tree), .fn_expr = fn_expr, .params = params, }); } -pub fn callFull(tree: Ast, node: Node.Index) full.Call { - const fn_expr, const extra_index = tree.nodeData(node).node_and_extra; +pub fn callFull(tree: *const Ast, node: Node.Index) full.Call { + const fn_expr, const extra_index = node.data(tree).node_and_extra; const params = tree.extraDataSlice(tree.extraData(extra_index, Node.SubRange), Node.Index); return tree.fullCallComponents(.{ - .lparen = tree.nodeMainToken(node), + .lparen = node.mainToken(tree), .fn_expr = fn_expr, .params = params, }); } -fn fullVarDeclComponents(tree: Ast, info: full.VarDecl.Components) full.VarDecl { +fn fullVarDeclComponents(tree: *const Ast, info: full.VarDecl.Components) full.VarDecl { var result: full.VarDecl = .{ .ast = info, .visib_token = null, @@ -2029,13 +2017,13 @@ fn fullVarDeclComponents(tree: Ast, info: full.VarDecl.Components) full.VarDecl return result; } -fn fullAssignDestructureComponents(tree: Ast, info: full.AssignDestructure.Components) full.AssignDestructure { +fn fullAssignDestructureComponents(tree: *const Ast, info: full.AssignDestructure.Components) full.AssignDestructure { var result: full.AssignDestructure = .{ .comptime_token = null, .ast = info, }; const first_variable_token = tree.firstToken(info.variables[0]); - const maybe_comptime_token = switch (tree.nodeTag(info.variables[0])) { + const maybe_comptime_token = switch (info.variables[0].tag(tree)) { .global_var_decl, .local_var_decl, .aligned_var_decl, @@ -2049,7 +2037,7 @@ fn fullAssignDestructureComponents(tree: Ast, info: full.AssignDestructure.Compo return result; } -fn fullIfComponents(tree: Ast, info: full.If.Components) full.If { +fn fullIfComponents(tree: *const Ast, info: full.If.Components) full.If { var result: full.If = .{ .ast = info, .payload_token = null, @@ -2073,7 +2061,7 @@ fn fullIfComponents(tree: Ast, info: full.If.Components) full.If { return result; } -fn fullContainerFieldComponents(tree: Ast, info: full.ContainerField.Components) full.ContainerField { +fn fullContainerFieldComponents(tree: *const Ast, info: full.ContainerField.Components) full.ContainerField { var result: full.ContainerField = .{ .ast = info, .comptime_token = null, @@ -2088,7 +2076,7 @@ fn fullContainerFieldComponents(tree: Ast, info: full.ContainerField.Components) return result; } -fn fullFnProtoComponents(tree: Ast, info: full.FnProto.Components) full.FnProto { +fn fullFnProtoComponents(tree: *const Ast, info: full.FnProto.Components) full.FnProto { var result: full.FnProto = .{ .ast = info, .visib_token = null, @@ -2123,7 +2111,7 @@ fn fullFnProtoComponents(tree: Ast, info: full.FnProto.Components) full.FnProto return result; } -fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType { +fn fullPtrTypeComponents(tree: *const Ast, info: full.PtrType.Components) full.PtrType { const size: std.builtin.Type.Pointer.Size = switch (tree.tokenTag(info.main_token)) { .asterisk, .asterisk_asterisk, @@ -2170,7 +2158,7 @@ fn fullPtrTypeComponents(tree: Ast, info: full.PtrType.Components) full.PtrType return result; } -fn fullContainerDeclComponents(tree: Ast, info: full.ContainerDecl.Components) full.ContainerDecl { +fn fullContainerDeclComponents(tree: *const Ast, info: full.ContainerDecl.Components) full.ContainerDecl { var result: full.ContainerDecl = .{ .ast = info, .layout_token = null, @@ -2186,7 +2174,7 @@ fn fullContainerDeclComponents(tree: Ast, info: full.ContainerDecl.Components) f return result; } -fn fullSwitchComponents(tree: Ast, info: full.Switch.Components) full.Switch { +fn fullSwitchComponents(tree: *const Ast, info: full.Switch.Components) full.Switch { const tok_i = info.switch_token -| 1; var result: full.Switch = .{ .ast = info, @@ -2200,7 +2188,7 @@ fn fullSwitchComponents(tree: Ast, info: full.Switch.Components) full.Switch { return result; } -fn fullSwitchCaseComponents(tree: Ast, info: full.SwitchCase.Components, node: Node.Index) full.SwitchCase { +fn fullSwitchCaseComponents(tree: *const Ast, info: full.SwitchCase.Components, node: Node.Index) full.SwitchCase { var result: full.SwitchCase = .{ .ast = info, .payload_token = null, @@ -2209,7 +2197,7 @@ fn fullSwitchCaseComponents(tree: Ast, info: full.SwitchCase.Components, node: N if (tree.tokenTag(info.arrow_token + 1) == .pipe) { result.payload_token = info.arrow_token + 2; } - result.inline_token = switch (tree.nodeTag(node)) { + result.inline_token = switch (node.tag(tree)) { .switch_case_inline, .switch_case_inline_one => if (result.ast.values.len == 0) info.arrow_token - 2 else @@ -2219,7 +2207,7 @@ fn fullSwitchCaseComponents(tree: Ast, info: full.SwitchCase.Components, node: N return result; } -fn fullAsmComponents(tree: Ast, info: full.Asm.Components) full.Asm { +fn fullAsmComponents(tree: *const Ast, info: full.Asm.Components) full.Asm { var result: full.Asm = .{ .ast = info, .volatile_token = null, @@ -2231,7 +2219,7 @@ fn fullAsmComponents(tree: Ast, info: full.Asm.Components) full.Asm { result.volatile_token = info.asm_token + 1; } const outputs_end: usize = for (info.items, 0..) |item, i| { - switch (tree.nodeTag(item)) { + switch (item.tag(tree)) { .asm_output => continue, else => break i, } @@ -2280,7 +2268,7 @@ fn fullAsmComponents(tree: Ast, info: full.Asm.Components) full.Asm { return result; } -fn fullWhileComponents(tree: Ast, info: full.While.Components) full.While { +fn fullWhileComponents(tree: *const Ast, info: full.While.Components) full.While { var result: full.While = .{ .ast = info, .inline_token = null, @@ -2312,7 +2300,7 @@ fn fullWhileComponents(tree: Ast, info: full.While.Components) full.While { return result; } -fn fullForComponents(tree: Ast, info: full.For.Components) full.For { +fn fullForComponents(tree: *const Ast, info: full.For.Components) full.For { var result: full.For = .{ .ast = info, .inline_token = null, @@ -2336,7 +2324,7 @@ fn fullForComponents(tree: Ast, info: full.For.Components) full.For { return result; } -fn fullCallComponents(tree: Ast, info: full.Call.Components) full.Call { +fn fullCallComponents(tree: *const Ast, info: full.Call.Components) full.Call { var result: full.Call = .{ .ast = info, .async_token = null, @@ -2348,8 +2336,8 @@ fn fullCallComponents(tree: Ast, info: full.Call.Components) full.Call { return result; } -pub fn fullVarDecl(tree: Ast, node: Node.Index) ?full.VarDecl { - return switch (tree.nodeTag(node)) { +pub fn fullVarDecl(tree: *const Ast, node: Node.Index) ?full.VarDecl { + return switch (node.tag(tree)) { .global_var_decl => tree.globalVarDecl(node), .local_var_decl => tree.localVarDecl(node), .aligned_var_decl => tree.alignedVarDecl(node), @@ -2358,16 +2346,16 @@ pub fn fullVarDecl(tree: Ast, node: Node.Index) ?full.VarDecl { }; } -pub fn fullIf(tree: Ast, node: Node.Index) ?full.If { - return switch (tree.nodeTag(node)) { +pub fn fullIf(tree: *const Ast, node: Node.Index) ?full.If { + return switch (node.tag(tree)) { .if_simple => tree.ifSimple(node), .@"if" => tree.ifFull(node), else => null, }; } -pub fn fullWhile(tree: Ast, node: Node.Index) ?full.While { - return switch (tree.nodeTag(node)) { +pub fn fullWhile(tree: *const Ast, node: Node.Index) ?full.While { + return switch (node.tag(tree)) { .while_simple => tree.whileSimple(node), .while_cont => tree.whileCont(node), .@"while" => tree.whileFull(node), @@ -2375,16 +2363,16 @@ pub fn fullWhile(tree: Ast, node: Node.Index) ?full.While { }; } -pub fn fullFor(tree: Ast, node: Node.Index) ?full.For { - return switch (tree.nodeTag(node)) { +pub fn fullFor(tree: *const Ast, node: Node.Index) ?full.For { + return switch (node.tag(tree)) { .for_simple => tree.forSimple(node), .@"for" => tree.forFull(node), else => null, }; } -pub fn fullContainerField(tree: Ast, node: Node.Index) ?full.ContainerField { - return switch (tree.nodeTag(node)) { +pub fn fullContainerField(tree: *const Ast, node: Node.Index) ?full.ContainerField { + return switch (node.tag(tree)) { .container_field_init => tree.containerFieldInit(node), .container_field_align => tree.containerFieldAlign(node), .container_field => tree.containerField(node), @@ -2392,19 +2380,19 @@ pub fn fullContainerField(tree: Ast, node: Node.Index) ?full.ContainerField { }; } -pub fn fullFnProto(tree: Ast, buffer: *[1]Ast.Node.Index, node: Node.Index) ?full.FnProto { - return switch (tree.nodeTag(node)) { +pub fn fullFnProto(tree: *const Ast, buffer: *[1]Ast.Node.Index, node: Node.Index) ?full.FnProto { + return switch (node.tag(tree)) { .fn_proto => tree.fnProto(node), .fn_proto_multi => tree.fnProtoMulti(node), .fn_proto_one => tree.fnProtoOne(buffer, node), .fn_proto_simple => tree.fnProtoSimple(buffer, node), - .fn_decl => tree.fullFnProto(buffer, tree.nodeData(node).node_and_node[0]), + .fn_decl => tree.fullFnProto(buffer, node.data(tree).node_and_node[0]), else => null, }; } -pub fn fullStructInit(tree: Ast, buffer: *[2]Ast.Node.Index, node: Node.Index) ?full.StructInit { - return switch (tree.nodeTag(node)) { +pub fn fullStructInit(tree: *const Ast, buffer: *[2]Ast.Node.Index, node: Node.Index) ?full.StructInit { + return switch (node.tag(tree)) { .struct_init_one, .struct_init_one_comma => tree.structInitOne(buffer[0..1], node), .struct_init_dot_two, .struct_init_dot_two_comma => tree.structInitDotTwo(buffer, node), .struct_init_dot, .struct_init_dot_comma => tree.structInitDot(node), @@ -2413,8 +2401,8 @@ pub fn fullStructInit(tree: Ast, buffer: *[2]Ast.Node.Index, node: Node.Index) ? }; } -pub fn fullArrayInit(tree: Ast, buffer: *[2]Node.Index, node: Node.Index) ?full.ArrayInit { - return switch (tree.nodeTag(node)) { +pub fn fullArrayInit(tree: *const Ast, buffer: *[2]Node.Index, node: Node.Index) ?full.ArrayInit { + return switch (node.tag(tree)) { .array_init_one, .array_init_one_comma => tree.arrayInitOne(buffer[0..1], node), .array_init_dot_two, .array_init_dot_two_comma => tree.arrayInitDotTwo(buffer, node), .array_init_dot, .array_init_dot_comma => tree.arrayInitDot(node), @@ -2423,16 +2411,16 @@ pub fn fullArrayInit(tree: Ast, buffer: *[2]Node.Index, node: Node.Index) ?full. }; } -pub fn fullArrayType(tree: Ast, node: Node.Index) ?full.ArrayType { - return switch (tree.nodeTag(node)) { +pub fn fullArrayType(tree: *const Ast, node: Node.Index) ?full.ArrayType { + return switch (node.tag(tree)) { .array_type => tree.arrayType(node), .array_type_sentinel => tree.arrayTypeSentinel(node), else => null, }; } -pub fn fullPtrType(tree: Ast, node: Node.Index) ?full.PtrType { - return switch (tree.nodeTag(node)) { +pub fn fullPtrType(tree: *const Ast, node: Node.Index) ?full.PtrType { + return switch (node.tag(tree)) { .ptr_type_aligned => tree.ptrTypeAligned(node), .ptr_type_sentinel => tree.ptrTypeSentinel(node), .ptr_type => tree.ptrType(node), @@ -2441,8 +2429,8 @@ pub fn fullPtrType(tree: Ast, node: Node.Index) ?full.PtrType { }; } -pub fn fullSlice(tree: Ast, node: Node.Index) ?full.Slice { - return switch (tree.nodeTag(node)) { +pub fn fullSlice(tree: *const Ast, node: Node.Index) ?full.Slice { + return switch (node.tag(tree)) { .slice_open => tree.sliceOpen(node), .slice => tree.slice(node), .slice_sentinel => tree.sliceSentinel(node), @@ -2450,8 +2438,8 @@ pub fn fullSlice(tree: Ast, node: Node.Index) ?full.Slice { }; } -pub fn fullContainerDecl(tree: Ast, buffer: *[2]Ast.Node.Index, node: Node.Index) ?full.ContainerDecl { - return switch (tree.nodeTag(node)) { +pub fn fullContainerDecl(tree: *const Ast, buffer: *[2]Ast.Node.Index, node: Node.Index) ?full.ContainerDecl { + return switch (node.tag(tree)) { .root => tree.containerDeclRoot(), .container_decl, .container_decl_trailing => tree.containerDecl(node), .container_decl_arg, .container_decl_arg_trailing => tree.containerDeclArg(node), @@ -2463,49 +2451,49 @@ pub fn fullContainerDecl(tree: Ast, buffer: *[2]Ast.Node.Index, node: Node.Index }; } -pub fn fullSwitch(tree: Ast, node: Node.Index) ?full.Switch { - return switch (tree.nodeTag(node)) { +pub fn fullSwitch(tree: *const Ast, node: Node.Index) ?full.Switch { + return switch (node.tag(tree)) { .@"switch", .switch_comma => tree.switchFull(node), else => null, }; } -pub fn fullSwitchCase(tree: Ast, node: Node.Index) ?full.SwitchCase { - return switch (tree.nodeTag(node)) { +pub fn fullSwitchCase(tree: *const Ast, node: Node.Index) ?full.SwitchCase { + return switch (node.tag(tree)) { .switch_case_one, .switch_case_inline_one => tree.switchCaseOne(node), .switch_case, .switch_case_inline => tree.switchCase(node), else => null, }; } -pub fn fullAsm(tree: Ast, node: Node.Index) ?full.Asm { - return switch (tree.nodeTag(node)) { +pub fn fullAsm(tree: *const Ast, node: Node.Index) ?full.Asm { + return switch (node.tag(tree)) { .asm_simple => tree.asmSimple(node), .@"asm" => tree.asmFull(node), else => null, }; } -pub fn fullCall(tree: Ast, buffer: *[1]Ast.Node.Index, node: Node.Index) ?full.Call { - return switch (tree.nodeTag(node)) { +pub fn fullCall(tree: *const Ast, buffer: *[1]Ast.Node.Index, node: Node.Index) ?full.Call { + return switch (node.tag(tree)) { .call, .call_comma, .async_call, .async_call_comma => tree.callFull(node), .call_one, .call_one_comma, .async_call_one, .async_call_one_comma => tree.callOne(buffer, node), else => null, }; } -pub fn builtinCallParams(tree: Ast, buffer: *[2]Ast.Node.Index, node: Ast.Node.Index) ?[]const Node.Index { - return switch (tree.nodeTag(node)) { - .builtin_call_two, .builtin_call_two_comma => loadOptionalNodesIntoBuffer(2, buffer, tree.nodeData(node).opt_node_and_opt_node), - .builtin_call, .builtin_call_comma => tree.extraDataSlice(tree.nodeData(node).extra_range, Node.Index), +pub fn builtinCallParams(tree: *const Ast, buffer: *[2]Ast.Node.Index, node: Ast.Node.Index) ?[]const Node.Index { + return switch (node.tag(tree)) { + .builtin_call_two, .builtin_call_two_comma => loadOptionalNodesIntoBuffer(2, buffer, node.data(tree).opt_node_and_opt_node), + .builtin_call, .builtin_call_comma => tree.extraDataSlice(node.data(tree).extra_range, Node.Index), else => null, }; } -pub fn blockStatements(tree: Ast, buffer: *[2]Ast.Node.Index, node: Ast.Node.Index) ?[]const Node.Index { - return switch (tree.nodeTag(node)) { - .block_two, .block_two_semicolon => loadOptionalNodesIntoBuffer(2, buffer, tree.nodeData(node).opt_node_and_opt_node), - .block, .block_semicolon => tree.extraDataSlice(tree.nodeData(node).extra_range, Node.Index), +pub fn blockStatements(tree: *const Ast, buffer: *[2]Ast.Node.Index, node: Ast.Node.Index) ?[]const Node.Index { + return switch (node.tag(tree)) { + .block_two, .block_two_semicolon => loadOptionalNodesIntoBuffer(2, buffer, node.data(tree).opt_node_and_opt_node), + .block, .block_semicolon => tree.extraDataSlice(node.data(tree).extra_range, Node.Index), else => null, }; } @@ -2620,7 +2608,7 @@ pub const full = struct { pub fn convertToNonTupleLike(cf: *ContainerField, tree: *const Ast) void { if (!cf.ast.tuple_like) return; - if (tree.nodeTag(cf.ast.type_expr.unwrap().?) != .identifier) return; + if (cf.ast.type_expr.unwrap().?.tag(tree) != .identifier) return; cf.ast.type_expr = .none; cf.ast.tuple_like = false; @@ -3004,6 +2992,18 @@ pub const Node = struct { const destination_i64: i64 = @intFromEnum(destination); return @enumFromInt(destination_i64 - base_i64); } + + pub fn tag(i: Node.Index, tree: *const Ast) Tag { + return tree.nodes.items(.tag)[@intFromEnum(i)]; + } + + pub fn mainToken(i: Index, ast: *const Ast) TokenIndex { + return ast.nodes.items(.main_token)[@intFromEnum(i)]; + } + + pub fn data(i: Index, ast: *const Ast) Data { + return ast.nodes.items(.data)[@intFromEnum(i)]; + } }; /// Index into `nodes`, or null. @@ -4098,7 +4098,7 @@ pub fn nodeToSpan(tree: *const Ast, node: Ast.Node.Index) Span { tree, tree.firstToken(node), tree.lastToken(node), - tree.nodeMainToken(node), + node.mainToken(tree), ); } diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig index b349903742..7d0545fbb8 100644 --- a/lib/std/zig/AstGen.zig +++ b/lib/std/zig/AstGen.zig @@ -141,7 +141,7 @@ fn appendRefsAssumeCapacity(astgen: *AstGen, refs: []const Zir.Inst.Ref) void { astgen.extra.appendSliceAssumeCapacity(@ptrCast(refs)); } -pub fn generate(gpa: Allocator, tree: Ast) Allocator.Error!Zir { +pub fn generate(gpa: Allocator, tree: *const Ast) Allocator.Error!Zir { assert(tree.mode == .zig); var arena = std.heap.ArenaAllocator.init(gpa); @@ -153,7 +153,7 @@ pub fn generate(gpa: Allocator, tree: Ast) Allocator.Error!Zir { var astgen: AstGen = .{ .gpa = gpa, .arena = arena.allocator(), - .tree = &tree, + .tree = tree, .nodes_need_rl = &nodes_need_rl, .src_hasher = undefined, // `structDeclInner` for the root struct will set this }; @@ -440,7 +440,7 @@ fn reachableExprComptime( fn lvalExpr(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; const tree = astgen.tree; - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .root => unreachable, .@"usingnamespace" => unreachable, .test_decl => unreachable, @@ -608,7 +608,7 @@ fn lvalExpr(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Ins .builtin_call_two, .builtin_call_two_comma, => { - const builtin_token = tree.nodeMainToken(node); + const builtin_token = node.mainToken(tree); const builtin_name = tree.tokenSlice(builtin_token); // If the builtin is an invalid name, we don't cause an error here; instead // let it pass, and the error will be "invalid builtin function" later. @@ -646,7 +646,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE gz.anon_name_strategy = .anon; } - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .root => unreachable, // Top-level declaration. .@"usingnamespace" => unreachable, // Top-level declaration. .test_decl => unreachable, // Top-level declaration. @@ -756,8 +756,8 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE }, // zig fmt: off - .shl => return shiftOp(gz, scope, ri, node, tree.nodeData(node).node_and_node[0], tree.nodeData(node).node_and_node[1], .shl), - .shr => return shiftOp(gz, scope, ri, node, tree.nodeData(node).node_and_node[0], tree.nodeData(node).node_and_node[1], .shr), + .shl => return shiftOp(gz, scope, ri, node, node.data(tree).node_and_node[0], node.data(tree).node_and_node[1], .shl), + .shr => return shiftOp(gz, scope, ri, node, node.data(tree).node_and_node[0], node.data(tree).node_and_node[1], .shr), .add => return simpleBinOp(gz, scope, ri, node, .add), .add_wrap => return simpleBinOp(gz, scope, ri, node, .addwrap), @@ -787,7 +787,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE // This syntax form does not currently use the result type in the language specification. // However, the result type can be used to emit more optimal code for large multiplications by // having Sema perform a coercion before the multiplication operation. - const lhs_node, const rhs_node = tree.nodeData(node).node_and_node; + const lhs_node, const rhs_node = node.data(tree).node_and_node; const result = try gz.addPlNode(.array_mul, node, Zir.Inst.ArrayMul{ .res_ty = if (try ri.rl.resultType(gz, node)) |t| t else .none, .lhs = try expr(gz, scope, .{ .rl = .none }, lhs_node), @@ -802,7 +802,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE .merge_error_sets => .merge_error_sets, else => unreachable, }; - const lhs_node, const rhs_node = tree.nodeData(node).node_and_node; + const lhs_node, const rhs_node = node.data(tree).node_and_node; const lhs = try reachableTypeExpr(gz, scope, lhs_node, node); const rhs = try reachableTypeExpr(gz, scope, rhs_node, node); const result = try gz.addPlNode(inst_tag, node, Zir.Inst.Bin{ .lhs = lhs, .rhs = rhs }); @@ -812,11 +812,11 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE .bool_and => return boolBinOp(gz, scope, ri, node, .bool_br_and), .bool_or => return boolBinOp(gz, scope, ri, node, .bool_br_or), - .bool_not => return simpleUnOp(gz, scope, ri, node, coerced_bool_ri, tree.nodeData(node).node, .bool_not), - .bit_not => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, tree.nodeData(node).node, .bit_not), + .bool_not => return simpleUnOp(gz, scope, ri, node, coerced_bool_ri, node.data(tree).node, .bool_not), + .bit_not => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, node.data(tree).node, .bit_not), .negation => return negation(gz, scope, ri, node), - .negation_wrap => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, tree.nodeData(node).node, .negate_wrap), + .negation_wrap => return simpleUnOp(gz, scope, ri, node, .{ .rl = .none }, node.data(tree).node, .negate_wrap), .identifier => return identifier(gz, scope, ri, node, null), @@ -875,8 +875,8 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE const else_node = if_full.ast.else_expr.unwrap() orelse break :no_switch_on_err; const full_switch = tree.fullSwitch(else_node) orelse break :no_switch_on_err; if (full_switch.label_token != null) break :no_switch_on_err; - if (tree.nodeTag(full_switch.ast.condition) != .identifier) break :no_switch_on_err; - if (!mem.eql(u8, tree.tokenSlice(error_token), tree.tokenSlice(tree.nodeMainToken(full_switch.ast.condition)))) break :no_switch_on_err; + if (full_switch.ast.condition.tag(tree) != .identifier) break :no_switch_on_err; + if (!mem.eql(u8, tree.tokenSlice(error_token), tree.tokenSlice(full_switch.ast.condition.mainToken(tree)))) break :no_switch_on_err; return switchExprErrUnion(gz, scope, ri.br(), node, .@"if"); } return ifExpr(gz, scope, ri.br(), node, if_full); @@ -895,7 +895,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE => { const full = tree.fullSlice(node).?; if (full.ast.end != .none and - tree.nodeTag(full.ast.sliced) == .slice_open and + full.ast.sliced.tag(tree) == .slice_open and nodeIsTriviallyZero(tree, full.ast.start)) { const lhs_extra = tree.sliceOpen(full.ast.sliced).ast; @@ -950,7 +950,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE }, .deref => { - const lhs = try expr(gz, scope, .{ .rl = .none }, tree.nodeData(node).node); + const lhs = try expr(gz, scope, .{ .rl = .none }, node.data(tree).node); _ = try gz.addUnNode(.validate_deref, lhs, node); switch (ri.rl) { .ref, .ref_coerced_ty => return lhs, @@ -965,17 +965,17 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE _ = try gz.addUnTok(.validate_ref_ty, res_ty_inst, tree.firstToken(node)); break :rl .{ .ref_coerced_ty = res_ty_inst }; } else .ref; - const result = try expr(gz, scope, .{ .rl = operand_rl }, tree.nodeData(node).node); + const result = try expr(gz, scope, .{ .rl = operand_rl }, node.data(tree).node); return rvalue(gz, ri, result, node); }, .optional_type => { - const operand = try typeExpr(gz, scope, tree.nodeData(node).node); + const operand = try typeExpr(gz, scope, node.data(tree).node); const result = try gz.addUnNode(.optional_type, operand, node); return rvalue(gz, ri, result, node); }, .unwrap_optional => switch (ri.rl) { .ref, .ref_coerced_ty => { - const lhs = try expr(gz, scope, .{ .rl = .ref }, tree.nodeData(node).node_and_token[0]); + const lhs = try expr(gz, scope, .{ .rl = .ref }, node.data(tree).node_and_token[0]); const cursor = maybeAdvanceSourceCursorToMainToken(gz, node); try emitDbgStmt(gz, cursor); @@ -983,7 +983,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE return gz.addUnNode(.optional_payload_safe_ptr, lhs, node); }, else => { - const lhs = try expr(gz, scope, .{ .rl = .none }, tree.nodeData(node).node_and_token[0]); + const lhs = try expr(gz, scope, .{ .rl = .none }, node.data(tree).node_and_token[0]); const cursor = maybeAdvanceSourceCursorToMainToken(gz, node); try emitDbgStmt(gz, cursor); @@ -1001,7 +1001,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE return blockExpr(gz, scope, ri, node, statements, .normal); }, .enum_literal => if (try ri.rl.resultType(gz, node)) |res_ty| { - const str_index = try astgen.identAsString(tree.nodeMainToken(node)); + const str_index = try astgen.identAsString(node.mainToken(tree)); const res = try gz.addPlNode(.decl_literal, node, Zir.Inst.Field{ .lhs = res_ty, .field_name_start = str_index, @@ -1011,8 +1011,8 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE .ty, .coerced_ty => return res, // `decl_literal` does the coercion for us .ref_coerced_ty, .ptr, .inferred_ptr, .destructure => return rvalue(gz, ri, res, node), } - } else return simpleStrTok(gz, ri, tree.nodeMainToken(node), node, .enum_literal), - .error_value => return simpleStrTok(gz, ri, tree.nodeMainToken(node) + 2, node, .error_value), + } else return simpleStrTok(gz, ri, node.mainToken(tree), node, .enum_literal), + .error_value => return simpleStrTok(gz, ri, node.mainToken(tree) + 2, node, .error_value), // TODO restore this when implementing https://github.com/ziglang/zig/issues/6025 // .anyframe_literal => return rvalue(gz, ri, .anyframe_type, node), .anyframe_literal => { @@ -1020,22 +1020,22 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE return rvalue(gz, ri, result, node); }, .anyframe_type => { - const return_type = try typeExpr(gz, scope, tree.nodeData(node).token_and_node[1]); + const return_type = try typeExpr(gz, scope, node.data(tree).token_and_node[1]); const result = try gz.addUnNode(.anyframe_type, return_type, node); return rvalue(gz, ri, result, node); }, .@"catch" => { - const catch_token = tree.nodeMainToken(node); + const catch_token = node.mainToken(tree); const payload_token: ?Ast.TokenIndex = if (tree.tokenTag(catch_token + 1) == .pipe) catch_token + 2 else null; no_switch_on_err: { const capture_token = payload_token orelse break :no_switch_on_err; - const full_switch = tree.fullSwitch(tree.nodeData(node).node_and_node[1]) orelse break :no_switch_on_err; + const full_switch = tree.fullSwitch(node.data(tree).node_and_node[1]) orelse break :no_switch_on_err; if (full_switch.label_token != null) break :no_switch_on_err; - if (tree.nodeTag(full_switch.ast.condition) != .identifier) break :no_switch_on_err; - if (!mem.eql(u8, tree.tokenSlice(capture_token), tree.tokenSlice(tree.nodeMainToken(full_switch.ast.condition)))) break :no_switch_on_err; + if (full_switch.ast.condition.tag(tree) != .identifier) break :no_switch_on_err; + if (!mem.eql(u8, tree.tokenSlice(capture_token), tree.tokenSlice(full_switch.ast.condition.mainToken(tree)))) break :no_switch_on_err; return switchExprErrUnion(gz, scope, ri.br(), node, .@"catch"); } switch (ri.rl) { @@ -1109,7 +1109,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE .@"break" => return breakExpr(gz, scope, node), .@"continue" => return continueExpr(gz, scope, node), - .grouped_expression => return expr(gz, scope, ri, tree.nodeData(node).node_and_token[0]), + .grouped_expression => return expr(gz, scope, ri, node.data(tree).node_and_token[0]), .array_type => return arrayType(gz, scope, ri, node), .array_type_sentinel => return arrayTypeSentinel(gz, scope, ri, node), .char_literal => return charLiteral(gz, ri, node), @@ -1123,7 +1123,7 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE .@"await" => return awaitExpr(gz, scope, ri, node), .@"resume" => return resumeExpr(gz, scope, ri, node), - .@"try" => return tryExpr(gz, scope, ri, node, tree.nodeData(node).node), + .@"try" => return tryExpr(gz, scope, ri, node, node.data(tree).node), .array_init_one, .array_init_one_comma, @@ -1170,7 +1170,7 @@ fn nosuspendExpr( ) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; const tree = astgen.tree; - const body_node = tree.nodeData(node).node; + const body_node = node.data(tree).node; if (gz.nosuspend_node.unwrap()) |nosuspend_node| { try astgen.appendErrorNodeNotes(node, "redundant nosuspend block", .{}, &[_]u32{ try astgen.errNoteNode(nosuspend_node, "other nosuspend block here", .{}), @@ -1189,7 +1189,7 @@ fn suspendExpr( const astgen = gz.astgen; const gpa = astgen.gpa; const tree = astgen.tree; - const body_node = tree.nodeData(node).node; + const body_node = node.data(tree).node; if (gz.nosuspend_node.unwrap()) |nosuspend_node| { return astgen.failNodeNotes(node, "suspend inside nosuspend block", .{}, &[_]u32{ @@ -1226,7 +1226,7 @@ fn awaitExpr( ) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; const tree = astgen.tree; - const rhs_node = tree.nodeData(node).node; + const rhs_node = node.data(tree).node; if (gz.suspend_node.unwrap()) |suspend_node| { return astgen.failNodeNotes(node, "cannot await inside suspend block", .{}, &[_]u32{ @@ -1253,7 +1253,7 @@ fn resumeExpr( ) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; const tree = astgen.tree; - const rhs_node = tree.nodeData(node).node; + const rhs_node = node.data(tree).node; const operand = try expr(gz, scope, .{ .rl = .ref }, rhs_node); const result = try gz.addUnNode(.@"resume", operand, node); return rvalue(gz, ri, result, node); @@ -1363,7 +1363,7 @@ fn fnProtoExprInner( const param_type = try fullBodyExpr(¶m_gz, scope, coerced_type_ri, param_type_node, .normal); const param_inst_expected: Zir.Inst.Index = @enumFromInt(astgen.instructions.len + 1); _ = try param_gz.addBreakWithSrcNode(.break_inline, param_inst_expected, param_type, param_type_node); - const name_token = param.name_token orelse tree.nodeMainToken(param_type_node); + const name_token = param.name_token orelse param_type_node.mainToken(tree); const tag: Zir.Inst.Tag = if (is_comptime) .param_comptime else .param; // We pass `prev_param_insts` as `&.{}` here because a function prototype can't refer to previous // arguments (we haven't set up scopes here). @@ -1437,8 +1437,8 @@ fn arrayInitExpr( infer: { const array_type: Ast.full.ArrayType = tree.fullArrayType(type_expr) orelse break :infer; // This intentionally does not support `@"_"` syntax. - if (tree.nodeTag(array_type.ast.elem_count) == .identifier and - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(array_type.ast.elem_count)), "_")) + if (array_type.ast.elem_count.tag(tree) == .identifier and + mem.eql(u8, tree.tokenSlice(array_type.ast.elem_count.mainToken(tree)), "_")) { const len_inst = try gz.addInt(array_init.ast.elements.len); const elem_type = try typeExpr(gz, scope, array_type.ast.elem_type); @@ -1705,9 +1705,9 @@ fn structInitExpr( } break :array; }; - const is_inferred_array_len = tree.nodeTag(array_type.ast.elem_count) == .identifier and + const is_inferred_array_len = array_type.ast.elem_count.tag(tree) == .identifier and // This intentionally does not support `@"_"` syntax. - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(array_type.ast.elem_count)), "_"); + mem.eql(u8, tree.tokenSlice(array_type.ast.elem_count.mainToken(tree)), "_"); if (struct_init.ast.fields.len == 0) { if (is_inferred_array_len) { const elem_type = try typeExpr(gz, scope, array_type.ast.elem_type); @@ -1987,7 +1987,7 @@ fn comptimeExpr2( // no need to wrap it in a block. This is hard to determine in general, but we can identify a // common subset of trivially comptime expressions to take down the size of the ZIR a bit. const tree = gz.astgen.tree; - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .identifier => { // Many identifiers can be handled without a `block_comptime`, so `AstGen.identifier` has // special handling for this case. @@ -2040,7 +2040,7 @@ fn comptimeExpr2( // comptime block, because that would be silly! Note that we don't bother doing this for // unlabelled blocks, since they don't generate blocks at comptime anyway (see `blockExpr`). .block_two, .block_two_semicolon, .block, .block_semicolon => { - const lbrace = tree.nodeMainToken(node); + const lbrace = node.mainToken(tree); // Careful! We can't pass in the real result location here, since it may // refer to runtime memory. A runtime-to-comptime boundary has to remove // result location information, compute the result, and copy it to the true @@ -2103,7 +2103,7 @@ fn comptimeExprAst( try astgen.appendErrorNode(node, "redundant comptime keyword in already comptime scope", .{}); } const tree = astgen.tree; - const body_node = tree.nodeData(node).node; + const body_node = node.data(tree).node; return comptimeExpr2(gz, scope, ri, body_node, node, .comptime_keyword); } @@ -2141,7 +2141,7 @@ fn restoreErrRetIndex( fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref { const astgen = parent_gz.astgen; const tree = astgen.tree; - const opt_break_label, const opt_rhs = tree.nodeData(node).opt_token_and_opt_node; + const opt_break_label, const opt_rhs = node.data(tree).opt_token_and_opt_node; // Look for the label in the scope. var scope = parent_scope; @@ -2237,7 +2237,7 @@ fn breakExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index) Inn fn continueExpr(parent_gz: *GenZir, parent_scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref { const astgen = parent_gz.astgen; const tree = astgen.tree; - const opt_break_label, const opt_rhs = tree.nodeData(node).opt_token_and_opt_node; + const opt_break_label, const opt_rhs = node.data(tree).opt_token_and_opt_node; if (opt_break_label == .none and opt_rhs != .none) { return astgen.failNode(node, "cannot continue with operand without label", .{}); @@ -2359,7 +2359,7 @@ fn fullBodyExpr( const statements = tree.blockStatements(&stmt_buf, node) orelse return expr(gz, scope, ri, node); - const lbrace = tree.nodeMainToken(node); + const lbrace = node.mainToken(tree); if (tree.isTokenPrecededByTags(lbrace, &.{ .identifier, .colon })) { // Labeled blocks are tricky - forwarding result location information properly is non-trivial, @@ -2387,7 +2387,7 @@ fn blockExpr( const astgen = gz.astgen; const tree = astgen.tree; - const lbrace = tree.nodeMainToken(block_node); + const lbrace = block_node.mainToken(tree); if (tree.isTokenPrecededByTags(lbrace, &.{ .identifier, .colon })) { return labeledBlockExpr(gz, scope, ri, block_node, statements, false, kind); } @@ -2466,7 +2466,7 @@ fn labeledBlockExpr( const astgen = gz.astgen; const tree = astgen.tree; - const lbrace = tree.nodeMainToken(block_node); + const lbrace = block_node.mainToken(tree); const label_token = lbrace - 2; assert(tree.tokenTag(label_token) == .identifier); @@ -2559,7 +2559,7 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const Ast.Nod }; var inner_node = statement; while (true) { - switch (tree.nodeTag(inner_node)) { + switch (inner_node.tag(tree)) { // zig fmt: off .global_var_decl, .local_var_decl, @@ -2589,7 +2589,7 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const Ast.Nod .assign_mul_wrap => try assignOp(gz, scope, statement, .mulwrap), .grouped_expression => { - inner_node = tree.nodeData(statement).node_and_token[0]; + inner_node = statement.data(tree).node_and_token[0]; continue; }, @@ -3122,7 +3122,7 @@ fn deferStmt( var local_val_scope: Scope.LocalVal = undefined; var opt_remapped_err_code: Zir.Inst.OptionalIndex = .none; const sub_scope = if (scope_tag != .defer_error) &defer_gen.base else blk: { - const payload_token = tree.nodeData(node).opt_token_and_node[0].unwrap() orelse break :blk &defer_gen.base; + const payload_token = node.data(tree).opt_token_and_node[0].unwrap() orelse break :blk &defer_gen.base; const ident_name = try gz.astgen.identAsString(payload_token); if (std.mem.eql(u8, tree.tokenSlice(payload_token), "_")) { try gz.astgen.appendErrorTok(payload_token, "discard of error capture; omit it instead", .{}); @@ -3151,8 +3151,8 @@ fn deferStmt( break :blk &local_val_scope.base; }; const expr_node = switch (scope_tag) { - .defer_normal => tree.nodeData(node).node, - .defer_error => tree.nodeData(node).opt_token_and_node[1], + .defer_normal => node.data(tree).node, + .defer_error => node.data(tree).opt_token_and_node[1], else => unreachable, }; _ = try unusedResultExpr(&defer_gen, sub_scope, expr_node); @@ -3210,11 +3210,11 @@ fn varDecl( }; if (var_decl.ast.addrspace_node.unwrap()) |addrspace_node| { - return astgen.failTok(tree.nodeMainToken(addrspace_node), "cannot set address space of local variable '{s}'", .{ident_name_raw}); + return astgen.failTok(addrspace_node.mainToken(tree), "cannot set address space of local variable '{s}'", .{ident_name_raw}); } if (var_decl.ast.section_node.unwrap()) |section_node| { - return astgen.failTok(tree.nodeMainToken(section_node), "cannot set section of local variable '{s}'", .{ident_name_raw}); + return astgen.failTok(section_node.mainToken(tree), "cannot set section of local variable '{s}'", .{ident_name_raw}); } const align_inst: Zir.Inst.Ref = if (var_decl.ast.align_node.unwrap()) |align_node| @@ -3267,7 +3267,7 @@ fn varDecl( } const is_comptime = gz.is_comptime or - tree.nodeTag(init_node) == .@"comptime"; + init_node.tag(tree) == .@"comptime"; const init_rl: ResultInfo.Loc = if (var_decl.ast.type_node.unwrap()) |type_node| init_rl: { const type_inst = try typeExpr(gz, scope, type_node); @@ -3430,10 +3430,10 @@ fn assign(gz: *GenZir, scope: *Scope, infix_node: Ast.Node.Index) InnerError!voi const astgen = gz.astgen; const tree = astgen.tree; - const lhs, const rhs = tree.nodeData(infix_node).node_and_node; - if (tree.nodeTag(lhs) == .identifier) { + const lhs, const rhs = infix_node.data(tree).node_and_node; + if (lhs.tag(tree) == .identifier) { // This intentionally does not support `@"_"` syntax. - const ident_name = tree.tokenSlice(tree.nodeMainToken(lhs)); + const ident_name = tree.tokenSlice(lhs.mainToken(tree)); if (mem.eql(u8, ident_name, "_")) { _ = try expr(gz, scope, .{ .rl = .discard, .ctx = .assignment }, rhs); return; @@ -3468,9 +3468,9 @@ fn assignDestructure(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerErro const rl_components = try astgen.arena.alloc(ResultInfo.Loc.DestructureComponent, full.ast.variables.len); for (rl_components, full.ast.variables) |*variable_rl, variable_node| { - if (tree.nodeTag(variable_node) == .identifier) { + if (variable_node.tag(tree) == .identifier) { // This intentionally does not support `@"_"` syntax. - const ident_name = tree.tokenSlice(tree.nodeMainToken(variable_node)); + const ident_name = tree.tokenSlice(variable_node.mainToken(tree)); if (mem.eql(u8, ident_name, "_")) { variable_rl.* = .discard; continue; @@ -3514,7 +3514,7 @@ fn assignDestructureMaybeDecls( } const is_comptime = full.comptime_token != null or gz.is_comptime; - const value_is_comptime = tree.nodeTag(full.ast.value_expr) == .@"comptime"; + const value_is_comptime = full.ast.value_expr.tag(tree) == .@"comptime"; // When declaring consts via a destructure, we always use a result pointer. // This avoids the need to create tuple types, and is also likely easier to @@ -3527,10 +3527,10 @@ fn assignDestructureMaybeDecls( var any_non_const_variables = false; var any_lvalue_expr = false; for (rl_components, full.ast.variables) |*variable_rl, variable_node| { - switch (tree.nodeTag(variable_node)) { + switch (variable_node.tag(tree)) { .identifier => { // This intentionally does not support `@"_"` syntax. - const ident_name = tree.tokenSlice(tree.nodeMainToken(variable_node)); + const ident_name = tree.tokenSlice(variable_node.mainToken(tree)); if (mem.eql(u8, ident_name, "_")) { any_non_const_variables = true; variable_rl.* = .discard; @@ -3549,10 +3549,10 @@ fn assignDestructureMaybeDecls( // We detect shadowing in the second pass over these, while we're creating scopes. if (full_var_decl.ast.addrspace_node.unwrap()) |addrspace_node| { - return astgen.failTok(tree.nodeMainToken(addrspace_node), "cannot set address space of local variable '{s}'", .{ident_name_raw}); + return astgen.failTok(addrspace_node.mainToken(tree), "cannot set address space of local variable '{s}'", .{ident_name_raw}); } if (full_var_decl.ast.section_node.unwrap()) |section_node| { - return astgen.failTok(tree.nodeMainToken(section_node), "cannot set section of local variable '{s}'", .{ident_name_raw}); + return astgen.failTok(section_node.mainToken(tree), "cannot set section of local variable '{s}'", .{ident_name_raw}); } const is_const = switch (tree.tokenTag(full_var_decl.ast.mut_token)) { @@ -3641,7 +3641,7 @@ fn assignDestructureMaybeDecls( // evaluate the lvalues from within the possible block_comptime. for (rl_components, full.ast.variables) |*variable_rl, variable_node| { if (variable_rl.* != .typed_ptr) continue; - switch (tree.nodeTag(variable_node)) { + switch (variable_node.tag(tree)) { .global_var_decl, .local_var_decl, .simple_var_decl, .aligned_var_decl => continue, else => {}, } @@ -3670,7 +3670,7 @@ fn assignDestructureMaybeDecls( // If there were any `const` decls, make the pointer constant. var cur_scope = scope; for (rl_components, full.ast.variables) |variable_rl, variable_node| { - switch (tree.nodeTag(variable_node)) { + switch (variable_node.tag(tree)) { .local_var_decl, .simple_var_decl, .aligned_var_decl => {}, else => continue, // We were mutating an existing lvalue - nothing to do } @@ -3732,7 +3732,7 @@ fn assignOp( const astgen = gz.astgen; const tree = astgen.tree; - const lhs_node, const rhs_node = tree.nodeData(infix_node).node_and_node; + const lhs_node, const rhs_node = infix_node.data(tree).node_and_node; const lhs_ptr = try lvalExpr(gz, scope, lhs_node); const cursor = switch (op_inst_tag) { @@ -3787,7 +3787,7 @@ fn assignShift( const astgen = gz.astgen; const tree = astgen.tree; - const lhs_node, const rhs_node = tree.nodeData(infix_node).node_and_node; + const lhs_node, const rhs_node = infix_node.data(tree).node_and_node; const lhs_ptr = try lvalExpr(gz, scope, lhs_node); const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node); const rhs_type = try gz.addUnNode(.typeof_log2_int_type, lhs, infix_node); @@ -3808,7 +3808,7 @@ fn assignShiftSat(gz: *GenZir, scope: *Scope, infix_node: Ast.Node.Index) InnerE const astgen = gz.astgen; const tree = astgen.tree; - const lhs_node, const rhs_node = tree.nodeData(infix_node).node_and_node; + const lhs_node, const rhs_node = infix_node.data(tree).node_and_node; const lhs_ptr = try lvalExpr(gz, scope, lhs_node); const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node); // Saturating shift-left allows any integer type for both the LHS and RHS. @@ -3940,9 +3940,9 @@ fn arrayType(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) ! const astgen = gz.astgen; const tree = astgen.tree; - const len_node, const elem_type_node = tree.nodeData(node).node_and_node; - if (tree.nodeTag(len_node) == .identifier and - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(len_node)), "_")) + const len_node, const elem_type_node = node.data(tree).node_and_node; + if (len_node.tag(tree) == .identifier and + mem.eql(u8, tree.tokenSlice(len_node.mainToken(tree)), "_")) { return astgen.failNode(len_node, "unable to infer array size", .{}); } @@ -3960,11 +3960,11 @@ fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node. const astgen = gz.astgen; const tree = astgen.tree; - const len_node, const extra_index = tree.nodeData(node).node_and_extra; + const len_node, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Ast.Node.ArrayTypeSentinel); - if (tree.nodeTag(len_node) == .identifier and - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(len_node)), "_")) + if (len_node.tag(tree) == .identifier and + mem.eql(u8, tree.tokenSlice(len_node.mainToken(tree)), "_")) { return astgen.failNode(len_node, "unable to infer array size", .{}); } @@ -4288,8 +4288,8 @@ fn fnDeclInner( } else { const type_expr = param.type_expr.?; ambiguous: { - if (tree.nodeTag(type_expr) != .identifier) break :ambiguous; - const main_token = tree.nodeMainToken(type_expr); + if (type_expr.tag(tree) != .identifier) break :ambiguous; + const main_token = type_expr.mainToken(tree); const identifier_str = tree.tokenSlice(main_token); if (isPrimitive(identifier_str)) break :ambiguous; return astgen.failNodeNotes( @@ -4331,7 +4331,7 @@ fn fnDeclInner( _ = try param_gz.addBreakWithSrcNode(.break_inline, param_inst_expected, param_type, param_type_node); const param_type_is_generic = any_param_used; - const name_token = param.name_token orelse tree.nodeMainToken(param_type_node); + const name_token = param.name_token orelse param_type_node.mainToken(tree); const tag: Zir.Inst.Tag = if (is_comptime) .param_comptime else .param; const param_inst = try decl_gz.addParam(¶m_gz, param_insts.items, param_type_is_generic, tag, name_token, param_name); assert(param_inst_expected == param_inst); @@ -4428,7 +4428,7 @@ fn fnDeclInner( // Leave `astgen.src_hasher` unmodified; this will be used for hashing // the *whole* function declaration, including its body. var proto_hasher = astgen.src_hasher; - const proto_node = tree.nodeData(decl_node).node_and_node[0]; + const proto_node = decl_node.data(tree).node_and_node[0]; proto_hasher.update(tree.getNodeSource(proto_node)); var proto_hash: std.zig.SrcHash = undefined; proto_hasher.final(&proto_hash); @@ -4643,7 +4643,7 @@ fn comptimeDecl( node: Ast.Node.Index, ) InnerError!void { const tree = astgen.tree; - const body_node = tree.nodeData(node).node; + const body_node = node.data(tree).node; const old_hasher = astgen.src_hasher; defer astgen.src_hasher = old_hasher; @@ -4713,8 +4713,8 @@ fn usingnamespaceDecl( astgen.src_hasher.update(tree.getNodeSource(node)); astgen.src_hasher.update(std.mem.asBytes(&astgen.source_column)); - const type_expr = tree.nodeData(node).node; - const is_pub = tree.isTokenPrecededByTags(tree.nodeMainToken(node), &.{.keyword_pub}); + const type_expr = node.data(tree).node; + const is_pub = tree.isTokenPrecededByTags(node.mainToken(tree), &.{.keyword_pub}); // Up top so the ZIR instruction index marks the start range of this // top-level declaration. @@ -4769,7 +4769,7 @@ fn testDecl( node: Ast.Node.Index, ) InnerError!void { const tree = astgen.tree; - _, const body_node = tree.nodeData(node).opt_token_and_node; + _, const body_node = node.data(tree).opt_token_and_node; const old_hasher = astgen.src_hasher; defer astgen.src_hasher = old_hasher; @@ -4801,7 +4801,7 @@ fn testDecl( const decl_column = astgen.source_column; - const test_token = tree.nodeMainToken(node); + const test_token = node.mainToken(tree); const test_name_token = test_token + 1; const test_name: Zir.NullTerminatedString = switch (tree.tokenTag(test_name_token)) { @@ -5275,7 +5275,7 @@ fn tupleDecl( for (container_decl.ast.members) |member_node| { const field = tree.fullContainerField(member_node) orelse { - const tuple_member = for (container_decl.ast.members) |maybe_tuple| switch (tree.nodeTag(maybe_tuple)) { + const tuple_member = for (container_decl.ast.members) |maybe_tuple| switch (maybe_tuple.tag(tree)) { .container_field_init, .container_field_align, .container_field, @@ -5845,7 +5845,7 @@ fn containerMember( ) InnerError!ContainerMemberResult { const astgen = gz.astgen; const tree = astgen.tree; - switch (tree.nodeTag(member_node)) { + switch (member_node.tag(tree)) { .container_field_init, .container_field_align, .container_field, @@ -5860,8 +5860,8 @@ fn containerMember( var buf: [1]Ast.Node.Index = undefined; const full = tree.fullFnProto(&buf, member_node).?; - const body: Ast.Node.OptionalIndex = if (tree.nodeTag(member_node) == .fn_decl) - tree.nodeData(member_node).node_and_node[1].toOptional() + const body: Ast.Node.OptionalIndex = if (member_node.tag(tree) == .fn_decl) + member_node.data(tree).node_and_node[1].toOptional() else .none; @@ -5934,7 +5934,7 @@ fn containerMember( .@"usingnamespace", .empty, member_node, - tree.isTokenPrecededByTags(tree.nodeMainToken(member_node), &.{.keyword_pub}), + tree.isTokenPrecededByTags(member_node.mainToken(tree), &.{.keyword_pub}), ); }, }; @@ -5975,7 +5975,7 @@ fn errorSetDecl(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index) InnerError!Zi var idents: std.AutoHashMapUnmanaged(Zir.NullTerminatedString, Ast.TokenIndex) = .empty; defer idents.deinit(gpa); - const lbrace, const rbrace = tree.nodeData(node).token_and_token; + const lbrace, const rbrace = node.data(tree).token_and_token; for (lbrace + 1..rbrace) |i| { const tok_i: Ast.TokenIndex = @intCast(i); switch (tree.tokenTag(tok_i)) { @@ -6103,7 +6103,7 @@ fn orelseCatchExpr( const astgen = parent_gz.astgen; const tree = astgen.tree; - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; const need_rl = astgen.nodes_need_rl.contains(node); const block_ri: ResultInfo = if (need_rl) ri else .{ @@ -6238,7 +6238,7 @@ fn addFieldAccess( const astgen = gz.astgen; const tree = astgen.tree; - const object_node, const field_ident = tree.nodeData(node).node_and_token; + const object_node, const field_ident = node.data(tree).node_and_token; const str_index = try astgen.identAsString(field_ident); const lhs = try expr(gz, scope, lhs_ri, object_node); @@ -6260,7 +6260,7 @@ fn arrayAccess( const tree = gz.astgen.tree; switch (ri.rl) { .ref, .ref_coerced_ty => { - const lhs_node, const rhs_node = tree.nodeData(node).node_and_node; + const lhs_node, const rhs_node = node.data(tree).node_and_node; const lhs = try expr(gz, scope, .{ .rl = .ref }, lhs_node); const cursor = maybeAdvanceSourceCursorToMainToken(gz, node); @@ -6271,7 +6271,7 @@ fn arrayAccess( return gz.addPlNode(.elem_ptr_node, node, Zir.Inst.Bin{ .lhs = lhs, .rhs = rhs }); }, else => { - const lhs_node, const rhs_node = tree.nodeData(node).node_and_node; + const lhs_node, const rhs_node = node.data(tree).node_and_node; const lhs = try expr(gz, scope, .{ .rl = .none }, lhs_node); const cursor = maybeAdvanceSourceCursorToMainToken(gz, node); @@ -6294,12 +6294,12 @@ fn simpleBinOp( const astgen = gz.astgen; const tree = astgen.tree; - const lhs_node, const rhs_node = tree.nodeData(node).node_and_node; + const lhs_node, const rhs_node = node.data(tree).node_and_node; if (op_inst_tag == .cmp_neq or op_inst_tag == .cmp_eq) { const str = if (op_inst_tag == .cmp_eq) "==" else "!="; - if (tree.nodeTag(lhs_node) == .string_literal or - tree.nodeTag(rhs_node) == .string_literal) + if (lhs_node.tag(tree) == .string_literal or + rhs_node.tag(tree) == .string_literal) return astgen.failNode(node, "cannot compare strings with {s}", .{str}); } @@ -6343,7 +6343,7 @@ fn boolBinOp( const astgen = gz.astgen; const tree = astgen.tree; - const lhs_node, const rhs_node = tree.nodeData(node).node_and_node; + const lhs_node, const rhs_node = node.data(tree).node_and_node; const lhs = try expr(gz, scope, coerced_bool_ri, lhs_node); const bool_br = (try gz.addPlNodePayloadIndex(zir_tag, node, undefined)).toIndex().?; @@ -6951,11 +6951,11 @@ fn forExpr( capture_token = ident_tok + 2; try emitDbgNode(parent_gz, input); - if (tree.nodeTag(input) == .for_range) { + if (input.tag(tree) == .for_range) { if (capture_is_ref) { return astgen.failTok(ident_tok, "cannot capture reference to range", .{}); } - const start_node, const end_node = tree.nodeData(input).node_and_opt_node; + const start_node, const end_node = input.data(tree).node_and_opt_node; const start_val = try expr(parent_gz, scope, .{ .rl = .{ .ty = .usize_type } }, start_node); const end_val = if (end_node.unwrap()) |end| @@ -7064,7 +7064,7 @@ fn forExpr( try astgen.detectLocalShadowing(capture_sub_scope, name_str_index, ident_tok, capture_name, .capture); const capture_inst = inst: { - const is_counter = tree.nodeTag(input) == .for_range; + const is_counter = input.tag(tree) == .for_range; if (indexable_ref == .none) { // Special case: the main index can be used directly. @@ -7204,9 +7204,9 @@ fn switchExprErrUnion( const switch_node, const operand_node, const error_payload = switch (node_ty) { .@"catch" => .{ - tree.nodeData(catch_or_if_node).node_and_node[1], - tree.nodeData(catch_or_if_node).node_and_node[0], - tree.nodeMainToken(catch_or_if_node) + 2, + catch_or_if_node.data(tree).node_and_node[1], + catch_or_if_node.data(tree).node_and_node[0], + catch_or_if_node.mainToken(tree) + 2, }, .@"if" => .{ if_full.ast.else_expr.unwrap().?, @@ -7266,8 +7266,8 @@ fn switchExprErrUnion( else_src = case_src; continue; } else if (case.ast.values.len == 1 and - tree.nodeTag(case.ast.values[0]) == .identifier and - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(case.ast.values[0])), "_")) + case.ast.values[0].tag(tree) == .identifier and + mem.eql(u8, tree.tokenSlice(case.ast.values[0].mainToken(tree)), "_")) { const case_src = case.ast.arrow_token - 1; return astgen.failTokNotes( @@ -7285,11 +7285,11 @@ fn switchExprErrUnion( } for (case.ast.values) |val| { - if (tree.nodeTag(val) == .string_literal) + if (val.tag(tree) == .string_literal) return astgen.failNode(val, "cannot switch on strings", .{}); } - if (case.ast.values.len == 1 and tree.nodeTag(case.ast.values[0]) != .switch_range) { + if (case.ast.values.len == 1 and case.ast.values[0].tag(tree) != .switch_range) { scalar_cases_len += 1; } else { multi_cases_len += 1; @@ -7486,7 +7486,7 @@ fn switchExprErrUnion( const case = tree.fullSwitchCase(case_node).?; const is_multi_case = case.ast.values.len > 1 or - (case.ast.values.len == 1 and tree.nodeTag(case.ast.values[0]) == .switch_range); + (case.ast.values.len == 1 and case.ast.values[0].tag(tree) == .switch_range); var dbg_var_name: Zir.NullTerminatedString = .empty; var dbg_var_inst: Zir.Inst.Ref = undefined; @@ -7540,7 +7540,7 @@ fn switchExprErrUnion( // items var items_len: u32 = 0; for (case.ast.values) |item_node| { - if (tree.nodeTag(item_node) == .switch_range) continue; + if (item_node.tag(tree) == .switch_range) continue; items_len += 1; const item_inst = try comptimeExpr(parent_gz, scope, item_ri, item_node, .switch_item); @@ -7550,10 +7550,10 @@ fn switchExprErrUnion( // ranges var ranges_len: u32 = 0; for (case.ast.values) |range| { - if (tree.nodeTag(range) != .switch_range) continue; + if (range.tag(tree) != .switch_range) continue; ranges_len += 1; - const first_node, const last_node = tree.nodeData(range).node_and_node; + const first_node, const last_node = range.data(tree).node_and_node; const first = try comptimeExpr(parent_gz, scope, item_ri, first_node, .switch_item); const last = try comptimeExpr(parent_gz, scope, item_ri, last_node, .switch_item); try payloads.appendSlice(gpa, &[_]u32{ @@ -7788,8 +7788,8 @@ fn switchExpr( else_src = case_src; continue; } else if (case.ast.values.len == 1 and - tree.nodeTag(case.ast.values[0]) == .identifier and - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(case.ast.values[0])), "_")) + case.ast.values[0].tag(tree) == .identifier and + mem.eql(u8, tree.tokenSlice(case.ast.values[0].mainToken(tree)), "_")) { const case_src = case.ast.arrow_token - 1; if (underscore_src) |src| { @@ -7834,11 +7834,11 @@ fn switchExpr( } for (case.ast.values) |val| { - if (tree.nodeTag(val) == .string_literal) + if (val.tag(tree) == .string_literal) return astgen.failNode(val, "cannot switch on strings", .{}); } - if (case.ast.values.len == 1 and tree.nodeTag(case.ast.values[0]) != .switch_range) { + if (case.ast.values.len == 1 and case.ast.values[0].tag(tree) != .switch_range) { scalar_cases_len += 1; } else { multi_cases_len += 1; @@ -7927,7 +7927,7 @@ fn switchExpr( const case = tree.fullSwitchCase(case_node).?; const is_multi_case = case.ast.values.len > 1 or - (case.ast.values.len == 1 and tree.nodeTag(case.ast.values[0]) == .switch_range); + (case.ast.values.len == 1 and case.ast.values[0].tag(tree) == .switch_range); var dbg_var_name: Zir.NullTerminatedString = .empty; var dbg_var_inst: Zir.Inst.Ref = undefined; @@ -8007,7 +8007,7 @@ fn switchExpr( // items var items_len: u32 = 0; for (case.ast.values) |item_node| { - if (tree.nodeTag(item_node) == .switch_range) continue; + if (item_node.tag(tree) == .switch_range) continue; items_len += 1; const item_inst = try comptimeExpr(parent_gz, scope, item_ri, item_node, .switch_item); @@ -8017,10 +8017,10 @@ fn switchExpr( // ranges var ranges_len: u32 = 0; for (case.ast.values) |range| { - if (tree.nodeTag(range) != .switch_range) continue; + if (range.tag(tree) != .switch_range) continue; ranges_len += 1; - const first_node, const last_node = tree.nodeData(range).node_and_node; + const first_node, const last_node = range.data(tree).node_and_node; const first = try comptimeExpr(parent_gz, scope, item_ri, first_node, .switch_item); const last = try comptimeExpr(parent_gz, scope, item_ri, last_node, .switch_item); try payloads.appendSlice(gpa, &[_]u32{ @@ -8170,7 +8170,7 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref const defer_outer = &astgen.fn_block.?.base; - const operand_node = tree.nodeData(node).opt_node.unwrap() orelse { + const operand_node = node.data(tree).opt_node.unwrap() orelse { // Returning a void value; skip error defers. try genDefers(gz, defer_outer, scope, .normal_only); @@ -8181,10 +8181,10 @@ fn ret(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Inst.Ref return Zir.Inst.Ref.unreachable_value; }; - if (tree.nodeTag(operand_node) == .error_value) { + if (operand_node.tag(tree) == .error_value) { // Hot path for `return error.Foo`. This bypasses result location logic as well as logic // for detecting whether to add something to the function's inferred error set. - const ident_token = tree.nodeMainToken(operand_node) + 2; + const ident_token = operand_node.mainToken(tree) + 2; const err_name_str_index = try astgen.identAsString(ident_token); const defer_counts = countDefers(defer_outer, scope); if (!defer_counts.need_err_code) { @@ -8316,7 +8316,7 @@ fn identifier( const astgen = gz.astgen; const tree = astgen.tree; - const ident_token = tree.nodeMainToken(ident); + const ident_token = ident.mainToken(tree); const ident_name_raw = tree.tokenSlice(ident_token); if (mem.eql(u8, ident_name_raw, "_")) { return astgen.failNode(ident, "'_' used as an identifier without @\"_\" syntax", .{}); @@ -8657,7 +8657,7 @@ fn stringLiteral( ) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; const tree = astgen.tree; - const str_lit_token = tree.nodeMainToken(node); + const str_lit_token = node.mainToken(tree); const str = try astgen.strLitAsString(str_lit_token); const result = try gz.add(.{ .tag = .str, @@ -8689,7 +8689,7 @@ fn multilineStringLiteral( fn charLiteral(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; const tree = astgen.tree; - const main_token = tree.nodeMainToken(node); + const main_token = node.mainToken(tree); const slice = tree.tokenSlice(main_token); switch (std.zig.parseCharLiteral(slice)) { @@ -8706,7 +8706,7 @@ const Sign = enum { negative, positive }; fn numberLiteral(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index, source_node: Ast.Node.Index, sign: Sign) InnerError!Zir.Inst.Ref { const astgen = gz.astgen; const tree = astgen.tree; - const num_token = tree.nodeMainToken(node); + const num_token = node.mainToken(tree); const bytes = tree.tokenSlice(num_token); const result: Zir.Inst.Ref = switch (std.zig.parseNumberLiteral(bytes)) { @@ -8826,10 +8826,10 @@ fn asmExpr( const tree = astgen.tree; const TagAndTmpl = struct { tag: Zir.Inst.Extended, tmpl: Zir.NullTerminatedString }; - const tag_and_tmpl: TagAndTmpl = switch (tree.nodeTag(full.ast.template)) { + const tag_and_tmpl: TagAndTmpl = switch (full.ast.template.tag(tree)) { .string_literal => .{ .tag = .@"asm", - .tmpl = (try astgen.strLitAsString(tree.nodeMainToken(full.ast.template))).index, + .tmpl = (try astgen.strLitAsString(full.ast.template.mainToken(tree))).index, }, .multiline_string_literal => .{ .tag = .@"asm", @@ -8864,7 +8864,7 @@ fn asmExpr( var output_type_bits: u32 = 0; for (full.outputs, 0..) |output_node, i| { - const symbolic_name = tree.nodeMainToken(output_node); + const symbolic_name = output_node.mainToken(tree); const name = try astgen.identAsString(symbolic_name); const constraint_token = symbolic_name + 2; const constraint = (try astgen.strLitAsString(constraint_token)).index; @@ -8874,7 +8874,7 @@ fn asmExpr( return astgen.failNode(output_node, "inline assembly allows up to one output value", .{}); } output_type_bits |= @as(u32, 1) << @intCast(i); - const out_type_node = tree.nodeData(output_node).opt_node_and_token[0].unwrap().?; + const out_type_node = output_node.data(tree).opt_node_and_token[0].unwrap().?; const out_type_inst = try typeExpr(gz, scope, out_type_node); outputs[i] = .{ .name = name, @@ -8901,11 +8901,11 @@ fn asmExpr( const inputs = inputs_buffer[0..full.inputs.len]; for (full.inputs, 0..) |input_node, i| { - const symbolic_name = tree.nodeMainToken(input_node); + const symbolic_name = input_node.mainToken(tree); const name = try astgen.identAsString(symbolic_name); const constraint_token = symbolic_name + 2; const constraint = (try astgen.strLitAsString(constraint_token)).index; - const operand = try expr(gz, scope, .{ .rl = .none }, tree.nodeData(input_node).node_and_token[0]); + const operand = try expr(gz, scope, .{ .rl = .none }, input_node.data(tree).node_and_token[0]); inputs[i] = .{ .name = name, .constraint = constraint, @@ -9029,11 +9029,11 @@ fn ptrCast( // to handle `builtin_call_two`. var node = root_node; while (true) { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .builtin_call_two, .builtin_call_two_comma => {}, .grouped_expression => { // Handle the chaining even with redundant parentheses - node = tree.nodeData(node).node_and_token[0]; + node = node.data(tree).node_and_token[0]; continue; }, else => break, @@ -9045,7 +9045,7 @@ fn ptrCast( if (args.len == 0) break; // 0 args - const builtin_token = tree.nodeMainToken(node); + const builtin_token = node.mainToken(tree); const builtin_name = tree.tokenSlice(builtin_token); const info = BuiltinFn.list.get(builtin_name) orelse break; if (args.len == 1) { @@ -9246,7 +9246,7 @@ fn builtinCall( const astgen = gz.astgen; const tree = astgen.tree; - const builtin_token = tree.nodeMainToken(node); + const builtin_token = node.mainToken(tree); const builtin_name = tree.tokenSlice(builtin_token); // We handle the different builtins manually because they have different semantics depending @@ -9289,11 +9289,11 @@ fn builtinCall( .import => { const operand_node = params[0]; - if (tree.nodeTag(operand_node) != .string_literal) { + if (operand_node.tag(tree) != .string_literal) { // Spec reference: https://github.com/ziglang/zig/issues/2206 return astgen.failNode(operand_node, "@import operand must be a string literal", .{}); } - const str_lit_token = tree.nodeMainToken(operand_node); + const str_lit_token = operand_node.mainToken(tree); const str = try astgen.strLitAsString(str_lit_token); const str_slice = astgen.string_bytes.items[@intFromEnum(str.index)..][0..str.len]; if (mem.indexOfScalar(u8, str_slice, 0) != null) { @@ -9919,8 +9919,8 @@ fn negation( // Check for float literal as the sub-expression because we want to preserve // its negativity rather than having it go through comptime subtraction. - const operand_node = tree.nodeData(node).node; - if (tree.nodeTag(operand_node) == .number_literal) { + const operand_node = node.data(tree).node; + if (operand_node.tag(tree) == .number_literal) { return numberLiteral(gz, ri, operand_node, node, .negative); } @@ -10034,9 +10034,10 @@ fn shiftOp( rhs_node: Ast.Node.Index, tag: Zir.Inst.Tag, ) InnerError!Zir.Inst.Ref { + const tree = gz.astgen.tree; const lhs = try expr(gz, scope, .{ .rl = .none }, lhs_node); - const cursor = switch (gz.astgen.tree.nodeTag(node)) { + const cursor = switch (node.tag(tree)) { .shl, .shr => maybeAdvanceSourceCursorToMainToken(gz, node), else => undefined, }; @@ -10044,7 +10045,7 @@ fn shiftOp( const log2_int_type = try gz.addUnNode(.typeof_log2_int_type, lhs, lhs_node); const rhs = try expr(gz, scope, .{ .rl = .{ .ty = log2_int_type }, .ctx = .shift_op }, rhs_node); - switch (gz.astgen.tree.nodeTag(node)) { + switch (node.tag(tree)) { .shl, .shr => try emitDbgStmt(gz, cursor), else => undefined, } @@ -10248,10 +10249,10 @@ fn calleeExpr( const astgen = gz.astgen; const tree = astgen.tree; - const tag = tree.nodeTag(node); + const tag = node.tag(tree); switch (tag) { .field_access => { - const object_node, const field_ident = tree.nodeData(node).node_and_token; + const object_node, const field_ident = node.data(tree).node_and_token; const str_index = try astgen.identAsString(field_ident); // Capture the object by reference so we can promote it to an // address in Sema if needed. @@ -10276,7 +10277,7 @@ fn calleeExpr( // Decl literal call syntax, e.g. // `const foo: T = .init();` // Look up `init` in `T`, but don't try and coerce it. - const str_index = try astgen.identAsString(tree.nodeMainToken(node)); + const str_index = try astgen.identAsString(node.mainToken(tree)); const callee = try gz.addPlNode(.decl_literal_no_coerce, node, Zir.Inst.Field{ .lhs = res_ty, .field_name_start = str_index, @@ -10348,9 +10349,9 @@ comptime { } fn nodeIsTriviallyZero(tree: *const Ast, node: Ast.Node.Index) bool { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .number_literal => { - const ident = tree.nodeMainToken(node); + const ident = node.mainToken(tree); return switch (std.zig.parseNumberLiteral(tree.tokenSlice(ident))) { .int => |number| switch (number) { 0 => true, @@ -10366,7 +10367,7 @@ fn nodeIsTriviallyZero(tree: *const Ast, node: Ast.Node.Index) bool { fn nodeMayAppendToErrorTrace(tree: *const Ast, start_node: Ast.Node.Index) bool { var node = start_node; while (true) { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { // These don't have the opportunity to call any runtime functions. .error_value, .identifier, @@ -10376,10 +10377,10 @@ fn nodeMayAppendToErrorTrace(tree: *const Ast, start_node: Ast.Node.Index) bool // Forward the question to the LHS sub-expression. .@"try", .@"nosuspend", - => node = tree.nodeData(node).node, + => node = node.data(tree).node, .grouped_expression, .unwrap_optional, - => node = tree.nodeData(node).node_and_token[0], + => node = node.data(tree).node_and_token[0], // Anything that does not eval to an error is guaranteed to pop any // additions to the error trace, so it effectively does not append. @@ -10391,7 +10392,7 @@ fn nodeMayAppendToErrorTrace(tree: *const Ast, start_node: Ast.Node.Index) bool fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) BuiltinFn.EvalToError { var node = start_node; while (true) { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .root, .@"usingnamespace", .test_decl, @@ -10558,10 +10559,10 @@ fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) BuiltinFn.Ev .@"await", .@"comptime", .@"nosuspend", - => node = tree.nodeData(node).node, + => node = node.data(tree).node, .grouped_expression, .unwrap_optional, - => node = tree.nodeData(node).node_and_token[0], + => node = node.data(tree).node_and_token[0], // LHS sub-expression may still be an error under the outer optional or error union .@"catch", @@ -10573,7 +10574,7 @@ fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) BuiltinFn.Ev .block, .block_semicolon, => { - const lbrace = tree.nodeMainToken(node); + const lbrace = node.mainToken(tree); if (tree.tokenTag(lbrace - 1) == .colon) { // Labeled blocks may need a memory location to forward // to their break statements. @@ -10588,7 +10589,7 @@ fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) BuiltinFn.Ev .builtin_call_two, .builtin_call_two_comma, => { - const builtin_token = tree.nodeMainToken(node); + const builtin_token = node.mainToken(tree); const builtin_name = tree.tokenSlice(builtin_token); // If the builtin is an invalid name, we don't cause an error here; instead // let it pass, and the error will be "invalid builtin function" later. @@ -10604,7 +10605,7 @@ fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) BuiltinFn.Ev fn nodeImpliesMoreThanOnePossibleValue(tree: *const Ast, start_node: Ast.Node.Index) bool { var node = start_node; while (true) { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .root, .@"usingnamespace", .test_decl, @@ -10771,10 +10772,10 @@ fn nodeImpliesMoreThanOnePossibleValue(tree: *const Ast, start_node: Ast.Node.In .@"await", .@"comptime", .@"nosuspend", - => node = tree.nodeData(node).node, + => node = node.data(tree).node, .grouped_expression, .unwrap_optional, - => node = tree.nodeData(node).node_and_token[0], + => node = node.data(tree).node_and_token[0], .ptr_type_aligned, .ptr_type_sentinel, @@ -10786,7 +10787,7 @@ fn nodeImpliesMoreThanOnePossibleValue(tree: *const Ast, start_node: Ast.Node.In => return true, .identifier => { - const ident_bytes = tree.tokenSlice(tree.nodeMainToken(node)); + const ident_bytes = tree.tokenSlice(node.mainToken(tree)); if (primitive_instrs.get(ident_bytes)) |primitive| switch (primitive) { .anyerror_type, .anyframe_type, @@ -10848,7 +10849,7 @@ fn nodeImpliesMoreThanOnePossibleValue(tree: *const Ast, start_node: Ast.Node.In fn nodeImpliesComptimeOnly(tree: *const Ast, start_node: Ast.Node.Index) bool { var node = start_node; while (true) { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .root, .@"usingnamespace", .test_decl, @@ -11024,13 +11025,13 @@ fn nodeImpliesComptimeOnly(tree: *const Ast, start_node: Ast.Node.Index) bool { .@"await", .@"comptime", .@"nosuspend", - => node = tree.nodeData(node).node, + => node = node.data(tree).node, .grouped_expression, .unwrap_optional, - => node = tree.nodeData(node).node_and_token[0], + => node = node.data(tree).node_and_token[0], .identifier => { - const ident_bytes = tree.tokenSlice(tree.nodeMainToken(node)); + const ident_bytes = tree.tokenSlice(node.mainToken(tree)); if (primitive_instrs.get(ident_bytes)) |primitive| switch (primitive) { .anyerror_type, .anyframe_type, @@ -11089,7 +11090,7 @@ fn nodeImpliesComptimeOnly(tree: *const Ast, start_node: Ast.Node.Index) bool { /// Returns `true` if the node uses `gz.anon_name_strategy`. fn nodeUsesAnonNameStrategy(tree: *const Ast, node: Ast.Node.Index) bool { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .container_decl, .container_decl_trailing, .container_decl_two, @@ -11104,7 +11105,7 @@ fn nodeUsesAnonNameStrategy(tree: *const Ast, node: Ast.Node.Index) bool { .tagged_union_enum_tag_trailing, => return true, .builtin_call_two, .builtin_call_two_comma, .builtin_call, .builtin_call_comma => { - const builtin_token = tree.nodeMainToken(node); + const builtin_token = node.mainToken(tree); const builtin_name = tree.tokenSlice(builtin_token); return std.mem.eql(u8, builtin_name, "@Type"); }, @@ -11660,7 +11661,7 @@ fn strLitAsString(astgen: *AstGen, str_lit_token: Ast.TokenIndex) !IndexSlice { fn strLitNodeAsString(astgen: *AstGen, node: Ast.Node.Index) !IndexSlice { const tree = astgen.tree; - const start, const end = tree.nodeData(node).token_and_token; + const start, const end = node.data(tree).token_and_token; const gpa = astgen.gpa; const string_bytes = &astgen.string_bytes; @@ -12155,9 +12156,9 @@ const GenZir = struct { const src_locs_and_hash: []const u32 = if (args.body_gz != null) src_locs_and_hash: { const tree = astgen.tree; const fn_decl = args.src_node; - const block = switch (tree.nodeTag(fn_decl)) { - .fn_decl => tree.nodeData(fn_decl).node_and_node[1], - .test_decl => tree.nodeData(fn_decl).opt_token_and_node[1], + const block = switch (fn_decl.tag(tree)) { + .fn_decl => fn_decl.data(tree).node_and_node[1], + .test_decl => fn_decl.data(tree).opt_token_and_node[1], else => unreachable, }; const rbrace_start = tree.tokenStart(tree.lastToken(block)); @@ -13399,7 +13400,7 @@ fn maybeAdvanceSourceCursorToMainToken(gz: *GenZir, node: Ast.Node.Index) LineCo if (gz.is_comptime) return .{ gz.astgen.source_line - gz.decl_line, gz.astgen.source_column }; const tree = gz.astgen.tree; - const node_start = tree.tokenStart(tree.nodeMainToken(node)); + const node_start = tree.tokenStart(node.mainToken(tree)); gz.astgen.advanceSourceCursor(node_start); return .{ gz.astgen.source_line - gz.decl_line, gz.astgen.source_column }; @@ -13492,7 +13493,7 @@ fn scanContainer( var decl_count: u32 = 0; for (members) |member_node| { const Kind = enum { decl, field }; - const kind: Kind, const name_token = switch (tree.nodeTag(member_node)) { + const kind: Kind, const name_token = switch (member_node.tag(tree)) { .container_field_init, .container_field_align, .container_field, @@ -13512,7 +13513,7 @@ fn scanContainer( .aligned_var_decl, => blk: { decl_count += 1; - break :blk .{ .decl, tree.nodeMainToken(member_node) + 1 }; + break :blk .{ .decl, member_node.mainToken(tree) + 1 }; }, .fn_proto_simple, @@ -13522,7 +13523,7 @@ fn scanContainer( .fn_decl, => blk: { decl_count += 1; - const ident = tree.nodeMainToken(member_node) + 1; + const ident = member_node.mainToken(tree) + 1; if (tree.tokenTag(ident) != .identifier) { try astgen.appendErrorNode(member_node, "missing function name", .{}); any_invalid_declarations = true; @@ -13540,7 +13541,7 @@ fn scanContainer( decl_count += 1; // We don't want shadowing detection here, and test names work a bit differently, so // we must do the redeclaration detection ourselves. - const test_name_token = tree.nodeMainToken(member_node) + 1; + const test_name_token = member_node.mainToken(tree) + 1; const new_ent: NameEntry = .{ .tok = test_name_token, .next = null, diff --git a/lib/std/zig/AstRlAnnotate.zig b/lib/std/zig/AstRlAnnotate.zig index 628574349b..91e1e3792e 100644 --- a/lib/std/zig/AstRlAnnotate.zig +++ b/lib/std/zig/AstRlAnnotate.zig @@ -61,11 +61,11 @@ const Block = struct { consumes_res_ptr: bool, }; -pub fn annotate(gpa: Allocator, arena: Allocator, tree: Ast) Allocator.Error!RlNeededSet { +pub fn annotate(gpa: Allocator, arena: Allocator, tree: *const Ast) Allocator.Error!RlNeededSet { var astrl: AstRlAnnotate = .{ .gpa = gpa, .arena = arena, - .tree = &tree, + .tree = tree, }; defer astrl.deinit(gpa); @@ -129,7 +129,7 @@ fn containerDecl( /// Returns true if `rl` provides a result pointer and the expression consumes it. fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultInfo) Allocator.Error!bool { const tree = astrl.tree; - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .root, .switch_case_one, .switch_case_inline_one, @@ -142,11 +142,11 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI => unreachable, .@"errdefer" => { - _ = try astrl.expr(tree.nodeData(node).opt_token_and_node[1], block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).opt_token_and_node[1], block, ResultInfo.none); return false; }, .@"defer" => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.none); return false; }, @@ -166,11 +166,11 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI return false; }, .@"usingnamespace" => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.type_only); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.type_only); return false; }, .test_decl => { - _ = try astrl.expr(tree.nodeData(node).opt_token_and_node[1], block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).opt_token_and_node[1], block, ResultInfo.none); return false; }, .global_var_decl, @@ -214,7 +214,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI return false; }, .assign => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.typed_ptr); return false; @@ -237,13 +237,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI .assign_mul_wrap, .assign_mul_sat, => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.none); return false; }, .shl, .shr => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.type_only); return false; @@ -271,20 +271,20 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI .less_or_equal, .array_cat, => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.none); return false; }, .array_mult => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.type_only); return false; }, .error_union, .merge_error_sets => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.none); return false; @@ -292,17 +292,17 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI .bool_and, .bool_or, => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.type_only); _ = try astrl.expr(rhs, block, ResultInfo.type_only); return false; }, .bool_not => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.type_only); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.type_only); return false; }, .bit_not, .negation, .negation_wrap => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.none); return false; }, @@ -347,7 +347,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI for (full.ast.params) |param_node| { _ = try astrl.expr(param_node, block, ResultInfo.type_only); } - return switch (tree.nodeTag(node)) { + return switch (node.tag(tree)) { .call_one, .call_one_comma, .call, @@ -363,7 +363,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI }, .@"return" => { - if (tree.nodeData(node).opt_node.unwrap()) |lhs| { + if (node.data(tree).opt_node.unwrap()) |lhs| { const ret_val_consumes_rl = try astrl.expr(lhs, block, ResultInfo.typed_ptr); if (ret_val_consumes_rl) { try astrl.nodes_need_rl.putNoClobber(astrl.gpa, node, {}); @@ -373,7 +373,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI }, .field_access => { - const lhs, _ = tree.nodeData(node).node_and_token; + const lhs, _ = node.data(tree).node_and_token; _ = try astrl.expr(lhs, block, ResultInfo.none); return false; }, @@ -436,8 +436,8 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI break :label try astrl.identString(label_token); } else null; for (full.ast.inputs) |input| { - if (tree.nodeTag(input) == .for_range) { - const lhs, const opt_rhs = tree.nodeData(input).node_and_opt_node; + if (input.tag(tree) == .for_range) { + const lhs, const opt_rhs = input.data(tree).node_and_opt_node; _ = try astrl.expr(lhs, block, ResultInfo.type_only); if (opt_rhs.unwrap()) |rhs| { _ = try astrl.expr(rhs, block, ResultInfo.type_only); @@ -466,13 +466,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI }, .slice_open => { - const sliced, const start = tree.nodeData(node).node_and_node; + const sliced, const start = node.data(tree).node_and_node; _ = try astrl.expr(sliced, block, ResultInfo.none); _ = try astrl.expr(start, block, ResultInfo.type_only); return false; }, .slice => { - const sliced, const extra_index = tree.nodeData(node).node_and_extra; + const sliced, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Ast.Node.Slice); _ = try astrl.expr(sliced, block, ResultInfo.none); _ = try astrl.expr(extra.start, block, ResultInfo.type_only); @@ -480,7 +480,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI return false; }, .slice_sentinel => { - const sliced, const extra_index = tree.nodeData(node).node_and_extra; + const sliced, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Ast.Node.SliceSentinel); _ = try astrl.expr(sliced, block, ResultInfo.none); _ = try astrl.expr(extra.start, block, ResultInfo.type_only); @@ -491,24 +491,24 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI return false; }, .deref => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.none); return false; }, .address_of => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.none); return false; }, .optional_type => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.type_only); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.type_only); return false; }, .@"try", .@"await", .@"nosuspend", - => return astrl.expr(tree.nodeData(node).node, block, ri), + => return astrl.expr(node.data(tree).node, block, ri), .grouped_expression, .unwrap_optional, - => return astrl.expr(tree.nodeData(node).node_and_token[0], block, ri), + => return astrl.expr(node.data(tree).node_and_token[0], block, ri), .block_two, .block_two_semicolon, @@ -520,12 +520,12 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI return astrl.blockExpr(block, ri, node, statements); }, .anyframe_type => { - _, const child_type = tree.nodeData(node).token_and_node; + _, const child_type = node.data(tree).token_and_node; _ = try astrl.expr(child_type, block, ResultInfo.type_only); return false; }, .@"catch", .@"orelse" => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); const rhs_consumes_rl = try astrl.expr(rhs, block, ri); if (rhs_consumes_rl) { @@ -577,7 +577,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI }, .@"break" => { - const opt_label, const opt_rhs = tree.nodeData(node).opt_token_and_opt_node; + const opt_label, const opt_rhs = node.data(tree).opt_token_and_opt_node; const rhs = opt_rhs.unwrap() orelse { // Breaks with void are not interesting return false; @@ -609,13 +609,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI }, .array_type => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.type_only); _ = try astrl.expr(rhs, block, ResultInfo.type_only); return false; }, .array_type_sentinel => { - const len_expr, const extra_index = tree.nodeData(node).node_and_extra; + const len_expr, const extra_index = node.data(tree).node_and_extra; const extra = tree.extraData(extra_index, Ast.Node.ArrayTypeSentinel); _ = try astrl.expr(len_expr, block, ResultInfo.type_only); _ = try astrl.expr(extra.elem_type, block, ResultInfo.type_only); @@ -623,7 +623,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI return false; }, .array_access => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.type_only); return false; @@ -631,11 +631,11 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI .@"comptime" => { // AstGen will emit an error if the scope is already comptime, so we can assume it is // not. This means the result location is not forwarded. - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.none); return false; }, .@"switch", .switch_comma => { - const operand_node, const extra_index = tree.nodeData(node).node_and_extra; + const operand_node, const extra_index = node.data(tree).node_and_extra; const case_nodes = tree.extraDataSlice(tree.extraData(extra_index, Ast.Node.SubRange), Ast.Node.Index); _ = try astrl.expr(operand_node, block, ResultInfo.none); @@ -644,8 +644,8 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI for (case_nodes) |case_node| { const case = tree.fullSwitchCase(case_node).?; for (case.ast.values) |item_node| { - if (tree.nodeTag(item_node) == .switch_range) { - const lhs, const rhs = tree.nodeData(item_node).node_and_node; + if (item_node.tag(tree) == .switch_range) { + const lhs, const rhs = item_node.data(tree).node_and_node; _ = try astrl.expr(lhs, block, ResultInfo.none); _ = try astrl.expr(rhs, block, ResultInfo.none); } else { @@ -662,11 +662,11 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI return any_prong_consumed_rl; }, .@"suspend" => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.none); return false; }, .@"resume" => { - _ = try astrl.expr(tree.nodeData(node).node, block, ResultInfo.none); + _ = try astrl.expr(node.data(tree).node, block, ResultInfo.none); return false; }, @@ -752,7 +752,7 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI => |tag| { var buf: [1]Ast.Node.Index = undefined; const full = tree.fullFnProto(&buf, node).?; - const body_node = if (tag == .fn_decl) tree.nodeData(node).node_and_node[1].toOptional() else .none; + const body_node = if (tag == .fn_decl) node.data(tree).node_and_node[1].toOptional() else .none; { var it = full.iterate(tree); while (it.next()) |param| { @@ -800,7 +800,7 @@ fn identString(astrl: *AstRlAnnotate, token: Ast.TokenIndex) ![]const u8 { fn blockExpr(astrl: *AstRlAnnotate, parent_block: ?*Block, ri: ResultInfo, node: Ast.Node.Index, statements: []const Ast.Node.Index) !bool { const tree = astrl.tree; - const lbrace = tree.nodeMainToken(node); + const lbrace = node.mainToken(tree); if (tree.isTokenPrecededByTags(lbrace, &.{ .identifier, .colon })) { // Labeled block var new_block: Block = .{ @@ -830,7 +830,7 @@ fn builtinCall(astrl: *AstRlAnnotate, block: ?*Block, ri: ResultInfo, node: Ast. _ = ri; // Currently, no builtin consumes its result location. const tree = astrl.tree; - const builtin_token = tree.nodeMainToken(node); + const builtin_token = node.mainToken(tree); const builtin_name = tree.tokenSlice(builtin_token); const info = BuiltinFn.list.get(builtin_name) orelse return false; if (info.param_count) |expected| { diff --git a/lib/std/zig/ZonGen.zig b/lib/std/zig/ZonGen.zig index 2114260e84..06349a3da7 100644 --- a/lib/std/zig/ZonGen.zig +++ b/lib/std/zig/ZonGen.zig @@ -1,7 +1,7 @@ //! Ingests an `Ast` and produces a `Zoir`. gpa: Allocator, -tree: Ast, +tree: *const Ast, options: Options, @@ -22,7 +22,7 @@ pub const Options = struct { parse_str_lits: bool = true, }; -pub fn generate(gpa: Allocator, tree: Ast, options: Options) Allocator.Error!Zoir { +pub fn generate(gpa: Allocator, tree: *const Ast, options: Options) Allocator.Error!Zoir { assert(tree.mode == .zon); var zg: ZonGen = .{ @@ -98,7 +98,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator const gpa = zg.gpa; const tree = zg.tree; - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .root => unreachable, .@"usingnamespace" => unreachable, .test_decl => unreachable, @@ -170,7 +170,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator .bool_not, .bit_not, .negation_wrap, - => try zg.addErrorTok(tree.nodeMainToken(node), "operator '{s}' is not allowed in ZON", .{tree.tokenSlice(tree.nodeMainToken(node))}), + => try zg.addErrorTok(node.mainToken(tree), "operator '{s}' is not allowed in ZON", .{tree.tokenSlice(node.mainToken(tree))}), .error_union, .merge_error_sets, @@ -248,8 +248,8 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator .slice_sentinel, => try zg.addErrorNode(node, "slice operator is not allowed in ZON", .{}), - .deref, .address_of => try zg.addErrorTok(tree.nodeMainToken(node), "pointers are not available in ZON", .{}), - .unwrap_optional => try zg.addErrorTok(tree.nodeMainToken(node), "optionals are not available in ZON", .{}), + .deref, .address_of => try zg.addErrorTok(node.mainToken(tree), "pointers are not available in ZON", .{}), + .unwrap_optional => try zg.addErrorTok(node.mainToken(tree), "optionals are not available in ZON", .{}), .error_value => try zg.addErrorNode(node, "errors are not available in ZON", .{}), .array_access => try zg.addErrorNode(node, "array indexing is not allowed in ZON", .{}), @@ -294,18 +294,18 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator }, .grouped_expression => { - try zg.addErrorTokNotes(tree.nodeMainToken(node), "expression grouping is not allowed in ZON", .{}, &.{ - try zg.errNoteTok(tree.nodeMainToken(node), "these parentheses are always redundant", .{}), + try zg.addErrorTokNotes(node.mainToken(tree), "expression grouping is not allowed in ZON", .{}, &.{ + try zg.errNoteTok(node.mainToken(tree), "these parentheses are always redundant", .{}), }); - return zg.expr(tree.nodeData(node).node_and_token[0], dest_node); + return zg.expr(node.data(tree).node_and_token[0], dest_node); }, .negation => { - const child_node = tree.nodeData(node).node; - switch (tree.nodeTag(child_node)) { + const child_node = node.data(tree).node; + switch (child_node.tag(tree)) { .number_literal => return zg.numberLiteral(child_node, node, dest_node, .negative), .identifier => { - const child_ident = tree.tokenSlice(tree.nodeMainToken(child_node)); + const child_ident = tree.tokenSlice(child_node.mainToken(tree)); if (mem.eql(u8, child_ident, "inf")) { zg.setNode(dest_node, .{ .tag = .neg_inf, @@ -317,7 +317,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator }, else => {}, } - try zg.addErrorTok(tree.nodeMainToken(node), "expected number or 'inf' after '-'", .{}); + try zg.addErrorTok(node.mainToken(tree), "expected number or 'inf' after '-'", .{}); }, .number_literal => try zg.numberLiteral(node, node, dest_node, .positive), .char_literal => try zg.charLiteral(node, dest_node), @@ -325,7 +325,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator .identifier => try zg.identifier(node, dest_node), .enum_literal => { - const str_index = zg.identAsString(tree.nodeMainToken(node)) catch |err| switch (err) { + const str_index = zg.identAsString(node.mainToken(tree)) catch |err| switch (err) { error.BadString => undefined, // doesn't matter, there's an error error.OutOfMemory => |e| return e, }; @@ -486,17 +486,17 @@ fn appendIdentStr(zg: *ZonGen, ident_token: Ast.TokenIndex) !u32 { } /// Estimates the size of a string node without parsing it. -pub fn strLitSizeHint(tree: Ast, node: Ast.Node.Index) usize { - switch (tree.nodeTag(node)) { +pub fn strLitSizeHint(tree: *const Ast, node: Ast.Node.Index) usize { + switch (node.tag(tree)) { // Parsed string literals are typically around the size of the raw strings. .string_literal => { - const token = tree.nodeMainToken(node); + const token = node.mainToken(tree); const raw_string = tree.tokenSlice(token); return raw_string.len; }, // Multiline string literal lengths can be computed exactly. .multiline_string_literal => { - const first_tok, const last_tok = tree.nodeData(node).token_and_token; + const first_tok, const last_tok = node.data(tree).token_and_token; var size = tree.tokenSlice(first_tok)[2..].len; for (first_tok + 1..last_tok + 1) |tok_idx| { @@ -511,18 +511,18 @@ pub fn strLitSizeHint(tree: Ast, node: Ast.Node.Index) usize { /// Parses the given node as a string literal. pub fn parseStrLit( - tree: Ast, + tree: *const Ast, node: Ast.Node.Index, writer: anytype, ) error{OutOfMemory}!std.zig.string_literal.Result { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .string_literal => { - const token = tree.nodeMainToken(node); + const token = node.mainToken(tree); const raw_string = tree.tokenSlice(token); return std.zig.string_literal.parseWrite(writer, raw_string); }, .multiline_string_literal => { - const first_tok, const last_tok = tree.nodeData(node).token_and_token; + const first_tok, const last_tok = node.data(tree).token_and_token; // First line: do not append a newline. { @@ -560,7 +560,7 @@ fn strLitAsString(zg: *ZonGen, str_node: Ast.Node.Index) !StringLiteralResult { switch (try parseStrLit(zg.tree, str_node, zg.string_bytes.writer(zg.gpa))) { .success => {}, .failure => |err| { - const token = zg.tree.nodeMainToken(str_node); + const token = str_node.mainToken(zg.tree); const raw_string = zg.tree.tokenSlice(token); try zg.lowerStrLitError(err, token, raw_string, 0); return error.BadString; @@ -608,7 +608,7 @@ fn identAsString(zg: *ZonGen, ident_token: Ast.TokenIndex) !Zoir.NullTerminatedS fn numberLiteral(zg: *ZonGen, num_node: Ast.Node.Index, src_node: Ast.Node.Index, dest_node: Zoir.Node.Index, sign: enum { negative, positive }) !void { const tree = zg.tree; - const num_token = tree.nodeMainToken(num_node); + const num_token = num_node.mainToken(tree); const num_bytes = tree.tokenSlice(num_token); switch (std.zig.parseNumberLiteral(num_bytes)) { @@ -712,8 +712,8 @@ fn setBigIntLiteralNode(zg: *ZonGen, dest_node: Zoir.Node.Index, src_node: Ast.N fn charLiteral(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) !void { const tree = zg.tree; - assert(tree.nodeTag(node) == .char_literal); - const main_token = tree.nodeMainToken(node); + assert(node.tag(tree) == .char_literal); + const main_token = node.mainToken(tree); const slice = tree.tokenSlice(main_token); switch (std.zig.parseCharLiteral(slice)) { .success => |codepoint| zg.setNode(dest_node, .{ @@ -727,8 +727,8 @@ fn charLiteral(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) !v fn identifier(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) !void { const tree = zg.tree; - assert(tree.nodeTag(node) == .identifier); - const main_token = tree.nodeMainToken(node); + assert(node.tag(tree) == .identifier); + const main_token = node.mainToken(tree); const ident = tree.tokenSlice(main_token); const tag: Zoir.Node.Repr.Tag = t: { diff --git a/lib/std/zig/render.zig b/lib/std/zig/render.zig index 994c6aa2cd..ff1aab34fc 100644 --- a/lib/std/zig/render.zig +++ b/lib/std/zig/render.zig @@ -75,11 +75,11 @@ pub const Fixups = struct { const Render = struct { gpa: Allocator, ais: *Ais, - tree: Ast, + tree: *const Ast, fixups: Fixups, }; -pub fn renderTree(buffer: *std.ArrayList(u8), tree: Ast, fixups: Fixups) Error!void { +pub fn renderTree(buffer: *std.ArrayList(u8), tree: *const Ast, fixups: Fixups) Error!void { assert(tree.errors.len == 0); // Cannot render an invalid tree. var auto_indenting_stream = Ais.init(buffer, indent_delta); defer auto_indenting_stream.deinit(); @@ -144,13 +144,13 @@ fn renderMember( const ais = r.ais; if (r.fixups.omit_nodes.contains(decl)) return; try renderDocComments(r, tree.firstToken(decl)); - switch (tree.nodeTag(decl)) { + switch (decl.tag(tree)) { .fn_decl => { // Some examples: // pub extern "foo" fn ... // export fn ... - const fn_proto, const body_node = tree.nodeData(decl).node_and_node; - const fn_token = tree.nodeMainToken(fn_proto); + const fn_proto, const body_node = decl.data(tree).node_and_node; + const fn_token = fn_proto.mainToken(tree); // Go back to the first token we should render here. var i = fn_token; while (i > 0) { @@ -174,18 +174,18 @@ fn renderMember( while (i < fn_token) : (i += 1) { try renderToken(r, i, .space); } - switch (tree.nodeTag(fn_proto)) { + switch (fn_proto.tag(tree)) { .fn_proto_one, .fn_proto => { var buf: [1]Ast.Node.Index = undefined; - const opt_callconv_expr = if (tree.nodeTag(fn_proto) == .fn_proto_one) + const opt_callconv_expr = if (fn_proto.tag(tree) == .fn_proto_one) tree.fnProtoOne(&buf, fn_proto).ast.callconv_expr else tree.fnProto(fn_proto).ast.callconv_expr; // Keep in sync with logic in `renderFnProto`. Search this file for the marker PROMOTE_CALLCONV_INLINE if (opt_callconv_expr.unwrap()) |callconv_expr| { - if (tree.nodeTag(callconv_expr) == .enum_literal) { - if (mem.eql(u8, "@\"inline\"", tree.tokenSlice(tree.nodeMainToken(callconv_expr)))) { + if (callconv_expr.tag(tree) == .enum_literal) { + if (mem.eql(u8, "@\"inline\"", tree.tokenSlice(callconv_expr.mainToken(tree)))) { try ais.writer().writeAll("inline "); } } @@ -197,7 +197,7 @@ fn renderMember( try renderExpression(r, fn_proto, .space); if (r.fixups.gut_functions.contains(decl)) { try ais.pushIndent(.normal); - const lbrace = tree.nodeMainToken(body_node); + const lbrace = body_node.mainToken(tree); try renderToken(r, lbrace, .newline); try discardAllParams(r, fn_proto); try ais.writer().writeAll("@trap();"); @@ -206,12 +206,12 @@ fn renderMember( try renderToken(r, tree.lastToken(body_node), space); // rbrace } else if (r.fixups.unused_var_decls.count() != 0) { try ais.pushIndent(.normal); - const lbrace = tree.nodeMainToken(body_node); + const lbrace = body_node.mainToken(tree); try renderToken(r, lbrace, .newline); var fn_proto_buf: [1]Ast.Node.Index = undefined; const full_fn_proto = tree.fullFnProto(&fn_proto_buf, fn_proto).?; - var it = full_fn_proto.iterate(&tree); + var it = full_fn_proto.iterate(tree); while (it.next()) |param| { const name_ident = param.name_token.?; assert(tree.tokenTag(name_ident) == .identifier); @@ -236,7 +236,7 @@ fn renderMember( => { // Extern function prototypes are parsed as these tags. // Go back to the first token we should render here. - const fn_token = tree.nodeMainToken(decl); + const fn_token = decl.mainToken(tree); var i = fn_token; while (i > 0) { i -= 1; @@ -263,8 +263,8 @@ fn renderMember( }, .@"usingnamespace" => { - const main_token = tree.nodeMainToken(decl); - const expr = tree.nodeData(decl).node; + const main_token = decl.mainToken(tree); + const expr = decl.data(tree).node; if (tree.isTokenPrecededByTags(main_token, &.{.keyword_pub})) { try renderToken(r, main_token - 1, .space); // pub } @@ -284,8 +284,8 @@ fn renderMember( }, .test_decl => { - const test_token = tree.nodeMainToken(decl); - const opt_name_token, const block_node = tree.nodeData(decl).opt_token_and_node; + const test_token = decl.mainToken(tree); + const opt_name_token, const block_node = decl.data(tree).opt_token_and_node; try renderToken(r, test_token, .space); if (opt_name_token.unwrap()) |name_token| { switch (tree.tokenTag(name_token)) { @@ -329,9 +329,9 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { } else if (r.fixups.replace_nodes_with_node.get(node)) |replacement| { return renderExpression(r, replacement, space); } - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .identifier => { - const token_index = tree.nodeMainToken(node); + const token_index = node.mainToken(tree); return renderIdentifier(r, token_index, space, .preserve_when_shadowing); }, @@ -340,12 +340,12 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { .unreachable_literal, .anyframe_literal, .string_literal, - => return renderToken(r, tree.nodeMainToken(node), space), + => return renderToken(r, node.mainToken(tree), space), .multiline_string_literal => { try ais.maybeInsertNewline(); - const first_tok, const last_tok = tree.nodeData(node).token_and_token; + const first_tok, const last_tok = node.data(tree).token_and_token; for (first_tok..last_tok + 1) |i| { try renderToken(r, @intCast(i), .newline); } @@ -372,7 +372,7 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .error_value => { - const main_token = tree.nodeMainToken(node); + const main_token = node.mainToken(tree); try renderToken(r, main_token, .none); try renderToken(r, main_token + 1, .none); return renderIdentifier(r, main_token + 2, space, .eagerly_unquote); @@ -389,8 +389,8 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .@"errdefer" => { - const defer_token = tree.nodeMainToken(node); - const maybe_payload_token, const expr = tree.nodeData(node).opt_token_and_node; + const defer_token = node.mainToken(tree); + const maybe_payload_token, const expr = node.data(tree).opt_token_and_node; try renderToken(r, defer_token, .space); if (maybe_payload_token.unwrap()) |payload_token| { @@ -406,15 +406,15 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { .@"nosuspend", .@"suspend", => { - const main_token = tree.nodeMainToken(node); - const item = tree.nodeData(node).node; + const main_token = node.mainToken(tree); + const item = node.data(tree).node; try renderToken(r, main_token, .space); return renderExpression(r, item, space); }, .@"catch" => { - const main_token = tree.nodeMainToken(node); - const lhs, const rhs = tree.nodeData(node).node_and_node; + const main_token = node.mainToken(tree); + const lhs, const rhs = node.data(tree).node_and_node; const fallback_first = tree.firstToken(rhs); const same_line = tree.tokensOnSameLine(main_token, fallback_first); @@ -437,7 +437,7 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .field_access => { - const lhs, const name_token = tree.nodeData(node).node_and_token; + const lhs, const name_token = node.data(tree).node_and_token; const dot_token = name_token - 1; try ais.pushIndent(.field_access); @@ -458,19 +458,19 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { .error_union, .switch_range, => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; try renderExpression(r, lhs, .none); - try renderToken(r, tree.nodeMainToken(node), .none); + try renderToken(r, node.mainToken(tree), .none); return renderExpression(r, rhs, space); }, .for_range => { - const start, const opt_end = tree.nodeData(node).node_and_opt_node; + const start, const opt_end = node.data(tree).node_and_opt_node; try renderExpression(r, start, .none); if (opt_end.unwrap()) |end| { - try renderToken(r, tree.nodeMainToken(node), .none); + try renderToken(r, node.mainToken(tree), .none); return renderExpression(r, end, space); } else { - return renderToken(r, tree.nodeMainToken(node), space); + return renderToken(r, node.mainToken(tree), space); } }, @@ -493,9 +493,9 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { .assign_mul_wrap, .assign_mul_sat, => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; try renderExpression(r, lhs, .space); - const op_token = tree.nodeMainToken(node); + const op_token = node.mainToken(tree); try ais.pushIndent(.after_equals); if (tree.tokensOnSameLine(op_token, op_token + 1)) { try renderToken(r, op_token, .space); @@ -536,9 +536,9 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { .sub_sat, .@"orelse", => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; try renderExpression(r, lhs, .space); - const op_token = tree.nodeMainToken(node); + const op_token = node.mainToken(tree); try ais.pushIndent(.binop); if (tree.tokensOnSameLine(op_token, op_token + 1)) { try renderToken(r, op_token, .space); @@ -557,7 +557,7 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { for (full.ast.variables, 0..) |variable_node, i| { const variable_space: Space = if (i == full.ast.variables.len - 1) .space else .comma_space; - switch (tree.nodeTag(variable_node)) { + switch (variable_node.tag(tree)) { .global_var_decl, .local_var_decl, .simple_var_decl, @@ -585,16 +585,16 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { .optional_type, .address_of, => { - try renderToken(r, tree.nodeMainToken(node), .none); - return renderExpression(r, tree.nodeData(node).node, space); + try renderToken(r, node.mainToken(tree), .none); + return renderExpression(r, node.data(tree).node, space); }, .@"try", .@"resume", .@"await", => { - try renderToken(r, tree.nodeMainToken(node), .space); - return renderExpression(r, tree.nodeData(node).node, space); + try renderToken(r, node.mainToken(tree), .space); + return renderExpression(r, node.data(tree).node, space); }, .array_type, @@ -647,7 +647,7 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .array_access => { - const lhs, const rhs = tree.nodeData(node).node_and_node; + const lhs, const rhs = node.data(tree).node_and_node; const lbracket = tree.firstToken(rhs) - 1; const rbracket = tree.lastToken(rhs) + 1; const one_line = tree.tokensOnSameLine(lbracket, rbracket); @@ -666,12 +666,12 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { => return renderSlice(r, node, tree.fullSlice(node).?, space), .deref => { - try renderExpression(r, tree.nodeData(node).node, .none); - return renderToken(r, tree.nodeMainToken(node), space); + try renderExpression(r, node.data(tree).node, .none); + return renderToken(r, node.mainToken(tree), space); }, .unwrap_optional => { - const lhs, const question_mark = tree.nodeData(node).node_and_token; + const lhs, const question_mark = node.data(tree).node_and_token; const dot_token = question_mark - 1; try renderExpression(r, lhs, .none); try renderToken(r, dot_token, .none); @@ -679,8 +679,8 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .@"break", .@"continue" => { - const main_token = tree.nodeMainToken(node); - const opt_label_token, const opt_target = tree.nodeData(node).opt_token_and_opt_node; + const main_token = node.mainToken(tree); + const opt_label_token, const opt_target = node.data(tree).opt_token_and_opt_node; if (opt_label_token == .none and opt_target == .none) { try renderToken(r, main_token, space); // break/continue } else if (opt_label_token == .none and opt_target != .none) { @@ -703,18 +703,18 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .@"return" => { - if (tree.nodeData(node).opt_node.unwrap()) |expr| { - try renderToken(r, tree.nodeMainToken(node), .space); + if (node.data(tree).opt_node.unwrap()) |expr| { + try renderToken(r, node.mainToken(tree), .space); try renderExpression(r, expr, space); } else { - try renderToken(r, tree.nodeMainToken(node), space); + try renderToken(r, node.mainToken(tree), space); } }, .grouped_expression => { - const expr, const rparen = tree.nodeData(node).node_and_token; + const expr, const rparen = node.data(tree).node_and_token; try ais.pushIndent(.normal); - try renderToken(r, tree.nodeMainToken(node), .none); // lparen + try renderToken(r, node.mainToken(tree), .none); // lparen try renderExpression(r, expr, .none); ais.popIndent(); return renderToken(r, rparen, space); @@ -738,8 +738,8 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .error_set_decl => { - const error_token = tree.nodeMainToken(node); - const lbrace, const rbrace = tree.nodeData(node).token_and_token; + const error_token = node.mainToken(tree); + const lbrace, const rbrace = node.data(tree).token_and_token; try renderToken(r, error_token, .none); @@ -796,7 +796,7 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { => { var buf: [2]Ast.Node.Index = undefined; const params = tree.builtinCallParams(&buf, node).?; - return renderBuiltinCall(r, tree.nodeMainToken(node), params, space); + return renderBuiltinCall(r, node.mainToken(tree), params, space); }, .fn_proto_simple, @@ -809,10 +809,10 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { }, .anyframe_type => { - const main_token = tree.nodeMainToken(node); + const main_token = node.mainToken(tree); try renderToken(r, main_token, .none); // anyframe try renderToken(r, main_token + 1, .none); // -> - return renderExpression(r, tree.nodeData(node).token_and_node[1], space); + return renderExpression(r, node.data(tree).token_and_node[1], space); }, .@"switch", @@ -869,8 +869,8 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void { => return renderAsm(r, tree.fullAsm(node).?, space), .enum_literal => { - try renderToken(r, tree.nodeMainToken(node) - 1, .none); // . - return renderIdentifier(r, tree.nodeMainToken(node), space, .eagerly_unquote); // name + try renderToken(r, node.mainToken(tree) - 1, .none); // . + return renderIdentifier(r, node.mainToken(tree), space, .eagerly_unquote); // name }, .fn_decl => unreachable, @@ -932,7 +932,7 @@ fn renderPtrType(r: *Render, ptr_type: Ast.full.PtrType, space: Space) Error!voi // this pointer type and rely on the child to render our asterisk // as well when it renders the ** token. if (tree.tokenTag(main_token) == .asterisk_asterisk and - main_token == tree.nodeMainToken(ptr_type.ast.child_type)) + main_token == ptr_type.ast.child_type.mainToken(tree)) { return renderExpression(r, ptr_type.ast.child_type, space); } @@ -1017,8 +1017,8 @@ fn renderSlice( space: Space, ) Error!void { const tree = r.tree; - const after_start_space_bool = nodeCausesSliceOpSpace(tree.nodeTag(slice.ast.start)) or - if (slice.ast.end.unwrap()) |end| nodeCausesSliceOpSpace(tree.nodeTag(end)) else false; + const after_start_space_bool = nodeCausesSliceOpSpace(slice.ast.start.tag(tree)) or + if (slice.ast.end.unwrap()) |end| nodeCausesSliceOpSpace(end.tag(tree)) else false; const after_start_space = if (after_start_space_bool) Space.space else Space.none; const after_dots_space = if (slice.ast.end != .none) after_start_space @@ -1050,8 +1050,8 @@ fn renderAsmOutput( space: Space, ) Error!void { const tree = r.tree; - assert(tree.nodeTag(asm_output) == .asm_output); - const symbolic_name = tree.nodeMainToken(asm_output); + assert(asm_output.tag(tree) == .asm_output); + const symbolic_name = asm_output.mainToken(tree); try renderToken(r, symbolic_name - 1, .none); // lbracket try renderIdentifier(r, symbolic_name, .none, .eagerly_unquote); // ident @@ -1060,7 +1060,7 @@ fn renderAsmOutput( try renderToken(r, symbolic_name + 3, .none); // lparen if (tree.tokenTag(symbolic_name + 4) == .arrow) { - const type_expr, const rparen = tree.nodeData(asm_output).opt_node_and_token; + const type_expr, const rparen = asm_output.data(tree).opt_node_and_token; try renderToken(r, symbolic_name + 4, .space); // -> try renderExpression(r, type_expr.unwrap().?, Space.none); return renderToken(r, rparen, space); @@ -1076,9 +1076,9 @@ fn renderAsmInput( space: Space, ) Error!void { const tree = r.tree; - assert(tree.nodeTag(asm_input) == .asm_input); - const symbolic_name = tree.nodeMainToken(asm_input); - const expr, const rparen = tree.nodeData(asm_input).node_and_token; + assert(asm_input.tag(tree) == .asm_input); + const symbolic_name = asm_input.mainToken(tree); + const expr, const rparen = asm_input.data(tree).node_and_token; try renderToken(r, symbolic_name - 1, .none); // lbracket try renderIdentifier(r, symbolic_name, .none, .eagerly_unquote); // ident @@ -1318,7 +1318,7 @@ fn renderThenElse( ) Error!void { const tree = r.tree; const ais = r.ais; - const then_expr_is_block = nodeIsBlock(tree.nodeTag(then_expr)); + const then_expr_is_block = nodeIsBlock(then_expr.tag(tree)); const indent_then_expr = !then_expr_is_block and !tree.tokensOnSameLine(last_prefix_token, tree.firstToken(then_expr)); @@ -1353,8 +1353,8 @@ fn renderThenElse( } const indent_else_expr = indent_then_expr and - !nodeIsBlock(tree.nodeTag(else_expr)) and - !nodeIsIfForWhileSwitch(tree.nodeTag(else_expr)); + !nodeIsBlock(else_expr.tag(tree)) and + !nodeIsIfForWhileSwitch(else_expr.tag(tree)); if (indent_else_expr) { try ais.pushIndent(.normal); try renderToken(r, last_else_token, .newline); @@ -1449,7 +1449,7 @@ fn renderContainerField( const tree = r.tree; const ais = r.ais; var field = field_param; - if (container != .tuple) field.convertToNonTupleLike(&tree); + if (container != .tuple) field.convertToNonTupleLike(tree); const quote: QuoteBehavior = switch (container) { .@"enum" => .eagerly_unquote_except_underscore, .tuple, .other => .eagerly_unquote, @@ -1569,7 +1569,7 @@ fn renderBuiltinCall( const slice = tree.tokenSlice(builtin_token); if (mem.eql(u8, slice, "@import")) f: { const param = params[0]; - const str_lit_token = tree.nodeMainToken(param); + const str_lit_token = param.mainToken(tree); assert(tree.tokenTag(str_lit_token) == .string_literal); const token_bytes = tree.tokenSlice(str_lit_token); const imported_string = std.zig.string_literal.parseAlloc(r.gpa, token_bytes) catch |err| switch (err) { @@ -1829,7 +1829,7 @@ fn renderFnProto(r: *Render, fn_proto: Ast.full.FnProto, space: Space) Error!voi if (fn_proto.ast.callconv_expr.unwrap()) |callconv_expr| { // Keep in sync with logic in `renderMember`. Search this file for the marker PROMOTE_CALLCONV_INLINE - const is_callconv_inline = mem.eql(u8, "@\"inline\"", tree.tokenSlice(tree.nodeMainToken(callconv_expr))); + const is_callconv_inline = mem.eql(u8, "@\"inline\"", tree.tokenSlice(callconv_expr.mainToken(tree))); const is_declaration = fn_proto.name_token != null; if (!(is_declaration and is_callconv_inline)) { const callconv_lparen = tree.firstToken(callconv_expr) - 1; @@ -1882,7 +1882,7 @@ fn renderSwitchCase( } // Render the arrow and everything after it - const pre_target_space = if (tree.nodeTag(switch_case.ast.target_expr) == .multiline_string_literal) + const pre_target_space = if (switch_case.ast.target_expr.tag(tree) == .multiline_string_literal) // Newline gets inserted when rendering the target expr. Space.none else @@ -1917,7 +1917,7 @@ fn renderBlock( ) Error!void { const tree = r.tree; const ais = r.ais; - const lbrace = tree.nodeMainToken(block_node); + const lbrace = block_node.mainToken(tree); if (tree.isTokenPrecededByTags(lbrace, &.{ .identifier, .colon })) { try renderIdentifier(r, lbrace - 2, .none, .eagerly_unquote); // identifier @@ -1946,7 +1946,7 @@ fn finishRenderBlock( if (i != 0) try renderExtraNewline(r, stmt); if (r.fixups.omit_nodes.contains(stmt)) continue; try ais.pushSpace(.semicolon); - switch (tree.nodeTag(stmt)) { + switch (stmt.tag(tree)) { .global_var_decl, .local_var_decl, .simple_var_decl, @@ -1996,7 +1996,7 @@ fn renderStructInit( // Don't output a space after the = if expression is a multiline string, // since then it will start on the next line. const field_node = struct_init.ast.fields[0]; - const expr = tree.nodeTag(field_node); + const expr = field_node.tag(tree); var space_after_equal: Space = if (expr == .multiline_string_literal) .none else .space; try renderToken(r, struct_init.ast.lbrace + 3, space_after_equal); // = @@ -2009,7 +2009,7 @@ fn renderStructInit( try renderExtraNewlineToken(r, init_token - 3); try renderToken(r, init_token - 3, .none); // . try renderIdentifier(r, init_token - 2, .space, .eagerly_unquote); // name - space_after_equal = if (tree.nodeTag(field_init) == .multiline_string_literal) .none else .space; + space_after_equal = if (field_init.tag(tree) == .multiline_string_literal) .none else .space; try renderToken(r, init_token - 1, space_after_equal); // = try ais.pushSpace(.comma); @@ -2361,7 +2361,7 @@ fn renderContainerDecl( } for (container_decl.ast.members, 0..) |member, i| { if (i != 0) try renderExtraNewline(r, member); - switch (tree.nodeTag(member)) { + switch (member.tag(tree)) { // For container fields, ensure a trailing comma is added if necessary. .container_field_init, .container_field_align, @@ -2919,7 +2919,7 @@ fn renderIdentifierContents(writer: anytype, bytes: []const u8) !void { /// `start_token` to `end_token`. This is used to determine if e.g. a /// fn_proto should be wrapped and have a trailing comma inserted even if /// there is none in the source. -fn hasComment(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenIndex) bool { +fn hasComment(tree: *const Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenIndex) bool { for (start_token..end_token) |i| { const token: Ast.TokenIndex = @intCast(i); const start = tree.tokenStart(token) + tree.tokenSlice(token).len; @@ -2932,7 +2932,7 @@ fn hasComment(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenIndex) /// Returns true if there exists a multiline string literal between the start /// of token `start_token` and the start of token `end_token`. -fn hasMultilineString(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenIndex) bool { +fn hasMultilineString(tree: *const Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenIndex) bool { return std.mem.indexOfScalar( Token.Tag, tree.tokens.items(.tag)[start_token..end_token], @@ -3084,7 +3084,7 @@ fn renderContainerDocComments(r: *Render, start_token: Ast.TokenIndex) Error!voi } fn discardAllParams(r: *Render, fn_proto_node: Ast.Node.Index) Error!void { - const tree = &r.tree; + const tree = r.tree; const ais = r.ais; var buf: [1]Ast.Node.Index = undefined; const fn_proto = tree.fullFnProto(&buf, fn_proto_node).?; @@ -3094,12 +3094,12 @@ fn discardAllParams(r: *Render, fn_proto_node: Ast.Node.Index) Error!void { assert(tree.tokenTag(name_ident) == .identifier); const w = ais.writer(); try w.writeAll("_ = "); - try w.writeAll(tokenSliceForRender(r.tree, name_ident)); + try w.writeAll(tokenSliceForRender(tree, name_ident)); try w.writeAll(";\n"); } } -fn tokenSliceForRender(tree: Ast, token_index: Ast.TokenIndex) []const u8 { +fn tokenSliceForRender(tree: *const Ast, token_index: Ast.TokenIndex) []const u8 { var ret = tree.tokenSlice(token_index); switch (tree.tokenTag(token_index)) { .container_doc_comment, .doc_comment => { @@ -3110,7 +3110,7 @@ fn tokenSliceForRender(tree: Ast, token_index: Ast.TokenIndex) []const u8 { return ret; } -fn hasSameLineComment(tree: Ast, token_index: Ast.TokenIndex) bool { +fn hasSameLineComment(tree: *const Ast, token_index: Ast.TokenIndex) bool { const between_source = tree.source[tree.tokenStart(token_index)..tree.tokenStart(token_index + 1)]; for (between_source) |byte| switch (byte) { '\n' => return false, @@ -3122,7 +3122,7 @@ fn hasSameLineComment(tree: Ast, token_index: Ast.TokenIndex) bool { /// Returns `true` if and only if there are any tokens or line comments between /// start_token and end_token. -fn anythingBetween(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenIndex) bool { +fn anythingBetween(tree: *const Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenIndex) bool { if (start_token + 1 != end_token) return true; const between_source = tree.source[tree.tokenStart(start_token)..tree.tokenStart(start_token + 1)]; for (between_source) |byte| switch (byte) { @@ -3217,7 +3217,7 @@ fn nodeCausesSliceOpSpace(tag: Ast.Node.Tag) bool { } // Returns the number of nodes in `exprs` that are on the same line as `rtoken`. -fn rowSize(tree: Ast, exprs: []const Ast.Node.Index, rtoken: Ast.TokenIndex) usize { +fn rowSize(tree: *const Ast, exprs: []const Ast.Node.Index, rtoken: Ast.TokenIndex) usize { const first_token = tree.firstToken(exprs[0]); if (tree.tokensOnSameLine(first_token, rtoken)) { const maybe_comma = rtoken - 1; diff --git a/lib/std/zon/parse.zig b/lib/std/zon/parse.zig index 849aa83f86..53bfc432c0 100644 --- a/lib/std/zon/parse.zig +++ b/lib/std/zon/parse.zig @@ -198,7 +198,7 @@ pub const Error = union(enum) { return location; } else { const ast_node: Ast.Node.Index = @enumFromInt(node_or_offset); - const token = ast.nodeMainToken(ast_node); + const token = ast_node.mainToken(ast); return ast.tokenLocation(0, token); } } @@ -644,7 +644,7 @@ const Parser = struct { switch (try ZonGen.parseStrLit(self.ast, ast_node, buf.writer(self.gpa))) { .success => {}, .failure => |err| { - const token = self.ast.nodeMainToken(ast_node); + const token = ast_node.mainToken(self.ast); const raw_string = self.ast.tokenSlice(token); return self.failTokenFmt(token, @intCast(err.offset()), "{s}", .{err.fmt(raw_string)}); }, @@ -1017,7 +1017,7 @@ const Parser = struct { args: anytype, ) error{ OutOfMemory, ParseZon } { @branchHint(.cold); - const token = self.ast.nodeMainToken(node.getAstNode(self.zoir)); + const token = node.getAstNode(self.zoir).mainToken(self.ast); return self.failTokenFmt(token, 0, fmt, args); } @@ -1036,7 +1036,7 @@ const Parser = struct { message: []const u8, ) error{ParseZon} { @branchHint(.cold); - const token = self.ast.nodeMainToken(node.getAstNode(self.zoir)); + const token = node.getAstNode(self.zoir).mainToken(self.ast); return self.failToken(.{ .token = token, .offset = 0, @@ -1069,7 +1069,7 @@ const Parser = struct { const struct_init = self.ast.fullStructInit(&buf, node.getAstNode(self.zoir)).?; const field_node = struct_init.ast.fields[f]; break :b self.ast.firstToken(field_node) - 2; - } else self.ast.nodeMainToken(node.getAstNode(self.zoir)); + } else node.getAstNode(self.zoir).mainToken(self.ast); switch (@typeInfo(T)) { inline .@"struct", .@"union", .@"enum" => |info| { const note: Error.TypeCheckFailure.Note = if (info.fields.len == 0) b: { diff --git a/src/Package/Manifest.zig b/src/Package/Manifest.zig index 6dff300503..075ba34065 100644 --- a/src/Package/Manifest.zig +++ b/src/Package/Manifest.zig @@ -58,7 +58,7 @@ pub const ParseOptions = struct { pub const Error = Allocator.Error; pub fn parse(gpa: Allocator, ast: Ast, options: ParseOptions) Error!Manifest { - const main_node_index = ast.nodeData(.root).node; + const main_node_index = Ast.Node.Index.root.data(&ast).node; var arena_instance = std.heap.ArenaAllocator.init(gpa); errdefer arena_instance.deinit(); @@ -158,8 +158,8 @@ const Parse = struct { const InnerError = error{ ParseFailure, OutOfMemory }; fn parseRoot(p: *Parse, node: Ast.Node.Index) !void { - const ast = p.ast; - const main_token = ast.nodeMainToken(node); + const ast = &p.ast; + const main_token = node.mainToken(ast); var buf: [2]Ast.Node.Index = undefined; const struct_init = ast.fullStructInit(&buf, node) orelse { @@ -192,17 +192,17 @@ const Parse = struct { p.version_node = field_init; const version_text = try parseString(p, field_init); if (version_text.len > max_version_len) { - try appendError(p, ast.nodeMainToken(field_init), "version string length {d} exceeds maximum of {d}", .{ version_text.len, max_version_len }); + try appendError(p, field_init.mainToken(ast), "version string length {d} exceeds maximum of {d}", .{ version_text.len, max_version_len }); } p.version = std.SemanticVersion.parse(version_text) catch |err| v: { - try appendError(p, ast.nodeMainToken(field_init), "unable to parse semantic version: {s}", .{@errorName(err)}); + try appendError(p, field_init.mainToken(ast), "unable to parse semantic version: {s}", .{@errorName(err)}); break :v undefined; }; have_version = true; } else if (mem.eql(u8, field_name, "minimum_zig_version")) { const version_text = try parseString(p, field_init); p.minimum_zig_version = std.SemanticVersion.parse(version_text) catch |err| v: { - try appendError(p, ast.nodeMainToken(field_init), "unable to parse semantic version: {s}", .{@errorName(err)}); + try appendError(p, field_init.mainToken(ast), "unable to parse semantic version: {s}", .{@errorName(err)}); break :v null; }; } else { @@ -244,11 +244,11 @@ const Parse = struct { } fn parseDependencies(p: *Parse, node: Ast.Node.Index) !void { - const ast = p.ast; + const ast = &p.ast; var buf: [2]Ast.Node.Index = undefined; const struct_init = ast.fullStructInit(&buf, node) orelse { - const tok = ast.nodeMainToken(node); + const tok = node.mainToken(ast); return fail(p, tok, "expected dependencies expression to be a struct", .{}); }; @@ -261,11 +261,11 @@ const Parse = struct { } fn parseDependency(p: *Parse, node: Ast.Node.Index) !Dependency { - const ast = p.ast; + const ast = &p.ast; var buf: [2]Ast.Node.Index = undefined; const struct_init = ast.fullStructInit(&buf, node) orelse { - const tok = ast.nodeMainToken(node); + const tok = node.mainToken(ast); return fail(p, tok, "expected dependency expression to be a struct", .{}); }; @@ -291,7 +291,7 @@ const Parse = struct { // that is desirable on a per-field basis. if (mem.eql(u8, field_name, "url")) { if (has_location) { - return fail(p, ast.nodeMainToken(field_init), "dependency should specify only one of 'url' and 'path' fields.", .{}); + return fail(p, field_init.mainToken(ast), "dependency should specify only one of 'url' and 'path' fields.", .{}); } dep.location = .{ .url = parseString(p, field_init) catch |err| switch (err) { @@ -300,11 +300,11 @@ const Parse = struct { }, }; has_location = true; - dep.location_tok = ast.nodeMainToken(field_init); + dep.location_tok = field_init.mainToken(ast); dep.location_node = field_init; } else if (mem.eql(u8, field_name, "path")) { if (has_location) { - return fail(p, ast.nodeMainToken(field_init), "dependency should specify only one of 'url' and 'path' fields.", .{}); + return fail(p, field_init.mainToken(ast), "dependency should specify only one of 'url' and 'path' fields.", .{}); } dep.location = .{ .path = parseString(p, field_init) catch |err| switch (err) { @@ -313,14 +313,14 @@ const Parse = struct { }, }; has_location = true; - dep.location_tok = ast.nodeMainToken(field_init); + dep.location_tok = field_init.mainToken(ast); dep.location_node = field_init; } else if (mem.eql(u8, field_name, "hash")) { dep.hash = parseHash(p, field_init) catch |err| switch (err) { error.ParseFailure => continue, else => |e| return e, }; - dep.hash_tok = .fromToken(ast.nodeMainToken(field_init)); + dep.hash_tok = .fromToken(field_init.mainToken(ast)); dep.hash_node = field_init.toOptional(); } else if (mem.eql(u8, field_name, "lazy")) { dep.lazy = parseBool(p, field_init) catch |err| switch (err) { @@ -334,18 +334,18 @@ const Parse = struct { } if (!has_location) { - try appendError(p, ast.nodeMainToken(node), "dependency requires location field, one of 'url' or 'path'.", .{}); + try appendError(p, node.mainToken(ast), "dependency requires location field, one of 'url' or 'path'.", .{}); } return dep; } fn parseIncludedPaths(p: *Parse, node: Ast.Node.Index) !void { - const ast = p.ast; + const ast = &p.ast; var buf: [2]Ast.Node.Index = undefined; const array_init = ast.fullArrayInit(&buf, node) orelse { - const tok = ast.nodeMainToken(node); + const tok = node.mainToken(ast); return fail(p, tok, "expected paths expression to be a list of strings", .{}); }; @@ -359,11 +359,11 @@ const Parse = struct { } fn parseBool(p: *Parse, node: Ast.Node.Index) !bool { - const ast = p.ast; - if (ast.nodeTag(node) != .identifier) { - return fail(p, ast.nodeMainToken(node), "expected identifier", .{}); + const ast = &p.ast; + if (node.tag(ast) != .identifier) { + return fail(p, node.mainToken(ast), "expected identifier", .{}); } - const ident_token = ast.nodeMainToken(node); + const ident_token = node.mainToken(ast); const token_bytes = ast.tokenSlice(ident_token); if (mem.eql(u8, token_bytes, "true")) { return true; @@ -375,9 +375,9 @@ const Parse = struct { } fn parseFingerprint(p: *Parse, node: Ast.Node.Index) !Package.Fingerprint { - const ast = p.ast; - const main_token = ast.nodeMainToken(node); - if (ast.nodeTag(node) != .number_literal) { + const ast = &p.ast; + const main_token = node.mainToken(ast); + if (node.tag(ast) != .number_literal) { return fail(p, main_token, "expected integer literal", .{}); } const token_bytes = ast.tokenSlice(main_token); @@ -392,10 +392,10 @@ const Parse = struct { } fn parseName(p: *Parse, node: Ast.Node.Index) ![]const u8 { - const ast = p.ast; - const main_token = ast.nodeMainToken(node); + const ast = &p.ast; + const main_token = node.mainToken(ast); - if (p.allow_name_string and ast.nodeTag(node) == .string_literal) { + if (p.allow_name_string and node.tag(ast) == .string_literal) { const name = try parseString(p, node); if (!std.zig.isValidId(name)) return fail(p, main_token, "name must be a valid bare zig identifier (hint: switch from string to enum literal)", .{}); @@ -408,7 +408,7 @@ const Parse = struct { return name; } - if (ast.nodeTag(node) != .enum_literal) + if (node.tag(ast) != .enum_literal) return fail(p, main_token, "expected enum literal", .{}); const ident_name = ast.tokenSlice(main_token); @@ -424,11 +424,11 @@ const Parse = struct { } fn parseString(p: *Parse, node: Ast.Node.Index) ![]const u8 { - const ast = p.ast; - if (ast.nodeTag(node) != .string_literal) { - return fail(p, ast.nodeMainToken(node), "expected string literal", .{}); + const ast = &p.ast; + if (node.tag(ast) != .string_literal) { + return fail(p, node.mainToken(ast), "expected string literal", .{}); } - const str_lit_token = ast.nodeMainToken(node); + const str_lit_token = node.mainToken(ast); const token_bytes = ast.tokenSlice(str_lit_token); p.buf.clearRetainingCapacity(); try parseStrLit(p, str_lit_token, &p.buf, token_bytes, 0); @@ -437,8 +437,8 @@ const Parse = struct { } fn parseHash(p: *Parse, node: Ast.Node.Index) ![]const u8 { - const ast = p.ast; - const tok = ast.nodeMainToken(node); + const ast = &p.ast; + const tok = node.mainToken(ast); const h = try parseString(p, node); if (h.len > Package.Hash.max_len) { @@ -450,7 +450,7 @@ const Parse = struct { /// TODO: try to DRY this with AstGen.identifierTokenString fn identifierTokenString(p: *Parse, token: Ast.TokenIndex) InnerError![]const u8 { - const ast = p.ast; + const ast = &p.ast; assert(ast.tokenTag(token) == .identifier); const ident_name = ast.tokenSlice(token); if (!mem.startsWith(u8, ident_name, "@")) { diff --git a/src/Sema.zig b/src/Sema.zig index 41453d2bba..b3950c7037 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -17298,7 +17298,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat break :name null; }; const node = src_node.toAbsolute(src_base_node); - const token = tree.nodeMainToken(node); + const token = node.mainToken(tree); break :name tree.tokenSlice(token); }; @@ -17326,7 +17326,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat break :name null; }; const node = src_node.toAbsolute(src_base_node); - const token = tree.nodeMainToken(node); + const token = node.mainToken(tree); break :name tree.tokenSlice(token); }; diff --git a/src/Zcu.zig b/src/Zcu.zig index 584eb8ca3d..0adaaa115f 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -1143,7 +1143,7 @@ pub const SrcLoc = struct { .node_offset_main_token => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - const main_token = tree.nodeMainToken(node); + const main_token = node.mainToken(tree); return tree.tokensToSpan(main_token, main_token, main_token); }, .node_offset_bin_op => |node_off| { @@ -1157,20 +1157,20 @@ pub const SrcLoc = struct { return tree.tokensToSpan( tree.firstToken(node) - 3, tree.lastToken(node), - tree.nodeMainToken(node) - 2, + node.mainToken(tree) - 2, ); }, .node_offset_var_decl_ty => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - const full = switch (tree.nodeTag(node)) { + const full = switch (node.tag(tree)) { .global_var_decl, .local_var_decl, .simple_var_decl, .aligned_var_decl, => tree.fullVarDecl(node).?, .@"usingnamespace" => { - return tree.nodeToSpan(tree.nodeData(node).node); + return tree.nodeToSpan(node.data(tree).node); }, else => unreachable, }; @@ -1221,7 +1221,7 @@ pub const SrcLoc = struct { .node_offset_var_decl_init => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - const init_node = switch (tree.nodeTag(node)) { + const init_node = switch (node.tag(tree)) { .global_var_decl, .local_var_decl, .aligned_var_decl, @@ -1244,16 +1244,16 @@ pub const SrcLoc = struct { var node = node_off.toAbsolute(src_loc.base_node); while (true) { - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .builtin_call_two, .builtin_call_two_comma => {}, else => break, } - const first_arg, const second_arg = tree.nodeData(node).opt_node_and_opt_node; + const first_arg, const second_arg = node.data(tree).opt_node_and_opt_node; if (first_arg == .none) break; // 0 args if (second_arg != .none) break; // 2 args - const builtin_token = tree.nodeMainToken(node); + const builtin_token = node.mainToken(tree); const builtin_name = tree.tokenSlice(builtin_token); const info = BuiltinFn.list.get(builtin_name) orelse break; @@ -1275,7 +1275,7 @@ pub const SrcLoc = struct { .node_offset_array_access_index => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - return tree.nodeToSpan(tree.nodeData(node).node_and_node[1]); + return tree.nodeToSpan(node.data(tree).node_and_node[1]); }, .node_offset_slice_ptr, .node_offset_slice_start, @@ -1305,8 +1305,8 @@ pub const SrcLoc = struct { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); var buf: [1]Ast.Node.Index = undefined; - const tok_index = switch (tree.nodeTag(node)) { - .field_access => tree.nodeData(node).node_and_token[1], + const tok_index = switch (node.tag(tree)) { + .field_access => node.data(tree).node_and_token[1], .call_one, .call_one_comma, .async_call_one, @@ -1349,13 +1349,13 @@ pub const SrcLoc = struct { const node = node_off.toAbsolute(src_loc.base_node); const full = tree.fullAsm(node).?; const asm_output = full.outputs[0]; - return tree.nodeToSpan(tree.nodeData(asm_output).opt_node_and_token[0].unwrap().?); + return tree.nodeToSpan(asm_output.data(tree).opt_node_and_token[0].unwrap().?); }, .node_offset_if_cond => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - const src_node = switch (tree.nodeTag(node)) { + const src_node = switch (node.tag(tree)) { .if_simple, .@"if", => tree.fullIf(node).?.ast.cond_expr, @@ -1433,9 +1433,9 @@ pub const SrcLoc = struct { const node = call_arg.call_node_offset.toAbsolute(src_loc.base_node); var buf: [2]Ast.Node.Index = undefined; const call_full = tree.fullCall(buf[0..1], node) orelse { - assert(tree.nodeTag(node) == .builtin_call); - const call_args_node: Ast.Node.Index = @enumFromInt(tree.extra_data[@intFromEnum(tree.nodeData(node).extra_range.end) - 1]); - switch (tree.nodeTag(call_args_node)) { + assert(node.tag(tree) == .builtin_call); + const call_args_node: Ast.Node.Index = @enumFromInt(tree.extra_data[@intFromEnum(node.data(tree).extra_range.end) - 1]); + switch (call_args_node.tag(tree)) { .array_init_one, .array_init_one_comma, .array_init_dot_two, @@ -1496,23 +1496,23 @@ pub const SrcLoc = struct { .node_offset_bin_lhs => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - return tree.nodeToSpan(tree.nodeData(node).node_and_node[0]); + return tree.nodeToSpan(node.data(tree).node_and_node[0]); }, .node_offset_bin_rhs => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - return tree.nodeToSpan(tree.nodeData(node).node_and_node[1]); + return tree.nodeToSpan(node.data(tree).node_and_node[1]); }, .array_cat_lhs, .array_cat_rhs => |cat| { const tree = try src_loc.file_scope.getTree(gpa); const node = cat.array_cat_offset.toAbsolute(src_loc.base_node); const arr_node = if (src_loc.lazy == .array_cat_lhs) - tree.nodeData(node).node_and_node[0] + node.data(tree).node_and_node[0] else - tree.nodeData(node).node_and_node[1]; + node.data(tree).node_and_node[1]; var buf: [2]Ast.Node.Index = undefined; - switch (tree.nodeTag(arr_node)) { + switch (arr_node.tag(tree)) { .array_init_one, .array_init_one_comma, .array_init_dot_two, @@ -1532,27 +1532,27 @@ pub const SrcLoc = struct { .node_offset_try_operand => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - return tree.nodeToSpan(tree.nodeData(node).node); + return tree.nodeToSpan(node.data(tree).node); }, .node_offset_switch_operand => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - const condition, _ = tree.nodeData(node).node_and_extra; + const condition, _ = node.data(tree).node_and_extra; return tree.nodeToSpan(condition); }, .node_offset_switch_special_prong => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const switch_node = node_off.toAbsolute(src_loc.base_node); - _, const extra_index = tree.nodeData(switch_node).node_and_extra; + _, const extra_index = switch_node.data(tree).node_and_extra; const case_nodes = tree.extraDataSlice(tree.extraData(extra_index, Ast.Node.SubRange), Ast.Node.Index); for (case_nodes) |case_node| { const case = tree.fullSwitchCase(case_node).?; const is_special = (case.ast.values.len == 0) or (case.ast.values.len == 1 and - tree.nodeTag(case.ast.values[0]) == .identifier and - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(case.ast.values[0])), "_")); + case.ast.values[0].tag(tree) == .identifier and + mem.eql(u8, tree.tokenSlice(case.ast.values[0].mainToken(tree)), "_")); if (!is_special) continue; return tree.nodeToSpan(case_node); @@ -1562,18 +1562,18 @@ pub const SrcLoc = struct { .node_offset_switch_range => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const switch_node = node_off.toAbsolute(src_loc.base_node); - _, const extra_index = tree.nodeData(switch_node).node_and_extra; + _, const extra_index = switch_node.data(tree).node_and_extra; const case_nodes = tree.extraDataSlice(tree.extraData(extra_index, Ast.Node.SubRange), Ast.Node.Index); for (case_nodes) |case_node| { const case = tree.fullSwitchCase(case_node).?; const is_special = (case.ast.values.len == 0) or (case.ast.values.len == 1 and - tree.nodeTag(case.ast.values[0]) == .identifier and - mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(case.ast.values[0])), "_")); + case.ast.values[0].tag(tree) == .identifier and + mem.eql(u8, tree.tokenSlice(case.ast.values[0].mainToken(tree)), "_")); if (is_special) continue; for (case.ast.values) |item_node| { - if (tree.nodeTag(item_node) == .switch_range) { + if (item_node.tag(tree) == .switch_range) { return tree.nodeToSpan(item_node); } } @@ -1632,7 +1632,7 @@ pub const SrcLoc = struct { }, .token_offset_param => |token_off| { const tree = try src_loc.file_scope.getTree(gpa); - const main_token = tree.nodeMainToken(src_loc.base_node); + const main_token = src_loc.base_node.mainToken(tree); const tok_index = token_off.toAbsolute(main_token); var first_tok = tok_index; @@ -1650,7 +1650,7 @@ pub const SrcLoc = struct { .node_offset_anyframe_type => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const parent_node = node_off.toAbsolute(src_loc.base_node); - _, const child_type = tree.nodeData(parent_node).token_and_node; + _, const child_type = parent_node.data(tree).token_and_node; return tree.nodeToSpan(child_type); }, @@ -1689,7 +1689,7 @@ pub const SrcLoc = struct { .node_offset_un_op => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - return tree.nodeToSpan(tree.nodeData(node).node); + return tree.nodeToSpan(node.data(tree).node); }, .node_offset_ptr_elem => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); @@ -1737,7 +1737,7 @@ pub const SrcLoc = struct { const tree = try src_loc.file_scope.getTree(gpa); const parent_node = node_off.toAbsolute(src_loc.base_node); - switch (tree.nodeTag(parent_node)) { + switch (parent_node.tag(tree)) { .container_decl_arg, .container_decl_arg_trailing => { const full = tree.containerDeclArg(parent_node); const arg_node = full.ast.arg.unwrap().?; @@ -1750,7 +1750,7 @@ pub const SrcLoc = struct { return tree.tokensToSpan( tree.firstToken(arg_node) - 2, tree.lastToken(arg_node) + 1, - tree.nodeMainToken(arg_node), + arg_node.mainToken(tree), ); }, else => unreachable, @@ -1760,7 +1760,7 @@ pub const SrcLoc = struct { const tree = try src_loc.file_scope.getTree(gpa); const parent_node = node_off.toAbsolute(src_loc.base_node); - const full: Ast.full.ContainerField = switch (tree.nodeTag(parent_node)) { + const full: Ast.full.ContainerField = switch (parent_node.tag(tree)) { .container_field => tree.containerField(parent_node), .container_field_init => tree.containerFieldInit(parent_node), else => unreachable, @@ -1782,7 +1782,7 @@ pub const SrcLoc = struct { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .assign, .assign_mul, .assign_div, @@ -1801,7 +1801,7 @@ pub const SrcLoc = struct { .assign_mul_sat, .assign_add_sat, .assign_sub_sat, - => return tree.nodeToSpan(tree.nodeData(node).node_and_node[0]), + => return tree.nodeToSpan(node.data(tree).node_and_node[0]), else => return tree.nodeToSpan(node), } }, @@ -1809,7 +1809,7 @@ pub const SrcLoc = struct { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - switch (tree.nodeTag(node)) { + switch (node.tag(tree)) { .assign, .assign_mul, .assign_div, @@ -1828,15 +1828,15 @@ pub const SrcLoc = struct { .assign_mul_sat, .assign_add_sat, .assign_sub_sat, - => return tree.nodeToSpan(tree.nodeData(node).node_and_node[1]), + => return tree.nodeToSpan(node.data(tree).node_and_node[1]), else => return tree.nodeToSpan(node), } }, .node_offset_return_operand => |node_off| { const tree = try src_loc.file_scope.getTree(gpa); const node = node_off.toAbsolute(src_loc.base_node); - if (tree.nodeTag(node) == .@"return") { - if (tree.nodeData(node).opt_node.unwrap()) |lhs| { + if (node.tag(tree) == .@"return") { + if (node.data(tree).opt_node.unwrap()) |lhs| { return tree.nodeToSpan(lhs); } } @@ -1900,7 +1900,7 @@ pub const SrcLoc = struct { return tree.tokensToSpan( tree.firstToken(field_node) - 3, tree.lastToken(field_node), - tree.nodeMainToken(field_node) - 2, + field_node.mainToken(tree) - 2, ); } else unreachable; }, @@ -1944,7 +1944,7 @@ pub const SrcLoc = struct { return tree.tokensToSpan( name_token - 1, tree.lastToken(field_node), - tree.nodeMainToken(field_node) - 2, + field_node.mainToken(tree) - 2, ); } } @@ -1969,7 +1969,7 @@ pub const SrcLoc = struct { const tree = try src_loc.file_scope.getTree(gpa); const switch_node = switch_node_offset.toAbsolute(src_loc.base_node); - _, const extra_index = tree.nodeData(switch_node).node_and_extra; + _, const extra_index = switch_node.data(tree).node_and_extra; const case_nodes = tree.extraDataSlice(tree.extraData(extra_index, Ast.Node.SubRange), Ast.Node.Index); var multi_i: u32 = 0; @@ -1978,8 +1978,8 @@ pub const SrcLoc = struct { const case = tree.fullSwitchCase(case_node).?; const is_special = special: { if (case.ast.values.len == 0) break :special true; - if (case.ast.values.len == 1 and tree.nodeTag(case.ast.values[0]) == .identifier) { - break :special mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(case.ast.values[0])), "_"); + if (case.ast.values.len == 1 and case.ast.values[0].tag(tree) == .identifier) { + break :special mem.eql(u8, tree.tokenSlice(case.ast.values[0].mainToken(tree)), "_"); } break :special false; }; @@ -1991,7 +1991,7 @@ pub const SrcLoc = struct { } const is_multi = case.ast.values.len != 1 or - tree.nodeTag(case.ast.values[0]) == .switch_range; + case.ast.values[0].tag(tree) == .switch_range; switch (want_case_idx.kind) { .scalar => if (!is_multi and want_case_idx.index == scalar_i) break case, @@ -2034,7 +2034,7 @@ pub const SrcLoc = struct { .single => { var item_i: u32 = 0; for (case.ast.values) |item_node| { - if (tree.nodeTag(item_node) == .switch_range) continue; + if (item_node.tag(tree) == .switch_range) continue; if (item_i != want_item.index) { item_i += 1; continue; @@ -2045,12 +2045,12 @@ pub const SrcLoc = struct { .range => { var range_i: u32 = 0; for (case.ast.values) |item_node| { - if (tree.nodeTag(item_node) != .switch_range) continue; + if (item_node.tag(tree) != .switch_range) continue; if (range_i != want_item.index) { range_i += 1; continue; } - const first, const last = tree.nodeData(item_node).node_and_node; + const first, const last = item_node.data(tree).node_and_node; return switch (src_loc.lazy) { .switch_case_item => tree.nodeToSpan(item_node), .switch_case_item_range_first => tree.nodeToSpan(first), diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index c80b80cb7d..4409f26e27 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -261,7 +261,7 @@ pub fn updateFile( }; }, .zon => { - file.zoir = try ZonGen.generate(gpa, file.tree.?, .{}); + file.zoir = try ZonGen.generate(gpa, &file.tree.?, .{}); Zcu.saveZoirCache(cache_file, stat, file.zoir.?) catch |err| { log.warn("unable to write cached ZOIR code for {}{s} to {}{s}: {s}", .{ file.mod.root, file.sub_file_path, cache_directory, &hex_digest, @errorName(err), diff --git a/src/fmt.zig b/src/fmt.zig index 6b1d73951e..7afa6a5295 100644 --- a/src/fmt.zig +++ b/src/fmt.zig @@ -106,28 +106,28 @@ pub fn run( if (check_ast_flag) { if (!force_zon) { - var zir = try std.zig.AstGen.generate(gpa, tree); + var zir = try std.zig.AstGen.generate(gpa, &tree); defer zir.deinit(gpa); if (zir.hasCompileErrors()) { var wip_errors: std.zig.ErrorBundle.Wip = undefined; try wip_errors.init(gpa); defer wip_errors.deinit(); - try wip_errors.addZirErrorMessages(zir, tree, source_code, ""); + try wip_errors.addZirErrorMessages(zir, &tree, source_code, ""); var error_bundle = try wip_errors.toOwnedBundle(""); defer error_bundle.deinit(gpa); error_bundle.renderToStdErr(color.renderOptions()); process.exit(2); } } else { - const zoir = try std.zig.ZonGen.generate(gpa, tree, .{}); + const zoir = try std.zig.ZonGen.generate(gpa, &tree, .{}); defer zoir.deinit(gpa); if (zoir.hasCompileErrors()) { var wip_errors: std.zig.ErrorBundle.Wip = undefined; try wip_errors.init(gpa); defer wip_errors.deinit(); - try wip_errors.addZoirErrorMessages(zoir, tree, source_code, ""); + try wip_errors.addZoirErrorMessages(zoir, &tree, source_code, ""); var error_bundle = try wip_errors.toOwnedBundle(""); defer error_bundle.deinit(gpa); error_bundle.renderToStdErr(color.renderOptions()); diff --git a/src/main.zig b/src/main.zig index 4ced84d469..095b26c95a 100644 --- a/src/main.zig +++ b/src/main.zig @@ -6454,7 +6454,7 @@ fn cmdAstCheck( } }, .zon => { - const zoir = try ZonGen.generate(gpa, file.tree.?, .{}); + const zoir = try ZonGen.generate(gpa, &file.tree.?, .{}); defer zoir.deinit(gpa); if (zoir.hasCompileErrors()) {