authorgravatar for techatrix@mailbox.orgTechatrix <techatrix@mailbox.org> 2024-12-28 08:04:15+01:00
committergravatar for techatrix@mailbox.orgTechatrix <techatrix@mailbox.org> 2025-03-07 22:20:34+01:00
logad38af77fa8ef3fe6938365258e198696fbf53d9
tree00e4a5d103fb0b9686735d1ff953fd5c84b848a2
parent5765736867f17df63740017a2a842427f046743f
signaturebadge-check Signed by SSH key SHA256:HYC3SjXQcAt6uwv9pu/6OoVQ2rUH8rb5zKiUHSe9uxk

remove unreachable code paths from std.zig.Ast.lastToken

This function checks for various possibilities that are never produced by the parser. Given that lastToken is unsafe to call on an Ast with errors, I also removed code paths that would be reachable on an Ast with errors.

1 files changed, 15 insertions(+), 132 deletions(-)

lib/std/zig/Ast.zig+15-132
......@@ -800,7 +800,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
800800 const tags = tree.nodes.items(.tag);
801801 const datas = tree.nodes.items(.data);
802802 const main_tokens = tree.nodes.items(.main_token);
803 const token_starts = tree.tokens.items(.start);
804803 const token_tags = tree.tokens.items(.tag);
805804 var n = node;
806805 var end_offset: TokenIndex = 0;
......@@ -816,6 +815,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
816815 .@"try",
817816 .@"await",
818817 .optional_type,
818 .@"suspend",
819819 .@"resume",
820820 .@"nosuspend",
821821 .@"comptime",
......@@ -880,6 +880,9 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
880880 .for_simple,
881881 .fn_proto_simple,
882882 .fn_proto_multi,
883 .fn_proto_one,
884 .fn_proto,
885 .fn_decl,
883886 .ptr_type_aligned,
884887 .ptr_type_sentinel,
885888 .ptr_type,
......@@ -928,9 +931,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
928931 .call, .async_call => {
929932 end_offset += 1; // for the rparen
930933 const params = tree.extraData(datas[n].rhs, Node.SubRange);
931 if (params.end - params.start == 0) {
932 return main_tokens[n] + end_offset;
933 }
934 assert(params.end - params.start > 0);
934935 n = tree.extra_data[params.end - 1]; // last parameter
935936 },
936937 .tagged_union_enum_tag => {
......@@ -1122,48 +1123,28 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
11221123 n = datas[n].rhs;
11231124 } else {
11241125 const extra = tree.extraData(datas[n].lhs, Node.LocalVarDecl);
1125 if (extra.align_node != 0) {
1126 end_offset += 1; // for the rparen
1127 n = extra.align_node;
1128 } else if (extra.type_node != 0) {
1129 n = extra.type_node;
1130 } else {
1131 end_offset += 1; // from mut token to name
1132 return main_tokens[n] + end_offset;
1133 }
1126 assert(extra.align_node != 0);
1127 end_offset += 1; // for the rparen
1128 n = extra.align_node;
11341129 }
11351130 },
11361131 .container_field_init => {
11371132 if (datas[n].rhs != 0) {
11381133 n = datas[n].rhs;
1139 } else if (datas[n].lhs != 0) {
1140 n = datas[n].lhs;
11411134 } else {
1142 return main_tokens[n] + end_offset;
1135 assert(datas[n].lhs != 0);
1136 n = datas[n].lhs;
11431137 }
11441138 },
11451139 .container_field_align => {
1146 if (datas[n].rhs != 0) {
1147 end_offset += 1; // for the rparen
1148 n = datas[n].rhs;
1149 } else if (datas[n].lhs != 0) {
1150 n = datas[n].lhs;
1151 } else {
1152 return main_tokens[n] + end_offset;
1153 }
1140 assert(datas[n].rhs != 0);
1141 end_offset += 1; // for the rparen
1142 n = datas[n].rhs;
11541143 },
11551144 .container_field => {
11561145 const extra = tree.extraData(datas[n].rhs, Node.ContainerField);
1157 if (extra.value_expr != 0) {
1158 n = extra.value_expr;
1159 } else if (extra.align_expr != 0) {
1160 end_offset += 1; // for the rparen
1161 n = extra.align_expr;
1162 } else if (datas[n].lhs != 0) {
1163 n = datas[n].lhs;
1164 } else {
1165 return main_tokens[n] + end_offset;
1166 }
1146 assert(extra.value_expr != 0);
1147 n = extra.value_expr;
11671148 },
11681149
11691150 .array_init_one,
......@@ -1208,97 +1189,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
12081189 return main_tokens[n] + end_offset;
12091190 }
12101191 },
1211 .fn_decl => {
1212 if (datas[n].rhs != 0) {
1213 n = datas[n].rhs;
1214 } else {
1215 n = datas[n].lhs;
1216 }
1217 },
1218 .fn_proto_one => {
1219 const extra = tree.extraData(datas[n].lhs, Node.FnProtoOne);
1220 // addrspace, linksection, callconv, align can appear in any order, so we
1221 // find the last one here.
1222 var max_node: Node.Index = datas[n].rhs;
1223 var max_start = token_starts[main_tokens[max_node]];
1224 var max_offset: TokenIndex = 0;
1225 if (extra.align_expr != 0) {
1226 const start = token_starts[main_tokens[extra.align_expr]];
1227 if (start > max_start) {
1228 max_node = extra.align_expr;
1229 max_start = start;
1230 max_offset = 1; // for the rparen
1231 }
1232 }
1233 if (extra.addrspace_expr != 0) {
1234 const start = token_starts[main_tokens[extra.addrspace_expr]];
1235 if (start > max_start) {
1236 max_node = extra.addrspace_expr;
1237 max_start = start;
1238 max_offset = 1; // for the rparen
1239 }
1240 }
1241 if (extra.section_expr != 0) {
1242 const start = token_starts[main_tokens[extra.section_expr]];
1243 if (start > max_start) {
1244 max_node = extra.section_expr;
1245 max_start = start;
1246 max_offset = 1; // for the rparen
1247 }
1248 }
1249 if (extra.callconv_expr != 0) {
1250 const start = token_starts[main_tokens[extra.callconv_expr]];
1251 if (start > max_start) {
1252 max_node = extra.callconv_expr;
1253 max_start = start;
1254 max_offset = 1; // for the rparen
1255 }
1256 }
1257 n = max_node;
1258 end_offset += max_offset;
1259 },
1260 .fn_proto => {
1261 const extra = tree.extraData(datas[n].lhs, Node.FnProto);
1262 // addrspace, linksection, callconv, align can appear in any order, so we
1263 // find the last one here.
1264 var max_node: Node.Index = datas[n].rhs;
1265 var max_start = token_starts[main_tokens[max_node]];
1266 var max_offset: TokenIndex = 0;
1267 if (extra.align_expr != 0) {
1268 const start = token_starts[main_tokens[extra.align_expr]];
1269 if (start > max_start) {
1270 max_node = extra.align_expr;
1271 max_start = start;
1272 max_offset = 1; // for the rparen
1273 }
1274 }
1275 if (extra.addrspace_expr != 0) {
1276 const start = token_starts[main_tokens[extra.addrspace_expr]];
1277 if (start > max_start) {
1278 max_node = extra.addrspace_expr;
1279 max_start = start;
1280 max_offset = 1; // for the rparen
1281 }
1282 }
1283 if (extra.section_expr != 0) {
1284 const start = token_starts[main_tokens[extra.section_expr]];
1285 if (start > max_start) {
1286 max_node = extra.section_expr;
1287 max_start = start;
1288 max_offset = 1; // for the rparen
1289 }
1290 }
1291 if (extra.callconv_expr != 0) {
1292 const start = token_starts[main_tokens[extra.callconv_expr]];
1293 if (start > max_start) {
1294 max_node = extra.callconv_expr;
1295 max_start = start;
1296 max_offset = 1; // for the rparen
1297 }
1298 }
1299 n = max_node;
1300 end_offset += max_offset;
1301 },
13021192 .while_cont => {
13031193 const extra = tree.extraData(datas[n].rhs, Node.WhileCont);
13041194 assert(extra.then_expr != 0);
......@@ -1318,13 +1208,6 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex {
13181208 const extra = @as(Node.For, @bitCast(datas[n].rhs));
13191209 n = tree.extra_data[datas[n].lhs + extra.inputs + @intFromBool(extra.has_else)];
13201210 },
1321 .@"suspend" => {
1322 if (datas[n].lhs != 0) {
1323 n = datas[n].lhs;
1324 } else {
1325 return main_tokens[n] + end_offset;
1326 }
1327 },
13281211 .array_type_sentinel => {
13291212 const extra = tree.extraData(datas[n].rhs, Node.ArrayTypeSentinel);
13301213 n = extra.elem_type;