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 {...@@ -230,20 +230,11 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
230230
231 .block_two,231 .block_two,
232 .block_two_semicolon,232 .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 },
243 .block,233 .block,
244 .block_semicolon,234 .block_semicolon,
245 => {235 => {
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).?;
247 return walkBlock(w, node, statements);238 return walkBlock(w, node, statements);
248 },239 },
249240
...@@ -506,17 +497,13 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {...@@ -506,17 +497,13 @@ fn walkExpression(w: *Walk, node: Ast.Node.Index) Error!void {
506 }497 }
507 },498 },
508499
509 .builtin_call_two, .builtin_call_two_comma => {500 .builtin_call_two,
510 if (datas[node].lhs == 0) {501 .builtin_call_two_comma,
511 return walkBuiltinCall(w, node, &.{});502 .builtin_call,
512 } else if (datas[node].rhs == 0) {503 .builtin_call_comma,
513 return walkBuiltinCall(w, node, &.{datas[node].lhs});504 => {
514 } else {505 var buf: [2]Ast.Node.Index = undefined;
515 return walkBuiltinCall(w, node, &.{ datas[node].lhs, datas[node].rhs });506 const params = ast.builtinCallParams(&buf, node).?;
516 }
517 },
518 .builtin_call, .builtin_call_comma => {
519 const params = ast.extra_data[datas[node].lhs..datas[node].rhs];
520 return walkBuiltinCall(w, node, params);507 return walkBuiltinCall(w, node, params);
521 },508 },
522509
...@@ -972,24 +959,13 @@ fn walkParamList(w: *Walk, params: []const Ast.Node.Index) Error!void {...@@ -972,24 +959,13 @@ fn walkParamList(w: *Walk, params: []const Ast.Node.Index) Error!void {
972fn isFnBodyGutted(ast: *const Ast, body_node: Ast.Node.Index) bool {959fn isFnBodyGutted(ast: *const Ast, body_node: Ast.Node.Index) bool {
973 // skip over discards960 // skip over discards
974 const node_tags = ast.nodes.items(.tag);961 const node_tags = ast.nodes.items(.tag);
975 const datas = ast.nodes.items(.data);
976 var statements_buf: [2]Ast.Node.Index = undefined;962 var statements_buf: [2]Ast.Node.Index = undefined;
977 const statements = switch (node_tags[body_node]) {963 const statements = switch (node_tags[body_node]) {
978 .block_two,964 .block_two,
979 .block_two_semicolon,965 .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
990 .block,966 .block,
991 .block_semicolon,967 .block_semicolon,
992 => ast.extra_data[datas[body_node].lhs..datas[body_node].rhs],968 => ast.blockStatements(&statements_buf, body_node).?,
993969
994 else => return false,970 else => return false,
995 };971 };
...@@ -1016,17 +992,13 @@ fn categorizeStmt(ast: *const Ast, stmt: Ast.Node.Index) StmtCategory {...@@ -1016,17 +992,13 @@ fn categorizeStmt(ast: *const Ast, stmt: Ast.Node.Index) StmtCategory {
1016 const datas = ast.nodes.items(.data);992 const datas = ast.nodes.items(.data);
1017 const main_tokens = ast.nodes.items(.main_token);993 const main_tokens = ast.nodes.items(.main_token);
1018 switch (node_tags[stmt]) {994 switch (node_tags[stmt]) {
1019 .builtin_call_two, .builtin_call_two_comma => {995 .builtin_call_two,
1020 if (datas[stmt].lhs == 0) {996 .builtin_call_two_comma,
1021 return categorizeBuiltinCall(ast, main_tokens[stmt], &.{});997 .builtin_call,
1022 } else if (datas[stmt].rhs == 0) {998 .builtin_call_comma,
1023 return categorizeBuiltinCall(ast, main_tokens[stmt], &.{datas[stmt].lhs});999 => {
1024 } else {1000 var buf: [2]Ast.Node.Index = undefined;
1025 return categorizeBuiltinCall(ast, main_tokens[stmt], &.{ datas[stmt].lhs, datas[stmt].rhs });1001 const params = ast.builtinCallParams(&buf, stmt).?;
1026 }
1027 },
1028 .builtin_call, .builtin_call_comma => {
1029 const params = ast.extra_data[datas[stmt].lhs..datas[stmt].rhs];
1030 return categorizeBuiltinCall(ast, main_tokens[stmt], params);1002 return categorizeBuiltinCall(ast, main_tokens[stmt], params);
1031 },1003 },
1032 .assign => {1004 .assign => {
lib/docs/wasm/Walk.zig+21-40
...@@ -232,20 +232,13 @@ pub const File = struct {...@@ -232,20 +232,13 @@ pub const File = struct {
232 return .{ .global_const = node };232 return .{ .global_const = node };
233 },233 },
234234
235 .builtin_call_two, .builtin_call_two_comma => {235 .builtin_call_two,
236 if (node_datas[node].lhs == 0) {236 .builtin_call_two_comma,
237 const params = [_]Ast.Node.Index{};237 .builtin_call,
238 return categorize_builtin_call(file_index, node, &params);238 .builtin_call_comma,
239 } else if (node_datas[node].rhs == 0) {239 => {
240 const params = [_]Ast.Node.Index{node_datas[node].lhs};240 var buf: [2]Ast.Node.Index = undefined;
241 return categorize_builtin_call(file_index, node, &params);241 const params = ast.builtinCallParams(&buf, node).?;
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];
249 return categorize_builtin_call(file_index, node, params);242 return categorize_builtin_call(file_index, node, params);
250 },243 },
251244
...@@ -818,20 +811,13 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)...@@ -818,20 +811,13 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
818 try expr(w, scope, parent_decl, full.ast.template);811 try expr(w, scope, parent_decl, full.ast.template);
819 },812 },
820813
821 .builtin_call_two, .builtin_call_two_comma => {814 .builtin_call_two,
822 if (node_datas[node].lhs == 0) {815 .builtin_call_two_comma,
823 const params = [_]Ast.Node.Index{};816 .builtin_call,
824 return builtin_call(w, scope, parent_decl, node, &params);817 .builtin_call_comma,
825 } else if (node_datas[node].rhs == 0) {818 => {
826 const params = [_]Ast.Node.Index{node_datas[node].lhs};819 var buf: [2]Ast.Node.Index = undefined;
827 return builtin_call(w, scope, parent_decl, node, &params);820 const params = ast.builtinCallParams(&buf, node).?;
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];
835 return builtin_call(w, scope, parent_decl, node, params);821 return builtin_call(w, scope, parent_decl, node, params);
836 },822 },
837823
...@@ -886,18 +872,13 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)...@@ -886,18 +872,13 @@ fn expr(w: *Walk, scope: *Scope, parent_decl: Decl.Index, node: Ast.Node.Index)
886 .slice_open => return slice(w, scope, parent_decl, ast.sliceOpen(node)),872 .slice_open => return slice(w, scope, parent_decl, ast.sliceOpen(node)),
887 .slice_sentinel => return slice(w, scope, parent_decl, ast.sliceSentinel(node)),873 .slice_sentinel => return slice(w, scope, parent_decl, ast.sliceSentinel(node)),
888874
889 .block_two, .block_two_semicolon => {875 .block_two,
890 const statements = [2]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };876 .block_two_semicolon,
891 if (node_datas[node].lhs == 0) {877 .block,
892 return block(w, scope, parent_decl, statements[0..0]);878 .block_semicolon,
893 } else if (node_datas[node].rhs == 0) {879 => {
894 return block(w, scope, parent_decl, statements[0..1]);880 var buf: [2]Ast.Node.Index = undefined;
895 } else {881 const statements = ast.blockStatements(&buf, node).?;
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];
901 return block(w, scope, parent_decl, statements);882 return block(w, scope, parent_decl, statements);
902 },883 },
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...@@ -2432,6 +2432,42 @@ pub fn fullCall(tree: Ast, buffer: *[1]Ast.Node.Index, node: Node.Index) ?full.C
2432 };2432 };
2433}2433}
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
2435/// Fully assembled AST node information.2471/// Fully assembled AST node information.
2436pub const full = struct {2472pub const full = struct {
2437 pub const VarDecl = struct {2473 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...@@ -824,20 +824,13 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
824 .number_literal => return numberLiteral(gz, ri, node, node, .positive),824 .number_literal => return numberLiteral(gz, ri, node, node, .positive),
825 // zig fmt: on825 // zig fmt: on
826826
827 .builtin_call_two, .builtin_call_two_comma => {827 .builtin_call_two,
828 if (node_datas[node].lhs == 0) {828 .builtin_call_two_comma,
829 const params = [_]Ast.Node.Index{};829 .builtin_call,
830 return builtinCall(gz, scope, ri, node, &params, false);830 .builtin_call_comma,
831 } else if (node_datas[node].rhs == 0) {831 => {
832 const params = [_]Ast.Node.Index{node_datas[node].lhs};832 var buf: [2]Ast.Node.Index = undefined;
833 return builtinCall(gz, scope, ri, node, &params, false);833 const params = tree.builtinCallParams(&buf, node).?;
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];
841 return builtinCall(gz, scope, ri, node, params, false);834 return builtinCall(gz, scope, ri, node, params, false);
842 },835 },
843836
...@@ -991,18 +984,13 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE...@@ -991,18 +984,13 @@ fn expr(gz: *GenZir, scope: *Scope, ri: ResultInfo, node: Ast.Node.Index) InnerE
991 return rvalue(gz, ri, try gz.addUnNode(.optional_payload_safe, lhs, node), node);984 return rvalue(gz, ri, try gz.addUnNode(.optional_payload_safe, lhs, node), node);
992 },985 },
993 },986 },
994 .block_two, .block_two_semicolon => {987 .block_two,
995 const statements = [2]Ast.Node.Index{ node_datas[node].lhs, node_datas[node].rhs };988 .block_two_semicolon,
996 if (node_datas[node].lhs == 0) {989 .block,
997 return blockExpr(gz, scope, ri, node, statements[0..0], .normal);990 .block_semicolon,
998 } else if (node_datas[node].rhs == 0) {991 => {
999 return blockExpr(gz, scope, ri, node, statements[0..1], .normal);992 var buf: [2]Ast.Node.Index = undefined;
1000 } else {993 const statements = tree.blockStatements(&buf, node).?;
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];
1006 return blockExpr(gz, scope, ri, node, statements, .normal);994 return blockExpr(gz, scope, ri, node, statements, .normal);
1007 },995 },
1008 .enum_literal => if (try ri.rl.resultType(gz, node)) |res_ty| {996 .enum_literal => if (try ri.rl.resultType(gz, node)) |res_ty| {
...@@ -2080,28 +2068,11 @@ fn comptimeExpr2(...@@ -2080,28 +2068,11 @@ fn comptimeExpr2(
2080 if (token_tags[lbrace - 1] == .colon and2068 if (token_tags[lbrace - 1] == .colon and
2081 token_tags[lbrace - 2] == .identifier)2069 token_tags[lbrace - 2] == .identifier)
2082 {2070 {
2083 const node_datas = tree.nodes.items(.data);2071 var buf: [2]Ast.Node.Index = undefined;
2084 switch (node_tags[node]) {2072 const stmts = tree.blockStatements(&buf, node).?;
2085 .block_two, .block_two_semicolon => {2073 // Replace result location and copy back later - see above.
2086 const stmts: [2]Ast.Node.Index = .{ node_datas[node].lhs, node_datas[node].rhs };2074 const block_ref = try labeledBlockExpr(gz, scope, ty_only_ri, node, stmts, true, .normal);
2087 const stmt_slice = if (stmts[0] == 0)2075 return rvalue(gz, ri, block_ref, node);
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 }
2105 }2076 }
2106 },2077 },
21072078
...@@ -2402,25 +2373,10 @@ fn fullBodyExpr(...@@ -2402,25 +2373,10 @@ fn fullBodyExpr(
2402 block_kind: BlockKind,2373 block_kind: BlockKind,
2403) InnerError!Zir.Inst.Ref {2374) InnerError!Zir.Inst.Ref {
2404 const tree = gz.astgen.tree;2375 const tree = gz.astgen.tree;
2405 const node_tags = tree.nodes.items(.tag);
2406 const node_datas = tree.nodes.items(.data);
2407 const main_tokens = tree.nodes.items(.main_token);2376 const main_tokens = tree.nodes.items(.main_token);
2408 const token_tags = tree.tokens.items(.tag);2377 const token_tags = tree.tokens.items(.tag);
2409 var stmt_buf: [2]Ast.Node.Index = undefined;2378 var stmt_buf: [2]Ast.Node.Index = undefined;
2410 const statements: []const Ast.Node.Index = switch (node_tags[node]) {2379 const statements = tree.blockStatements(&stmt_buf, 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 };
24242380
2425 const lbrace = main_tokens[node];2381 const lbrace = main_tokens[node];
2426 if (token_tags[lbrace - 1] == .colon and2382 if (token_tags[lbrace - 1] == .colon and
...@@ -2671,33 +2627,23 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const Ast.Nod...@@ -2671,33 +2627,23 @@ fn blockExprStmts(gz: *GenZir, parent_scope: *Scope, statements: []const Ast.Nod
26712627
2672 .for_simple,2628 .for_simple,
2673 .@"for", => _ = try forExpr(gz, scope, .{ .rl = .none }, inner_node, tree.fullFor(inner_node).?, true),2629 .@"for", => _ = try forExpr(gz, scope, .{ .rl = .none }, inner_node, tree.fullFor(inner_node).?, true),
2630 // zig fmt: on
26742631
2675 // These cases are here to allow branch hints.2632 // These cases are here to allow branch hints.
2676 .builtin_call_two, .builtin_call_two_comma => {2633 .builtin_call_two,
2677 try emitDbgNode(gz, inner_node);2634 .builtin_call_two_comma,
2678 const ri: ResultInfo = .{ .rl = .none };2635 .builtin_call,
2679 const result = if (node_data[inner_node].lhs == 0) r: {2636 .builtin_call_comma,
2680 break :r try builtinCall(gz, scope, ri, inner_node, &.{}, allow_branch_hint);2637 => {
2681 } else if (node_data[inner_node].rhs == 0) r: {2638 var buf: [2]Ast.Node.Index = undefined;
2682 break :r try builtinCall(gz, scope, ri, inner_node, &.{node_data[inner_node].lhs}, allow_branch_hint);2639 const params = tree.builtinCallParams(&buf, inner_node).?;
2683 } else r: {2640
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 => {
2692 try emitDbgNode(gz, inner_node);2641 try emitDbgNode(gz, inner_node);
2693 const ri: ResultInfo = .{ .rl = .none };2642 const result = try builtinCall(gz, scope, .{ .rl = .none }, inner_node, params, allow_branch_hint);
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);
2696 noreturn_src_node = try addEnsureResult(gz, result, inner_node);2643 noreturn_src_node = try addEnsureResult(gz, result, inner_node);
2697 },2644 },
26982645
2699 else => noreturn_src_node = try unusedResultExpr(gz, scope, inner_node),2646 else => noreturn_src_node = try unusedResultExpr(gz, scope, inner_node),
2700 // zig fmt: on
2701 }2647 }
2702 break;2648 break;
2703 }2649 }
...@@ -9194,13 +9140,14 @@ fn ptrCast(...@@ -9194,13 +9140,14 @@ fn ptrCast(
9194 else => break,9140 else => break,
9195 }9141 }
91969142
9197 if (node_datas[node].lhs == 0) break; // 0 args9143 var buf: [2]Ast.Node.Index = undefined;
9144 const args = tree.builtinCallParams(&buf, node).?;
9145 std.debug.assert(args.len <= 2);
91989146
9199 const builtin_token = main_tokens[node];9147 const builtin_token = main_tokens[node];
9200 const builtin_name = tree.tokenSlice(builtin_token);9148 const builtin_name = tree.tokenSlice(builtin_token);
9201 const info = BuiltinFn.list.get(builtin_name) orelse break;9149 const info = BuiltinFn.list.get(builtin_name) orelse break;
9202 if (node_datas[node].rhs == 0) {9150 if (args.len == 1) {
9203 // 1 arg
9204 if (info.param_count != 1) break;9151 if (info.param_count != 1) break;
92059152
9206 switch (info.tag) {9153 switch (info.tag) {
...@@ -9218,9 +9165,9 @@ fn ptrCast(...@@ -9218,9 +9165,9 @@ fn ptrCast(
9218 },9165 },
9219 }9166 }
92209167
9221 node = node_datas[node].lhs;9168 node = args[0];
9222 } else {9169 } else {
9223 // 2 args9170 std.debug.assert(args.len == 2);
9224 if (info.param_count != 2) break;9171 if (info.param_count != 2) break;
92259172
9226 switch (info.tag) {9173 switch (info.tag) {
...@@ -9231,8 +9178,8 @@ fn ptrCast(...@@ -9231,8 +9178,8 @@ fn ptrCast(
9231 const flags_int: FlagsInt = @bitCast(flags);9178 const flags_int: FlagsInt = @bitCast(flags);
9232 const cursor = maybeAdvanceSourceCursorToMainToken(gz, root_node);9179 const cursor = maybeAdvanceSourceCursorToMainToken(gz, root_node);
9233 const parent_ptr_type = try ri.rl.resultTypeForCast(gz, root_node, "@alignCast");9180 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);9181 const field_name = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_u8_type } }, args[0], .field_name);
9235 const field_ptr = try expr(gz, scope, .{ .rl = .none }, node_datas[node].rhs);9182 const field_ptr = try expr(gz, scope, .{ .rl = .none }, args[1]);
9236 try emitDbgStmt(gz, cursor);9183 try emitDbgStmt(gz, cursor);
9237 const result = try gz.addExtendedPayloadSmall(.field_parent_ptr, flags_int, Zir.Inst.FieldParentPtr{9184 const result = try gz.addExtendedPayloadSmall(.field_parent_ptr, flags_int, Zir.Inst.FieldParentPtr{
9238 .src_node = gz.nodeIndexToRelative(node),9185 .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...@@ -313,17 +313,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI
313 .error_set_decl,313 .error_set_decl,
314 => return false,314 => return false,
315315
316 .builtin_call_two, .builtin_call_two_comma => {316 .builtin_call_two,
317 if (node_datas[node].lhs == 0) {317 .builtin_call_two_comma,
318 return astrl.builtinCall(block, ri, node, &.{});318 .builtin_call,
319 } else if (node_datas[node].rhs == 0) {319 .builtin_call_comma,
320 return astrl.builtinCall(block, ri, node, &.{node_datas[node].lhs});320 => {
321 } else {321 var buf: [2]Ast.Node.Index = undefined;
322 return astrl.builtinCall(block, ri, node, &.{ node_datas[node].lhs, node_datas[node].rhs });322 const params = tree.builtinCallParams(&buf, node).?;
323 }
324 },
325 .builtin_call, .builtin_call_comma => {
326 const params = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
327 return astrl.builtinCall(block, ri, node, params);323 return astrl.builtinCall(block, ri, node, params);
328 },324 },
329325
...@@ -499,17 +495,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI...@@ -499,17 +495,13 @@ fn expr(astrl: *AstRlAnnotate, node: Ast.Node.Index, block: ?*Block, ri: ResultI
499 .unwrap_optional,495 .unwrap_optional,
500 => return astrl.expr(node_datas[node].lhs, block, ri),496 => return astrl.expr(node_datas[node].lhs, block, ri),
501497
502 .block_two, .block_two_semicolon => {498 .block_two,
503 if (node_datas[node].lhs == 0) {499 .block_two_semicolon,
504 return astrl.blockExpr(block, ri, node, &.{});500 .block,
505 } else if (node_datas[node].rhs == 0) {501 .block_semicolon,
506 return astrl.blockExpr(block, ri, node, &.{node_datas[node].lhs});502 => {
507 } else {503 var buf: [2]Ast.Node.Index = undefined;
508 return astrl.blockExpr(block, ri, node, &.{ node_datas[node].lhs, node_datas[node].rhs });504 const statements = tree.blockStatements(&buf, node).?;
509 }
510 },
511 .block, .block_semicolon => {
512 const statements = tree.extra_data[node_datas[node].lhs..node_datas[node].rhs];
513 return astrl.blockExpr(block, ri, node, statements);505 return astrl.blockExpr(block, ri, node, statements);
514 },506 },
515 .anyframe_type => {507 .anyframe_type => {
lib/std/zig/render.zig+10-42
...@@ -141,7 +141,6 @@ fn renderMember(...@@ -141,7 +141,6 @@ fn renderMember(
141) Error!void {141) Error!void {
142 const tree = r.tree;142 const tree = r.tree;
143 const ais = r.ais;143 const ais = r.ais;
144 const node_tags = tree.nodes.items(.tag);
145 const token_tags = tree.tokens.items(.tag);144 const token_tags = tree.tokens.items(.tag);
146 const main_tokens = tree.nodes.items(.main_token);145 const main_tokens = tree.nodes.items(.main_token);
147 const datas = tree.nodes.items(.data);146 const datas = tree.nodes.items(.data);
...@@ -223,25 +222,7 @@ fn renderMember(...@@ -223,25 +222,7 @@ fn renderMember(
223 }222 }
224 }223 }
225 var statements_buf: [2]Ast.Node.Index = undefined;224 var statements_buf: [2]Ast.Node.Index = undefined;
226 const statements = switch (node_tags[body_node]) {225 const statements = tree.blockStatements(&statements_buf, 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 };
245 return finishRenderBlock(r, body_node, statements, space);226 return finishRenderBlock(r, body_node, statements, space);
246 } else {227 } else {
247 return renderExpression(r, body_node, space);228 return renderExpression(r, body_node, space);
...@@ -394,20 +375,11 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {...@@ -394,20 +375,11 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
394375
395 .block_two,376 .block_two,
396 .block_two_semicolon,377 .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 },
407 .block,378 .block,
408 .block_semicolon,379 .block_semicolon,
409 => {380 => {
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).?;
411 return renderBlock(r, node, statements, space);383 return renderBlock(r, node, statements, space);
412 },384 },
413385
...@@ -813,17 +785,13 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {...@@ -813,17 +785,13 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
813 }785 }
814 },786 },
815787
816 .builtin_call_two, .builtin_call_two_comma => {788 .builtin_call_two,
817 if (datas[node].lhs == 0) {789 .builtin_call_two_comma,
818 return renderBuiltinCall(r, main_tokens[node], &.{}, space);790 .builtin_call,
819 } else if (datas[node].rhs == 0) {791 .builtin_call_comma,
820 return renderBuiltinCall(r, main_tokens[node], &.{datas[node].lhs}, space);792 => {
821 } else {793 var buf: [2]Ast.Node.Index = undefined;
822 return renderBuiltinCall(r, main_tokens[node], &.{ datas[node].lhs, datas[node].rhs }, space);794 const params = tree.builtinCallParams(&buf, node).?;
823 }
824 },
825 .builtin_call, .builtin_call_comma => {
826 const params = tree.extra_data[datas[node].lhs..datas[node].rhs];
827 return renderBuiltinCall(r, main_tokens[node], params, space);795 return renderBuiltinCall(r, main_tokens[node], params, space);
828 },796 },
829797
src/Zcu.zig+6-19
...@@ -1162,19 +1162,10 @@ pub const SrcLoc = struct {...@@ -1162,19 +1162,10 @@ pub const SrcLoc = struct {
1162 },1162 },
1163 .node_offset_builtin_call_arg => |builtin_arg| {1163 .node_offset_builtin_call_arg => |builtin_arg| {
1164 const tree = try src_loc.file_scope.getTree(gpa);1164 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);
1167 const node = src_loc.relativeToNodeIndex(builtin_arg.builtin_call_node);1165 const node = src_loc.relativeToNodeIndex(builtin_arg.builtin_call_node);
1168 const param = switch (node_tags[node]) {1166 var buf: [2]Ast.Node.Index = undefined;
1169 .builtin_call_two, .builtin_call_two_comma => switch (builtin_arg.arg_index) {1167 const params = tree.builtinCallParams(&buf, node).?;
1170 0 => node_datas[node].lhs,1168 return tree.nodeToSpan(params[builtin_arg.arg_index]);
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);
1178 },1169 },
1179 .node_offset_ptrcast_operand => |node_off| {1170 .node_offset_ptrcast_operand => |node_off| {
1180 const tree = try src_loc.file_scope.getTree(gpa);1171 const tree = try src_loc.file_scope.getTree(gpa);
...@@ -1855,14 +1846,10 @@ pub const SrcLoc = struct {...@@ -1855,14 +1846,10 @@ pub const SrcLoc = struct {
1855 else => unreachable,1846 else => unreachable,
1856 };1847 };
1857 const tree = try src_loc.file_scope.getTree(gpa);1848 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);
1860 const node = src_loc.relativeToNodeIndex(builtin_call_node);1849 const node = src_loc.relativeToNodeIndex(builtin_call_node);
1861 const arg_node = switch (node_tags[node]) {1850 var builtin_buf: [2]Ast.Node.Index = undefined;
1862 .builtin_call_two, .builtin_call_two_comma => node_datas[node].rhs,1851 const args = tree.builtinCallParams(&builtin_buf, node).?;
1863 .builtin_call, .builtin_call_comma => tree.extra_data[node_datas[node].lhs + 1],1852 const arg_node = args[1];
1864 else => unreachable,
1865 };
1866 var buf: [2]Ast.Node.Index = undefined;1853 var buf: [2]Ast.Node.Index = undefined;
1867 const full = tree.fullStructInit(&buf, arg_node) orelse1854 const full = tree.fullStructInit(&buf, arg_node) orelse
1868 return tree.nodeToSpan(arg_node);1855 return tree.nodeToSpan(arg_node);