authorgravatar for techatrix@mailbox.orgTechatrix <techatrix@mailbox.org> 2025-01-03 05:31:56+01:00
committergravatar for techatrix@mailbox.orgTechatrix <techatrix@mailbox.org> 2025-03-07 22:20:35+01:00
log6dcd8f4f75098c716ed617a388c96238c70aff17
tree59b9f6532751f8e2241c668c6a8984bda25932c2
parentde9c889a0e7b8ef71d1c1d11985bf87e180885a6
signaturebadge-check Signed by SSH key SHA256:HYC3SjXQcAt6uwv9pu/6OoVQ2rUH8rb5zKiUHSe9uxk

std.zig.Ast: add `blockStatements` and `builtinCallParams`

7 files changed, 142 insertions(+), 259 deletions(-)

lib/compiler/reduce/Walk.zig+17-45
......@@ -230,20 +230,11 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
230230
231231 .block_two,
232232 .block_two_semicolon,
233 => {
234 const statements = [2]Ast.Node.Index{ datas[node].lhs, datas[node].rhs };
235 if (datas[node].lhs == 0) {
236 return walkBlock(w, node, statements[0..0]);
237 } else if (datas[node].rhs == 0) {
238 return walkBlock(w, node, statements[0..1]);
239 } else {
240 return walkBlock(w, node, statements[0..2]);
241 }
242 },
243233 .block,
244234 .block_semicolon,
245235 => {
246 const statements = ast.extra_data[datas[node].lhs..datas[node].rhs];
236 var buf: [2]Ast.Node.Index = undefined;
237 const statements = ast.blockStatements(&buf, node).?;
247238 return walkBlock(w, node, statements);
248239 },
249240
......@@ -506,17 +497,13 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
506497 }
507498 },
508499
509 .builtin_call_two, .builtin_call_two_comma => {
510 if (datas[node].lhs == 0) {
511 return walkBuiltinCall(w, node, &.{});
512 } else if (datas[node].rhs == 0) {
513 return walkBuiltinCall(w, node, &.{datas[node].lhs});
514 } else {
515 return walkBuiltinCall(w, node, &.{ datas[node].lhs, datas[node].rhs });
516 }
517 },
518 .builtin_call, .builtin_call_comma => {
519 const params = ast.extra_data[datas[node].lhs..datas[node].rhs];
500 .builtin_call_two,
501 .builtin_call_two_comma,
502 .builtin_call,
503 .builtin_call_comma,
504 => {
505 var buf: [2]Ast.Node.Index = undefined;
506 const params = ast.builtinCallParams(&buf, node).?;
520507 return walkBuiltinCall(w, node, params);
521508 },
522509
......@@ -972,24 +959,13 @@ fn walkParamList(w: *Walk, params: []const Ast.Node.Index) Error!void {
972959fn isFnBodyGutted(ast: *const Ast, body_node: Ast.Node.Index) bool {
973960 // skip over discards
974961 const node_tags = ast.nodes.items(.tag);
975 const datas = ast.nodes.items(.data);
976962 var statements_buf: [2]Ast.Node.Index = undefined;
977963 const statements = switch (node_tags[body_node]) {
978964 .block_two,
979965 .block_two_semicolon,
980 => blk: {
981 statements_buf[0..2].* = .{ datas[body_node].lhs, datas[body_node].rhs };
982 break :blk if (datas[body_node].lhs == 0)
983 statements_buf[0..0]
984 else if (datas[body_node].rhs == 0)
985 statements_buf[0..1]
986 else
987 statements_buf[0..2];
988 },
989
990966 .block,
991967 .block_semicolon,
992 => ast.extra_data[datas[body_node].lhs..datas[body_node].rhs],
968 => ast.blockStatements(&statements_buf, body_node).?,
993969
994970 else => return false,
995971 };
......@@ -1016,17 +992,13 @@ fn categorizeStmt(ast: *const Ast, stmt: Ast.Node.Index) StmtCategory {
1016992 const datas = ast.nodes.items(.data);
1017993 const main_tokens = ast.nodes.items(.main_token);
1018994 switch (node_tags[stmt]) {
1019 .builtin_call_two, .builtin_call_two_comma => {
1020 if (datas[stmt].lhs == 0) {
1021 return categorizeBuiltinCall(ast, main_tokens[stmt], &.{});
1022 } else if (datas[stmt].rhs == 0) {
1023 return categorizeBuiltinCall(ast, main_tokens[stmt], &.{datas[stmt].lhs});
1024 } else {
1025 return categorizeBuiltinCall(ast, main_tokens[stmt], &.{ datas[stmt].lhs, datas[stmt].rhs });
1026 }
1027 },
1028 .builtin_call, .builtin_call_comma => {
1029 const params = ast.extra_data[datas[stmt].lhs..datas[stmt].rhs];
995 .builtin_call_two,
996 .builtin_call_two_comma,
997 .builtin_call,
998 .builtin_call_comma,
999 => {
1000 var buf: [2]Ast.Node.Index = undefined;
1001 const params = ast.builtinCallParams(&buf, stmt).?;
10301002 return categorizeBuiltinCall(ast, main_tokens[stmt], params);
10311003 },
10321004 .assign => {
lib/docs/wasm/Walk.zig+21-40
......@@ -232,20 +232,13 @@ pub const File = struct {
232232 return .{ .global_const = node };
233233 },
234234
235 .builtin_call_two, .builtin_call_two_comma => {
236 if (node_datas[node].lhs == 0) {
237 const params = [_]Ast.Node.Index{};
238 return categorize_builtin_call(file_index, node, &params);
239 } else if (node_datas[node].rhs == 0) {
240 const params = [_]Ast.Node.Index{node_datas[node].lhs};
241 return categorize_builtin_call(file_index, node, &params);
242 } else {
243 const params = [_]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
244 return categorize_builtin_call(file_index, node, &params);
245 }
246 },
247 .builtin_call, .builtin_call_comma => {
248 const params = ast.extra_data[node_datas[node].lhs..node_datas[node].rhs];
235 .builtin_call_two,
236 .builtin_call_two_comma,
237 .builtin_call,
238 .builtin_call_comma,
239 => {
240 var buf: [2]Ast.Node.Index = undefined;
241 const params = ast.builtinCallParams(&buf, node).?;
249242 return categorize_builtin_call(file_index, node, params);
250243 },
251244
......@@ -818,20 +811,13 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
818811 try expr(w, scope, parent_decl, full.ast.template);
819812 },
820813
821 .builtin_call_two, .builtin_call_two_comma => {
822 if (node_datas[node].lhs == 0) {
823 const params = [_]Ast.Node.Index{};
824 return builtin_call(w, scope, parent_decl, node, &params);
825 } else if (node_datas[node].rhs == 0) {
826 const params = [_]Ast.Node.Index{node_datas[node].lhs};
827 return builtin_call(w, scope, parent_decl, node, &params);
828 } else {
829 const params = [_]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
830 return builtin_call(w, scope, parent_decl, node, &params);
831 }
832 },
833 .builtin_call, .builtin_call_comma => {
834 const params = ast.extra_data[node_datas[node].lhs..node_datas[node].rhs];
814 .builtin_call_two,
815 .builtin_call_two_comma,
816 .builtin_call,
817 .builtin_call_comma,
818 => {
819 var buf: [2]Ast.Node.Index = undefined;
820 const params = ast.builtinCallParams(&buf, node).?;
835821 return builtin_call(w, scope, parent_decl, node, params);
836822 },
837823
......@@ -886,18 +872,13 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
886872 .slice_open => return slice(w, scope, parent_decl, ast.sliceOpen(node)),
887873 .slice_sentinel => return slice(w, scope, parent_decl, ast.sliceSentinel(node)),
888874
889 .block_two, .block_two_semicolon => {
890 const statements = [2]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
891 if (node_datas[node].lhs == 0) {
892 return block(w, scope, parent_decl, statements[0..0]);
893 } else if (node_datas[node].rhs == 0) {
894 return block(w, scope, parent_decl, statements[0..1]);
895 } else {
896 return block(w, scope, parent_decl, statements[0..2]);
897 }
898 },
899 .block, .block_semicolon => {
900 const statements = ast.extra_data[node_datas[node].lhs..node_datas[node].rhs];
875 .block_two,
876 .block_two_semicolon,
877 .block,
878 .block_semicolon,
879 => {
880 var buf: [2]Ast.Node.Index = undefined;
881 const statements = ast.blockStatements(&buf, node).?;
901882 return block(w, scope, parent_decl, statements);
902883 },
903884
lib/std/zig/Ast.zig+36
......@@ -2432,6 +2432,42 @@ pub fn fullCall(tree: Ast, buffer: *[1]Ast.Node.Index, node: Node.Index) ?full.C
24322432 };
24332433}
24342434
2435pub fn builtinCallParams(tree: Ast, buffer: *[2]Ast.Node.Index, node: Ast.Node.Index) ?[]const Node.Index {
2436 const data = tree.nodes.items(.data)[node];
2437 return switch (tree.nodes.items(.tag)[node]) {
2438 .builtin_call_two, .builtin_call_two_comma => {
2439 buffer.* = .{ data.lhs, data.rhs };
2440 if (data.rhs != 0) {
2441 return buffer[0..2];
2442 } else if (data.lhs != 0) {
2443 return buffer[0..1];
2444 } else {
2445 return buffer[0..0];
2446 }
2447 },
2448 .builtin_call, .builtin_call_comma => tree.extra_data[data.lhs..data.rhs],
2449 else => null,
2450 };
2451}
2452
2453pub fn blockStatements(tree: Ast, buffer: *[2]Ast.Node.Index, node: Ast.Node.Index) ?[]const Node.Index {
2454 const data = tree.nodes.items(.data)[node];
2455 return switch (tree.nodes.items(.tag)[node]) {
2456 .block_two, .block_two_semicolon => {
2457 buffer.* = .{ data.lhs, data.rhs };
2458 if (data.rhs != 0) {
2459 return buffer[0..2];
2460 } else if (data.lhs != 0) {
2461 return buffer[0..1];
2462 } else {
2463 return buffer[0..0];
2464 }
2465 },
2466 .block, .block_semicolon => tree.extra_data[data.lhs..data.rhs],
2467 else => null,
2468 };
2469}
2470
24352471/// Fully assembled AST node information.
24362472pub const full = struct {
24372473 pub const VarDecl = struct {
lib/std/zig/AstGen.zig+38-91
......@@ -824,20 +824,13 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
824824 .number_literal => return numberLiteral(gz, ri, node, node, .positive),
825825 // zig fmt: on
826826
827 .builtin_call_two, .builtin_call_two_comma => {
828 if (node_datas[node].lhs == 0) {
829 const params = [_]Ast.Node.Index{};
830 return builtinCall(gz, scope, ri, node, &params, false);
831 } else if (node_datas[node].rhs == 0) {
832 const params = [_]Ast.Node.Index{node_datas[node].lhs};
833 return builtinCall(gz, scope, ri, node, &params, false);
834 } else {
835 const params = [_]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
836 return builtinCall(gz, scope, ri, node, &params, false);
837 }
838 },
839 .builtin_call, .builtin_call_comma => {
840 const params = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
827 .builtin_call_two,
828 .builtin_call_two_comma,
829 .builtin_call,
830 .builtin_call_comma,
831 => {
832 var buf: [2]Ast.Node.Index = undefined;
833 const params = tree.builtinCallParams(&buf, node).?;
841834 return builtinCall(gz, scope, ri, node, params, false);
842835 },
843836
......@@ -991,18 +984,13 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
991984 return rvalue(gz, ri, try gz.addUnNode(.optional_payload_safe, lhs, node), node);
992985 },
993986 },
994 .block_two, .block_two_semicolon => {
995 const statements = [2]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };
996 if (node_datas[node].lhs == 0) {
997 return blockExpr(gz, scope, ri, node, statements[0..0], .normal);
998 } else if (node_datas[node].rhs == 0) {
999 return blockExpr(gz, scope, ri, node, statements[0..1], .normal);
1000 } else {
1001 return blockExpr(gz, scope, ri, node, statements[0..2], .normal);
1002 }
1003 },
1004 .block, .block_semicolon => {
1005 const statements = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
987 .block_two,
988 .block_two_semicolon,
989 .block,
990 .block_semicolon,
991 => {
992 var buf: [2]Ast.Node.Index = undefined;
993 const statements = tree.blockStatements(&buf, node).?;
1006994 return blockExpr(gz, scope, ri, node, statements, .normal);
1007995 },
1008996 .enum_literal => if (try ri.rl.resultType(gz, node)) |res_ty| {
......@@ -2080,28 +2068,11 @@ fn comptimeExpr2(
20802068 if (token_tags[lbrace - 1] == .colon and
20812069 token_tags[lbrace - 2] == .identifier)
20822070 {
2083 const node_datas = tree.nodes.items(.data);
2084 switch (node_tags[node]) {
2085 .block_two, .block_two_semicolon => {
2086 const stmts: [2]Ast.Node.Index = .{ node_datas[node].lhs, node_datas[node].rhs };
2087 const stmt_slice = if (stmts[0] == 0)
2088 stmts[0..0]
2089 else if (stmts[1] == 0)
2090 stmts[0..1]
2091 else
2092 stmts[0..2];
2093
2094 const block_ref = try labeledBlockExpr(gz, scope, ty_only_ri, node, stmt_slice, true, .normal);
2095 return rvalue(gz, ri, block_ref, node);
2096 },
2097 .block, .block_semicolon => {
2098 const stmts = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
2099 // Replace result location and copy back later - see above.
2100 const block_ref = try labeledBlockExpr(gz, scope, ty_only_ri, node, stmts, true, .normal);
2101 return rvalue(gz, ri, block_ref, node);
2102 },
2103 else => unreachable,
2104 }
2071 var buf: [2]Ast.Node.Index = undefined;
2072 const stmts = tree.blockStatements(&buf, node).?;
2073 // Replace result location and copy back later - see above.
2074 const block_ref = try labeledBlockExpr(gz, scope, ty_only_ri, node, stmts, true, .normal);
2075 return rvalue(gz, ri, block_ref, node);
21052076 }
21062077 },
21072078
......@@ -2402,25 +2373,10 @@ fn fullBodyExpr(
24022373 block_kind: BlockKind,
24032374) InnerError!Zir.Inst.Ref {
24042375 const tree = gz.astgen.tree;
2405 const node_tags = tree.nodes.items(.tag);
2406 const node_datas = tree.nodes.items(.data);
24072376 const main_tokens = tree.nodes.items(.main_token);
24082377 const token_tags = tree.tokens.items(.tag);
24092378 var stmt_buf: [2]Ast.Node.Index = undefined;
2410 const statements: []const Ast.Node.Index = switch (node_tags[node]) {
2411 else => return expr(gz, scope, ri, node),
2412 .block_two, .block_two_semicolon => if (node_datas[node].lhs == 0) s: {
2413 break :s &.{};
2414 } else if (node_datas[node].rhs == 0) s: {
2415 stmt_buf[0] = node_datas[node].lhs;
2416 break :s stmt_buf[0..1];
2417 } else s: {
2418 stmt_buf[0] = node_datas[node].lhs;
2419 stmt_buf[1] = node_datas[node].rhs;
2420 break :s stmt_buf[0..2];
2421 },
2422 .block, .block_semicolon => tree.extra_data[node_datas[node].lhs..node_datas[node].rhs],
2423 };
2379 const statements = tree.blockStatements(&stmt_buf, node).?;
24242380
24252381 const lbrace = main_tokens[node];
24262382 if (token_tags[lbrace - 1] == .colon and
......@@ -2671,33 +2627,23 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const Ast.Nod
26712627
26722628 .for_simple,
26732629 .@"for", => _ = try forExpr(gz, scope, .{ .rl = .none }, inner_node, tree.fullFor(inner_node).?, true),
2630 // zig fmt: on
26742631
26752632 // These cases are here to allow branch hints.
2676 .builtin_call_two, .builtin_call_two_comma => {
2677 try emitDbgNode(gz, inner_node);
2678 const ri: ResultInfo = .{ .rl = .none };
2679 const result = if (node_data[inner_node].lhs == 0) r: {
2680 break :r try builtinCall(gz, scope, ri, inner_node, &.{}, allow_branch_hint);
2681 } else if (node_data[inner_node].rhs == 0) r: {
2682 break :r try builtinCall(gz, scope, ri, inner_node, &.{node_data[inner_node].lhs}, allow_branch_hint);
2683 } else r: {
2684 break :r try builtinCall(gz, scope, ri, inner_node, &.{
2685 node_data[inner_node].lhs,
2686 node_data[inner_node].rhs,
2687 }, allow_branch_hint);
2688 };
2689 noreturn_src_node = try addEnsureResult(gz, result, inner_node);
2690 },
2691 .builtin_call, .builtin_call_comma => {
2633 .builtin_call_two,
2634 .builtin_call_two_comma,
2635 .builtin_call,
2636 .builtin_call_comma,
2637 => {
2638 var buf: [2]Ast.Node.Index = undefined;
2639 const params = tree.builtinCallParams(&buf, inner_node).?;
2640
26922641 try emitDbgNode(gz, inner_node);
2693 const ri: ResultInfo = .{ .rl = .none };
2694 const params = tree.extra_data[node_data[inner_node].lhs..node_data[inner_node].rhs];
2695 const result = try builtinCall(gz, scope, ri, inner_node, params, allow_branch_hint);
2642 const result = try builtinCall(gz, scope, .{ .rl = .none }, inner_node, params, allow_branch_hint);
26962643 noreturn_src_node = try addEnsureResult(gz, result, inner_node);
26972644 },
26982645
26992646 else => noreturn_src_node = try unusedResultExpr(gz, scope, inner_node),
2700 // zig fmt: on
27012647 }
27022648 break;
27032649 }
......@@ -9194,13 +9140,14 @@ fn ptrCast(
91949140 else => break,
91959141 }
91969142
9197 if (node_datas[node].lhs == 0) break; // 0 args
9143 var buf: [2]Ast.Node.Index = undefined;
9144 const args = tree.builtinCallParams(&buf, node).?;
9145 std.debug.assert(args.len <= 2);
91989146
91999147 const builtin_token = main_tokens[node];
92009148 const builtin_name = tree.tokenSlice(builtin_token);
92019149 const info = BuiltinFn.list.get(builtin_name) orelse break;
9202 if (node_datas[node].rhs == 0) {
9203 // 1 arg
9150 if (args.len == 1) {
92049151 if (info.param_count != 1) break;
92059152
92069153 switch (info.tag) {
......@@ -9218,9 +9165,9 @@ fn ptrCast(
92189165 },
92199166 }
92209167
9221 node = node_datas[node].lhs;
9168 node = args[0];
92229169 } else {
9223 // 2 args
9170 std.debug.assert(args.len == 2);
92249171 if (info.param_count != 2) break;
92259172
92269173 switch (info.tag) {
......@@ -9231,8 +9178,8 @@ fn ptrCast(
92319178 const flags_int: FlagsInt = @bitCast(flags);
92329179 const cursor = maybeAdvanceSourceCursorToMainToken(gz, root_node);
92339180 const parent_ptr_type = try ri.rl.resultTypeForCast(gz, root_node, "@alignCast");
9234 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, node_datas[node].lhs, .field_name);
9235 const field_ptr = try expr(gz, scope, .{ .rl = .none }, node_datas[node].rhs);
9181 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, args[0], .field_name);
9182 const field_ptr = try expr(gz, scope, .{ .rl = .none }, args[1]);
92369183 try emitDbgStmt(gz, cursor);
92379184 const result = try gz.addExtendedPayloadSmall(.field_parent_ptr, flags_int, Zir.Inst.FieldParentPtr{
92389185 .src_node = gz.nodeIndexToRelative(node),
lib/std/zig/AstRlAnnotate.zig+14-22
......@@ -313,17 +313,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI
313313 .error_set_decl,
314314 => return false,
315315
316 .builtin_call_two, .builtin_call_two_comma => {
317 if (node_datas[node].lhs == 0) {
318 return astrl.builtinCall(block, ri, node, &.{});
319 } else if (node_datas[node].rhs == 0) {
320 return astrl.builtinCall(block, ri, node, &.{node_datas[node].lhs});
321 } else {
322 return astrl.builtinCall(block, ri, node, &.{ node_datas[node].lhs, node_datas[node].rhs });
323 }
324 },
325 .builtin_call, .builtin_call_comma => {
326 const params = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
316 .builtin_call_two,
317 .builtin_call_two_comma,
318 .builtin_call,
319 .builtin_call_comma,
320 => {
321 var buf: [2]Ast.Node.Index = undefined;
322 const params = tree.builtinCallParams(&buf, node).?;
327323 return astrl.builtinCall(block, ri, node, params);
328324 },
329325
......@@ -499,17 +495,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI
499495 .unwrap_optional,
500496 => return astrl.expr(node_datas[node].lhs, block, ri),
501497
502 .block_two, .block_two_semicolon => {
503 if (node_datas[node].lhs == 0) {
504 return astrl.blockExpr(block, ri, node, &.{});
505 } else if (node_datas[node].rhs == 0) {
506 return astrl.blockExpr(block, ri, node, &.{node_datas[node].lhs});
507 } else {
508 return astrl.blockExpr(block, ri, node, &.{ node_datas[node].lhs, node_datas[node].rhs });
509 }
510 },
511 .block, .block_semicolon => {
512 const statements = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
498 .block_two,
499 .block_two_semicolon,
500 .block,
501 .block_semicolon,
502 => {
503 var buf: [2]Ast.Node.Index = undefined;
504 const statements = tree.blockStatements(&buf, node).?;
513505 return astrl.blockExpr(block, ri, node, statements);
514506 },
515507 .anyframe_type => {
lib/std/zig/render.zig+10-42
......@@ -141,7 +141,6 @@ fn renderMember(
141141) Error!void {
142142 const tree = r.tree;
143143 const ais = r.ais;
144 const node_tags = tree.nodes.items(.tag);
145144 const token_tags = tree.tokens.items(.tag);
146145 const main_tokens = tree.nodes.items(.main_token);
147146 const datas = tree.nodes.items(.data);
......@@ -223,25 +222,7 @@ fn renderMember(
223222 }
224223 }
225224 var statements_buf: [2]Ast.Node.Index = undefined;
226 const statements = switch (node_tags[body_node]) {
227 .block_two,
228 .block_two_semicolon,
229 => b: {
230 statements_buf = .{ datas[body_node].lhs, datas[body_node].rhs };
231 if (datas[body_node].lhs == 0) {
232 break :b statements_buf[0..0];
233 } else if (datas[body_node].rhs == 0) {
234 break :b statements_buf[0..1];
235 } else {
236 break :b statements_buf[0..2];
237 }
238 },
239 .block,
240 .block_semicolon,
241 => tree.extra_data[datas[body_node].lhs..datas[body_node].rhs],
242
243 else => unreachable,
244 };
225 const statements = tree.blockStatements(&statements_buf, body_node).?;
245226 return finishRenderBlock(r, body_node, statements, space);
246227 } else {
247228 return renderExpression(r, body_node, space);
......@@ -394,20 +375,11 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
394375
395376 .block_two,
396377 .block_two_semicolon,
397 => {
398 const statements = [2]Ast.Node.Index{ datas[node].lhs, datas[node].rhs };
399 if (datas[node].lhs == 0) {
400 return renderBlock(r, node, statements[0..0], space);
401 } else if (datas[node].rhs == 0) {
402 return renderBlock(r, node, statements[0..1], space);
403 } else {
404 return renderBlock(r, node, statements[0..2], space);
405 }
406 },
407378 .block,
408379 .block_semicolon,
409380 => {
410 const statements = tree.extra_data[datas[node].lhs..datas[node].rhs];
381 var buf: [2]Ast.Node.Index = undefined;
382 const statements = tree.blockStatements(&buf, node).?;
411383 return renderBlock(r, node, statements, space);
412384 },
413385
......@@ -813,17 +785,13 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
813785 }
814786 },
815787
816 .builtin_call_two, .builtin_call_two_comma => {
817 if (datas[node].lhs == 0) {
818 return renderBuiltinCall(r, main_tokens[node], &.{}, space);
819 } else if (datas[node].rhs == 0) {
820 return renderBuiltinCall(r, main_tokens[node], &.{datas[node].lhs}, space);
821 } else {
822 return renderBuiltinCall(r, main_tokens[node], &.{ datas[node].lhs, datas[node].rhs }, space);
823 }
824 },
825 .builtin_call, .builtin_call_comma => {
826 const params = tree.extra_data[datas[node].lhs..datas[node].rhs];
788 .builtin_call_two,
789 .builtin_call_two_comma,
790 .builtin_call,
791 .builtin_call_comma,
792 => {
793 var buf: [2]Ast.Node.Index = undefined;
794 const params = tree.builtinCallParams(&buf, node).?;
827795 return renderBuiltinCall(r, main_tokens[node], params, space);
828796 },
829797
src/Zcu.zig+6-19
......@@ -1162,19 +1162,10 @@ pub const SrcLoc = struct {
11621162 },
11631163 .node_offset_builtin_call_arg => |builtin_arg| {
11641164 const tree = try src_loc.file_scope.getTree(gpa);
1165 const node_datas = tree.nodes.items(.data);
1166 const node_tags = tree.nodes.items(.tag);
11671165 const node = src_loc.relativeToNodeIndex(builtin_arg.builtin_call_node);
1168 const param = switch (node_tags[node]) {
1169 .builtin_call_two, .builtin_call_two_comma => switch (builtin_arg.arg_index) {
1170 0 => node_datas[node].lhs,
1171 1 => node_datas[node].rhs,
1172 else => unreachable,
1173 },
1174 .builtin_call, .builtin_call_comma => tree.extra_data[node_datas[node].lhs + builtin_arg.arg_index],
1175 else => unreachable,
1176 };
1177 return tree.nodeToSpan(param);
1166 var buf: [2]Ast.Node.Index = undefined;
1167 const params = tree.builtinCallParams(&buf, node).?;
1168 return tree.nodeToSpan(params[builtin_arg.arg_index]);
11781169 },
11791170 .node_offset_ptrcast_operand => |node_off| {
11801171 const tree = try src_loc.file_scope.getTree(gpa);
......@@ -1855,14 +1846,10 @@ pub const SrcLoc = struct {
18551846 else => unreachable,
18561847 };
18571848 const tree = try src_loc.file_scope.getTree(gpa);
1858 const node_datas = tree.nodes.items(.data);
1859 const node_tags = tree.nodes.items(.tag);
18601849 const node = src_loc.relativeToNodeIndex(builtin_call_node);
1861 const arg_node = switch (node_tags[node]) {
1862 .builtin_call_two, .builtin_call_two_comma => node_datas[node].rhs,
1863 .builtin_call, .builtin_call_comma => tree.extra_data[node_datas[node].lhs + 1],
1864 else => unreachable,
1865 };
1850 var builtin_buf: [2]Ast.Node.Index = undefined;
1851 const args = tree.builtinCallParams(&builtin_buf, node).?;
1852 const arg_node = args[1];
18661853 var buf: [2]Ast.Node.Index = undefined;
18671854 const full = tree.fullStructInit(&buf, arg_node) orelse
18681855 return tree.nodeToSpan(arg_node);