authorgravatar for vallahor91@gmail.comVallahor <vallahor91@gmail.com> 2022-06-02 22:33:28-03:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-07-19 19:10:12-07:00
log9613aca417e5cc97ee17bc3f4e5036a8438e7673
tree679e501eaa03a6e6fa255692d8ae0beb2d266443
parent918475e2e2fbaf840653b23b59d3e014fcdc7b99

autodoc: refactoring binOp

2 files changed, 182 insertions(+), 1095 deletions(-)

lib/docs/main.js+93-81
......@@ -1114,22 +1114,14 @@ var zigAnalysis;
11141114 return exprName(sliceIndex, opts);
11151115 }
11161116 case "switchOp":{
1117 let payloadHtml = "switch() {</br>";
1118 for (let i = 0; i < expr.switchOp.cases.length; i++) {
1119 const caseIndex = expr.switchOp.cases[i];
1120 const item = zigAnalysis.exprs[caseIndex];
1121 if (item['enumLiteral']) {
1122 payloadHtml += " " + " ." + exprName(item, opts) + " => {} " + "</br>";
1123 continue;
1124 }
1125 payloadHtml += " " + exprName(item, opts) + " => {} " + "</br>";
1126 }
1127 if (expr.switchOp.else_index !== 0) {
1128 const else_index = expr.switchOp.else_index;
1129 const item = zigAnalysis.exprs[else_index];
1130 payloadHtml += " " + "else" + " => {} " + "</br>";
1131 }
1132 payloadHtml += "}";
1117 let condExpr = zigAnalysis.exprs[expr.switchOp.cond_index];
1118 let node_name_ = expr.switchOp.node_name;
1119 let file_name = expr.switchOp.file_name;
1120 let line_start = expr.switchOp.line_start;
1121 let payloadHtml = "";
1122 let cond = exprName(condExpr, opts);
1123 payloadHtml += "</br>" + "node_name: " + node_name_ + "</br>" + "file: " + file_name + "</br>" + "line_start: " + line_start + "</br>";
1124 payloadHtml += "switch(" + cond + ") {...}";
11331125 return payloadHtml;
11341126 }
11351127 case "switchIndex": {
......@@ -1279,7 +1271,6 @@ var zigAnalysis;
12791271 }
12801272 case "builtinBinIndex" : {
12811273 const builtinBinIndex = zigAnalysis.exprs[expr.builtinBinIndex];
1282 console.log(expr)
12831274 return exprName(builtinBinIndex, opts);
12841275 }
12851276 case "builtinBin": {
......@@ -1288,8 +1279,6 @@ var zigAnalysis;
12881279 let lhs = exprName(lhsOp, opts);
12891280 let rhs = exprName(rhsOp, opts);
12901281
1291 console.log(expr);
1292
12931282 let payloadHtml = "@";
12941283 switch (expr.builtinBin.name) {
12951284 case "float_to_int": {
......@@ -1356,6 +1345,50 @@ var zigAnalysis;
13561345 payloadHtml += "bitReverse";
13571346 break;
13581347 }
1348 case "div_exact": {
1349 payloadHtml += "divExact";
1350 break;
1351 }
1352 case "div_floor": {
1353 payloadHtml += "divFloor";
1354 break;
1355 }
1356 case "div_trunc": {
1357 payloadHtml += "divTrunc";
1358 break;
1359 }
1360 case "mod": {
1361 payloadHtml += "mod";
1362 break;
1363 }
1364 case "rem": {
1365 payloadHtml += "rem";
1366 break;
1367 }
1368 case "mod_rem": {
1369 payloadHtml += "rem";
1370 break;
1371 }
1372 case "shl_exact": {
1373 payloadHtml += "shlExact";
1374 break;
1375 }
1376 case "shr_exact": {
1377 payloadHtml += "shrExact";
1378 break;
1379 }
1380 case "bitcast" : {
1381 payloadHtml += "bitCast";
1382 break;
1383 }
1384 case "align_cast" : {
1385 payloadHtml += "alignCast";
1386 break;
1387 }
1388 case "vector_type" : {
1389 payloadHtml += "Vector";
1390 break;
1391 }
13591392 default: console.log("builtin function not handled yet or doesn't exist!");
13601393 };
13611394 return payloadHtml + "(" + lhs + ", " + rhs + ")";
......@@ -1386,97 +1419,79 @@ var zigAnalysis;
13861419 }
13871420
13881421 let operator = "";
1389 // binOp.kind is described at Autodoc.zig
1390 // Expr section in BinOp struct
1391 switch (expr.binOp.opKind) {
1392 case 0: {
1422
1423 switch (expr.binOp.name) {
1424 case "add": {
13931425 operator += "+";
13941426 break;
13951427 }
1396 case 1: {
1428 case "addwrap": {
1429 operator += "+%";
1430 break;
1431 }
1432 case "add_sat": {
1433 operator += "+|";
1434 break;
1435 }
1436 case "sub": {
13971437 operator += "-";
13981438 break;
13991439 }
1400 case 2: {
1401 operator += "*";
1440 case "subwrap": {
1441 operator += "-%";
14021442 break;
14031443 }
1404 case 3: {
1405 if (!expr.binOp.extact && !expr.binOp.floor && !expr.binOp.trunv) {
1406 operator += "/";
1407 break;
1408 }
1409 let print_div = "";
1410 if (expr.binOp.exact) {
1411 print_div = "@divExact(";
1412 }
1413 if (expr.binOp.floor) {
1414 print_div = "@divFloor(";
1415 }
1416 if (expr.binOp.trunc) {
1417 print_div = "@divTrunc(";
1418 }
1419 return print_div + print_lhs + ", " + print_rhs + ")";
1444 case "sub_sat": {
1445 operator += "-|";
1446 break;
1447 }
1448 case "mul": {
1449 operator += "*";
1450 break;
14201451 }
1421 case 4: {
1422 return "@mod(" + print_lhs + ", " + print_rhs + ")";
1452 case "mulwrap": {
1453 operator += "*%";
1454 break;
14231455 }
1424 case 5: {
1425 return "@rem(" + print_lhs + ", " + print_rhs + ")";
1456 case "mul_sat": {
1457 operator += "*|";
1458 break;
14261459 }
1427 case 6: {
1428 // rem_mod
1429 return "@rem(" + print_lhs + ", " + print_rhs + ")";
1460 case "div": {
1461 operator += "/";
1462 break;
14301463 }
1431 case 7: {
1432 if (expr.binOp.exact) {
1433 let print_shl = "@shlExact(";
1434 return print_shl + print_lhs + ", " + print_rhs + ")";
1435 }
1464 case "shl": {
14361465 operator += "<<";
14371466 break;
14381467 }
1439 case 8: {
1440 if (expr.binOp.exact) {
1441 let print_shr = "@shrExact(";
1442 return print_shr + print_lhs + ", " + print_rhs + ")";
1443 }
1444 operator += ">>";
1468 case "shl_sat": {
1469 operator += "<<|";
14451470 break;
14461471 }
1447 case 9 : {
1448 return "@bitCast(" + print_lhs + ", " + print_rhs + ")";
1472 case "shr": {
1473 operator += ">>";
1474 break;
14491475 }
1450 case 10 : {
1476 case "bit_or" : {
14511477 operator += "|";
14521478 break;
14531479 }
1454 case 11 : {
1455 return "@alignCast(" + print_lhs + ", " + print_rhs + ")";
1456 }
1457 case 12 : {
1480 case "bit_and" : {
14581481 operator += "&";
14591482 break;
14601483 }
1461 case 13 : {
1484 case "array_cat" : {
14621485 operator += "++";
14631486 break;
14641487 }
1465 case 14 : {
1488 case "array_mul" : {
14661489 operator += "**";
14671490 break;
14681491 }
1469 case 15 : {
1470 return "@Vector(" + print_lhs + ", " + print_rhs + ")";
1471 }
14721492 default: console.log("operator not handled yet or doesn't exist!");
14731493 };
1474 if (expr.binOp.wrap) {
1475 operator += "%";
1476 }
1477 if (expr.binOp.sat) {
1478 operator += "|";
1479 }
1494
14801495 return print_lhs + " " + operator + " " + print_rhs;
14811496
14821497 }
......@@ -1966,8 +1981,6 @@ var zigAnalysis;
19661981 payloadHtml += '<span class="tok-kw">' + escapeHtml(name) + '</span>';
19671982 } else if ("binOpIndex" in value) {
19681983 payloadHtml += exprName(value, opts);
1969 console.log(value);
1970 console.log(payloadHtml);
19711984 }else if ("comptimeExpr" in value) {
19721985 let comptimeExpr = zigAnalysis.comptimeExprs[value.comptimeExpr].code;
19731986 if (opts.wantHtml) {
......@@ -1998,7 +2011,6 @@ var zigAnalysis;
19982011 }
19992012
20002013 if (fnObj.is_inferred_error) {
2001 console.log(fnObj)
20022014 payloadHtml += "!";
20032015 }
20042016 if (fnObj.ret != null) {
src/Autodoc.zig+89-1014
......@@ -676,31 +676,18 @@ const DocData = struct {
676676 builtinBinIndex: usize,
677677 switchIndex: usize, // index in `exprs`
678678 switchOp: SwitchOp,
679 // Index a `type` like struct with expressions
680 // it's necessary because when a caller ask by a binOp maybe there are
681 // more binary op inside them, so the caller get's the current `exprs` index
682 // and the binOp can walk the tree preserving the first index of the tree
683 // for examples see `.mul` and `analyzeFunctionExtended` in `has_align` section
684679 binOp: BinOp,
685680 binOpIndex: usize,
686681 const BinOp = struct {
687682 lhs: usize, // index in `exprs`
688683 rhs: usize, // index in `exprs`
689 // opKind
690 // Identify the operator in js
691 // 0: add, 1: sub, 2: mul, 3: div, 4: mod, 5: rem, 6: rem_mod, 7: shl, 8: shr, 9: bitcast, 10: bit_or, 11: align_cast, 12: bit_and, 13: array_cat, 14: array_mul, 15: vector
692 // Others binOp are not handled yet
693 opKind: usize = 0,
694 // flags to operations
695 wrap: bool = false,
696 sat: bool = false,
697 exact: bool = false,
698 floor: bool = false,
699 trunc: bool = false,
684 name: []const u8 = "", // tag name
700685 };
701686 const SwitchOp = struct {
702 cases: []usize,
703 else_index: ?usize,
687 cond_index: usize,
688 node_name: []const u8,
689 file_name: []const u8,
690 line_start: usize,
704691 };
705692 const BuiltinBin = struct {
706693 name: []const u8 = "", // fn name
......@@ -1061,757 +1048,13 @@ fn walkInstruction(
10611048 .expr = .{ .int = .{ .value = int } },
10621049 };
10631050 },
1064 .bitcast => {
1065 const pl_node = data[inst_index].pl_node;
1066 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1067
1068 const binop_index = self.exprs.items.len;
1069 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1070
1071 var lhs: DocData.WalkResult = try self.walkRef(
1072 file,
1073 parent_scope,
1074 extra.data.lhs,
1075 false,
1076 );
1077 var rhs: DocData.WalkResult = try self.walkRef(
1078 file,
1079 parent_scope,
1080 extra.data.rhs,
1081 false,
1082 );
1083
1084 const lhs_index = self.exprs.items.len;
1085 try self.exprs.append(self.arena, lhs.expr);
1086 const rhs_index = self.exprs.items.len;
1087 try self.exprs.append(self.arena, rhs.expr);
1088 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 9 } };
1089
1090 return DocData.WalkResult{
1091 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1092 .expr = .{ .binOpIndex = binop_index },
1093 };
1094 },
1095 // implementing in builtinBin @check if it's ok to delete it
1096 // .align_cast => {
1097 // const pl_node = data[inst_index].pl_node;
1098 // const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1099 //
1100 // const binop_index = self.exprs.items.len;
1101 // try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1102 //
1103 // var lhs: DocData.WalkResult = try self.walkRef(
1104 // file,
1105 // parent_scope,
1106 // extra.data.lhs,
1107 // false,
1108 // );
1109 // var rhs: DocData.WalkResult = try self.walkRef(
1110 // file,
1111 // parent_scope,
1112 // extra.data.rhs,
1113 // false,
1114 // );
1115 //
1116 // const lhs_index = self.exprs.items.len;
1117 // try self.exprs.append(self.arena, lhs.expr);
1118 // const rhs_index = self.exprs.items.len;
1119 // try self.exprs.append(self.arena, rhs.expr);
1120 // self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 11 } };
1121 //
1122 // return DocData.WalkResult{
1123 // .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1124 // .expr = .{ .binOpIndex = binop_index },
1125 // };
1126 // },
1127 .slice_start => {
1128 const pl_node = data[inst_index].pl_node;
1129 const extra = file.zir.extraData(Zir.Inst.SliceStart, pl_node.payload_index);
1130
1131 const slice_index = self.exprs.items.len;
1132 try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
1133
1134 var lhs: DocData.WalkResult = try self.walkRef(
1135 file,
1136 parent_scope,
1137 extra.data.lhs,
1138 false,
1139 );
1140 var start: DocData.WalkResult = try self.walkRef(
1141 file,
1142 parent_scope,
1143 extra.data.start,
1144 false,
1145 );
1146
1147 const lhs_index = self.exprs.items.len;
1148 try self.exprs.append(self.arena, lhs.expr);
1149 const start_index = self.exprs.items.len;
1150 try self.exprs.append(self.arena, start.expr);
1151 self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index } };
1152
1153 return DocData.WalkResult{
1154 .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
1155 .expr = .{ .sliceIndex = slice_index },
1156 };
1157 },
1158 .slice_end => {
1159 const pl_node = data[inst_index].pl_node;
1160 const extra = file.zir.extraData(Zir.Inst.SliceEnd, pl_node.payload_index);
1161
1162 const slice_index = self.exprs.items.len;
1163 try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
1164
1165 var lhs: DocData.WalkResult = try self.walkRef(
1166 file,
1167 parent_scope,
1168 extra.data.lhs,
1169 false,
1170 );
1171 var start: DocData.WalkResult = try self.walkRef(
1172 file,
1173 parent_scope,
1174 extra.data.start,
1175 false,
1176 );
1177 var end: DocData.WalkResult = try self.walkRef(
1178 file,
1179 parent_scope,
1180 extra.data.end,
1181 false,
1182 );
1183
1184 const lhs_index = self.exprs.items.len;
1185 try self.exprs.append(self.arena, lhs.expr);
1186 const start_index = self.exprs.items.len;
1187 try self.exprs.append(self.arena, start.expr);
1188 const end_index = self.exprs.items.len;
1189 try self.exprs.append(self.arena, end.expr);
1190 self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index } };
1191
1192 return DocData.WalkResult{
1193 .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
1194 .expr = .{ .sliceIndex = slice_index },
1195 };
1196 },
1197 .slice_sentinel => {
1198 const pl_node = data[inst_index].pl_node;
1199 const extra = file.zir.extraData(Zir.Inst.SliceSentinel, pl_node.payload_index);
1200
1201 const slice_index = self.exprs.items.len;
1202 try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
1203
1204 var lhs: DocData.WalkResult = try self.walkRef(
1205 file,
1206 parent_scope,
1207 extra.data.lhs,
1208 false,
1209 );
1210 var start: DocData.WalkResult = try self.walkRef(
1211 file,
1212 parent_scope,
1213 extra.data.start,
1214 false,
1215 );
1216 var end: DocData.WalkResult = try self.walkRef(
1217 file,
1218 parent_scope,
1219 extra.data.end,
1220 false,
1221 );
1222 var sentinel: DocData.WalkResult = try self.walkRef(
1223 file,
1224 parent_scope,
1225 extra.data.sentinel,
1226 false,
1227 );
1228
1229 const lhs_index = self.exprs.items.len;
1230 try self.exprs.append(self.arena, lhs.expr);
1231 const start_index = self.exprs.items.len;
1232 try self.exprs.append(self.arena, start.expr);
1233 const end_index = self.exprs.items.len;
1234 try self.exprs.append(self.arena, end.expr);
1235 const sentinel_index = self.exprs.items.len;
1236 try self.exprs.append(self.arena, sentinel.expr);
1237 self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index, .sentinel = sentinel_index } };
1238
1239 return DocData.WalkResult{
1240 .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
1241 .expr = .{ .sliceIndex = slice_index },
1242 };
1243 },
1244 .bit_or => {
1245 const pl_node = data[inst_index].pl_node;
1246 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1247
1248 const binop_index = self.exprs.items.len;
1249 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1250
1251 var lhs: DocData.WalkResult = try self.walkRef(
1252 file,
1253 parent_scope,
1254 extra.data.lhs,
1255 false,
1256 );
1257 var rhs: DocData.WalkResult = try self.walkRef(
1258 file,
1259 parent_scope,
1260 extra.data.rhs,
1261 false,
1262 );
1263
1264 const lhs_index = self.exprs.items.len;
1265 try self.exprs.append(self.arena, lhs.expr);
1266 const rhs_index = self.exprs.items.len;
1267 try self.exprs.append(self.arena, rhs.expr);
1268 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 10 } };
1269
1270 return DocData.WalkResult{
1271 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1272 .expr = .{ .binOpIndex = binop_index },
1273 };
1274 },
1275 .bit_and => {
1276 const pl_node = data[inst_index].pl_node;
1277 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1278
1279 const binop_index = self.exprs.items.len;
1280 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1281
1282 var lhs: DocData.WalkResult = try self.walkRef(
1283 file,
1284 parent_scope,
1285 extra.data.lhs,
1286 false,
1287 );
1288 var rhs: DocData.WalkResult = try self.walkRef(
1289 file,
1290 parent_scope,
1291 extra.data.rhs,
1292 false,
1293 );
1294
1295 const lhs_index = self.exprs.items.len;
1296 try self.exprs.append(self.arena, lhs.expr);
1297 const rhs_index = self.exprs.items.len;
1298 try self.exprs.append(self.arena, rhs.expr);
1299 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 12 } };
1300
1301 return DocData.WalkResult{
1302 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1303 .expr = .{ .binOpIndex = binop_index },
1304 };
1305 },
1306 .add => {
1307 const pl_node = data[inst_index].pl_node;
1308 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1309
1310 const binop_index = self.exprs.items.len;
1311 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1312
1313 var lhs: DocData.WalkResult = try self.walkRef(
1314 file,
1315 parent_scope,
1316 extra.data.lhs,
1317 false,
1318 );
1319 var rhs: DocData.WalkResult = try self.walkRef(
1320 file,
1321 parent_scope,
1322 extra.data.rhs,
1323 false,
1324 );
1325
1326 const lhs_index = self.exprs.items.len;
1327 try self.exprs.append(self.arena, lhs.expr);
1328 const rhs_index = self.exprs.items.len;
1329 try self.exprs.append(self.arena, rhs.expr);
1330 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 0 } };
1331
1332 return DocData.WalkResult{
1333 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1334 .expr = .{ .binOpIndex = binop_index },
1335 };
1336 },
1337 .addwrap => {
1338 const pl_node = data[inst_index].pl_node;
1339 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1340
1341 const binop_index = self.exprs.items.len;
1342 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1343
1344 var lhs: DocData.WalkResult = try self.walkRef(
1345 file,
1346 parent_scope,
1347 extra.data.lhs,
1348 false,
1349 );
1350 var rhs: DocData.WalkResult = try self.walkRef(
1351 file,
1352 parent_scope,
1353 extra.data.rhs,
1354 false,
1355 );
1356
1357 const lhs_index = self.exprs.items.len;
1358 try self.exprs.append(self.arena, lhs.expr);
1359 const rhs_index = self.exprs.items.len;
1360 try self.exprs.append(self.arena, rhs.expr);
1361 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .wrap = true, .opKind = 0 } };
1362
1363 return DocData.WalkResult{
1364 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1365 .expr = .{ .binOpIndex = binop_index },
1366 };
1367 },
1368 .add_sat => {
1369 const pl_node = data[inst_index].pl_node;
1370 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1371
1372 const binop_index = self.exprs.items.len;
1373 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1374
1375 var lhs: DocData.WalkResult = try self.walkRef(
1376 file,
1377 parent_scope,
1378 extra.data.lhs,
1379 false,
1380 );
1381 var rhs: DocData.WalkResult = try self.walkRef(
1382 file,
1383 parent_scope,
1384 extra.data.rhs,
1385 false,
1386 );
1387
1388 const lhs_index = self.exprs.items.len;
1389 try self.exprs.append(self.arena, lhs.expr);
1390 const rhs_index = self.exprs.items.len;
1391 try self.exprs.append(self.arena, rhs.expr);
1392 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 0 } };
1393
1394 return DocData.WalkResult{
1395 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1396 .expr = .{ .binOpIndex = binop_index },
1397 };
1398 },
1399
1400 .sub => {
1401 const pl_node = data[inst_index].pl_node;
1402 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1403
1404 const binop_index = self.exprs.items.len;
1405 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1406
1407 var lhs: DocData.WalkResult = try self.walkRef(
1408 file,
1409 parent_scope,
1410 extra.data.lhs,
1411 false,
1412 );
1413 var rhs: DocData.WalkResult = try self.walkRef(
1414 file,
1415 parent_scope,
1416 extra.data.rhs,
1417 false,
1418 );
1419
1420 const lhs_index = self.exprs.items.len;
1421 try self.exprs.append(self.arena, lhs.expr);
1422 const rhs_index = self.exprs.items.len;
1423 try self.exprs.append(self.arena, rhs.expr);
1424 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 1 } };
1425
1426 return DocData.WalkResult{
1427 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1428 .expr = .{ .binOpIndex = binop_index },
1429 };
1430 },
1431 .subwrap => {
1432 const pl_node = data[inst_index].pl_node;
1433 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1434
1435 const binop_index = self.exprs.items.len;
1436 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1437
1438 var lhs: DocData.WalkResult = try self.walkRef(
1439 file,
1440 parent_scope,
1441 extra.data.lhs,
1442 false,
1443 );
1444 var rhs: DocData.WalkResult = try self.walkRef(
1445 file,
1446 parent_scope,
1447 extra.data.rhs,
1448 false,
1449 );
1450
1451 const lhs_index = self.exprs.items.len;
1452 try self.exprs.append(self.arena, lhs.expr);
1453 const rhs_index = self.exprs.items.len;
1454 try self.exprs.append(self.arena, rhs.expr);
1455 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .wrap = true, .opKind = 1 } };
1456
1457 return DocData.WalkResult{
1458 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1459 .expr = .{ .binOpIndex = binop_index },
1460 };
1461 },
1462 .sub_sat => {
1463 const pl_node = data[inst_index].pl_node;
1464 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1465
1466 const binop_index = self.exprs.items.len;
1467 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1468
1469 var lhs: DocData.WalkResult = try self.walkRef(
1470 file,
1471 parent_scope,
1472 extra.data.lhs,
1473 false,
1474 );
1475 var rhs: DocData.WalkResult = try self.walkRef(
1476 file,
1477 parent_scope,
1478 extra.data.rhs,
1479 false,
1480 );
1481
1482 const lhs_index = self.exprs.items.len;
1483 try self.exprs.append(self.arena, lhs.expr);
1484 const rhs_index = self.exprs.items.len;
1485 try self.exprs.append(self.arena, rhs.expr);
1486 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 1 } };
1487
1488 return DocData.WalkResult{
1489 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1490 .expr = .{ .binOpIndex = binop_index },
1491 };
1492 },
1493
1494 .mul => {
1495 const pl_node = data[inst_index].pl_node;
1496 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1497
1498 const binop_index = self.exprs.items.len;
1499 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1500
1501 var lhs: DocData.WalkResult = try self.walkRef(
1502 file,
1503 parent_scope,
1504 extra.data.lhs,
1505 false,
1506 );
1507 var rhs: DocData.WalkResult = try self.walkRef(
1508 file,
1509 parent_scope,
1510 extra.data.rhs,
1511 false,
1512 );
1513
1514 const lhs_index = self.exprs.items.len;
1515 try self.exprs.append(self.arena, lhs.expr);
1516 const rhs_index = self.exprs.items.len;
1517 try self.exprs.append(self.arena, rhs.expr);
1518 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 2 } };
1519
1520 return DocData.WalkResult{
1521 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1522 .expr = .{ .binOpIndex = binop_index },
1523 };
1524 },
1525 .mulwrap => {
1526 const pl_node = data[inst_index].pl_node;
1527 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1528
1529 const binop_index = self.exprs.items.len;
1530 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1531
1532 var lhs: DocData.WalkResult = try self.walkRef(
1533 file,
1534 parent_scope,
1535 extra.data.lhs,
1536 false,
1537 );
1538 var rhs: DocData.WalkResult = try self.walkRef(
1539 file,
1540 parent_scope,
1541 extra.data.rhs,
1542 false,
1543 );
1544
1545 const lhs_index = self.exprs.items.len;
1546 try self.exprs.append(self.arena, lhs.expr);
1547 const rhs_index = self.exprs.items.len;
1548 try self.exprs.append(self.arena, rhs.expr);
1549 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .wrap = true, .opKind = 2 } };
1550
1551 return DocData.WalkResult{
1552 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1553 .expr = .{ .binOpIndex = binop_index },
1554 };
1555 },
1556 .mul_sat => {
1557 const pl_node = data[inst_index].pl_node;
1558 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1559
1560 const binop_index = self.exprs.items.len;
1561 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1562
1563 var lhs: DocData.WalkResult = try self.walkRef(
1564 file,
1565 parent_scope,
1566 extra.data.lhs,
1567 false,
1568 );
1569 var rhs: DocData.WalkResult = try self.walkRef(
1570 file,
1571 parent_scope,
1572 extra.data.rhs,
1573 false,
1574 );
1575
1576 const lhs_index = self.exprs.items.len;
1577 try self.exprs.append(self.arena, lhs.expr);
1578 const rhs_index = self.exprs.items.len;
1579 try self.exprs.append(self.arena, rhs.expr);
1580 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 2 } };
1581
1582 return DocData.WalkResult{
1583 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1584 .expr = .{ .binOpIndex = binop_index },
1585 };
1586 },
1587
1588 .div => {
1589 const pl_node = data[inst_index].pl_node;
1590 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1591
1592 const binop_index = self.exprs.items.len;
1593 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1594
1595 var lhs: DocData.WalkResult = try self.walkRef(
1596 file,
1597 parent_scope,
1598 extra.data.lhs,
1599 false,
1600 );
1601 var rhs: DocData.WalkResult = try self.walkRef(
1602 file,
1603 parent_scope,
1604 extra.data.rhs,
1605 false,
1606 );
1607
1608 const lhs_index = self.exprs.items.len;
1609 try self.exprs.append(self.arena, lhs.expr);
1610 const rhs_index = self.exprs.items.len;
1611 try self.exprs.append(self.arena, rhs.expr);
1612 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 3 } };
1613
1614 return DocData.WalkResult{
1615 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1616 .expr = .{ .binOpIndex = binop_index },
1617 };
1618 },
1619 .div_exact => {
1620 const pl_node = data[inst_index].pl_node;
1621 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1622
1623 const binop_index = self.exprs.items.len;
1624 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1625
1626 var lhs: DocData.WalkResult = try self.walkRef(
1627 file,
1628 parent_scope,
1629 extra.data.lhs,
1630 false,
1631 );
1632 var rhs: DocData.WalkResult = try self.walkRef(
1633 file,
1634 parent_scope,
1635 extra.data.rhs,
1636 false,
1637 );
1638
1639 const lhs_index = self.exprs.items.len;
1640 try self.exprs.append(self.arena, lhs.expr);
1641 const rhs_index = self.exprs.items.len;
1642 try self.exprs.append(self.arena, rhs.expr);
1643 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 3 } };
1644
1645 return DocData.WalkResult{
1646 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1647 .expr = .{ .binOpIndex = binop_index },
1648 };
1649 },
1650 .div_floor => {
1651 const pl_node = data[inst_index].pl_node;
1652 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1653
1654 const binop_index = self.exprs.items.len;
1655 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1656
1657 var lhs: DocData.WalkResult = try self.walkRef(
1658 file,
1659 parent_scope,
1660 extra.data.lhs,
1661 false,
1662 );
1663 var rhs: DocData.WalkResult = try self.walkRef(
1664 file,
1665 parent_scope,
1666 extra.data.rhs,
1667 false,
1668 );
1669
1670 const lhs_index = self.exprs.items.len;
1671 try self.exprs.append(self.arena, lhs.expr);
1672 const rhs_index = self.exprs.items.len;
1673 try self.exprs.append(self.arena, rhs.expr);
1674 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 3 } };
1675
1676 return DocData.WalkResult{
1677 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1678 .expr = .{ .binOpIndex = binop_index },
1679 };
1680 },
1681 .div_trunc => {
1682 const pl_node = data[inst_index].pl_node;
1683 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1684
1685 const binop_index = self.exprs.items.len;
1686 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1687
1688 var lhs: DocData.WalkResult = try self.walkRef(
1689 file,
1690 parent_scope,
1691 extra.data.lhs,
1692 false,
1693 );
1694 var rhs: DocData.WalkResult = try self.walkRef(
1695 file,
1696 parent_scope,
1697 extra.data.rhs,
1698 false,
1699 );
1700
1701 const lhs_index = self.exprs.items.len;
1702 try self.exprs.append(self.arena, lhs.expr);
1703 const rhs_index = self.exprs.items.len;
1704 try self.exprs.append(self.arena, rhs.expr);
1705 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .trunc = true, .opKind = 3 } };
1706
1707 return DocData.WalkResult{
1708 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1709 .expr = .{ .binOpIndex = binop_index },
1710 };
1711 },
1712
1713 .mod => {
1714 const pl_node = data[inst_index].pl_node;
1715 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1716
1717 const binop_index = self.exprs.items.len;
1718 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1719
1720 var lhs: DocData.WalkResult = try self.walkRef(
1721 file,
1722 parent_scope,
1723 extra.data.lhs,
1724 false,
1725 );
1726 var rhs: DocData.WalkResult = try self.walkRef(
1727 file,
1728 parent_scope,
1729 extra.data.rhs,
1730 false,
1731 );
1732
1733 const lhs_index = self.exprs.items.len;
1734 try self.exprs.append(self.arena, lhs.expr);
1735 const rhs_index = self.exprs.items.len;
1736 try self.exprs.append(self.arena, rhs.expr);
1737 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 4 } };
1738
1739 return DocData.WalkResult{
1740 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1741 .expr = .{ .binOpIndex = binop_index },
1742 };
1743 },
1744 .rem => {
1745 const pl_node = data[inst_index].pl_node;
1746 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1747
1748 const binop_index = self.exprs.items.len;
1749 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1750
1751 var lhs: DocData.WalkResult = try self.walkRef(
1752 file,
1753 parent_scope,
1754 extra.data.lhs,
1755 false,
1756 );
1757 var rhs: DocData.WalkResult = try self.walkRef(
1758 file,
1759 parent_scope,
1760 extra.data.rhs,
1761 false,
1762 );
1763
1764 const lhs_index = self.exprs.items.len;
1765 try self.exprs.append(self.arena, lhs.expr);
1766 const rhs_index = self.exprs.items.len;
1767 try self.exprs.append(self.arena, rhs.expr);
1768 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 5 } };
1769
1770 return DocData.WalkResult{
1771 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1772 .expr = .{ .binOpIndex = binop_index },
1773 };
1774 },
1775
1776 // @check how to test it
1777 .mod_rem => {
1778 const pl_node = data[inst_index].pl_node;
1779 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1780
1781 const binop_index = self.exprs.items.len;
1782 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1783
1784 var lhs: DocData.WalkResult = try self.walkRef(
1785 file,
1786 parent_scope,
1787 extra.data.lhs,
1788 false,
1789 );
1790 var rhs: DocData.WalkResult = try self.walkRef(
1791 file,
1792 parent_scope,
1793 extra.data.rhs,
1794 false,
1795 );
1796
1797 const lhs_index = self.exprs.items.len;
1798 try self.exprs.append(self.arena, lhs.expr);
1799 const rhs_index = self.exprs.items.len;
1800 try self.exprs.append(self.arena, rhs.expr);
1801 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .floor = true, .opKind = 6 } };
1802
1803 return DocData.WalkResult{
1804 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1805 .expr = .{ .binOpIndex = binop_index },
1806 };
1807 },
18081051
1809 .shl => {
1052 .slice_start => {
18101053 const pl_node = data[inst_index].pl_node;
1811 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1054 const extra = file.zir.extraData(Zir.Inst.SliceStart, pl_node.payload_index);
18121055
1813 const binop_index = self.exprs.items.len;
1814 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1056 const slice_index = self.exprs.items.len;
1057 try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
18151058
18161059 var lhs: DocData.WalkResult = try self.walkRef(
18171060 file,
......@@ -1819,30 +1062,30 @@ fn walkInstruction(
18191062 extra.data.lhs,
18201063 false,
18211064 );
1822 var rhs: DocData.WalkResult = try self.walkRef(
1065 var start: DocData.WalkResult = try self.walkRef(
18231066 file,
18241067 parent_scope,
1825 extra.data.rhs,
1068 extra.data.start,
18261069 false,
18271070 );
18281071
18291072 const lhs_index = self.exprs.items.len;
18301073 try self.exprs.append(self.arena, lhs.expr);
1831 const rhs_index = self.exprs.items.len;
1832 try self.exprs.append(self.arena, rhs.expr);
1833 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 7 } };
1074 const start_index = self.exprs.items.len;
1075 try self.exprs.append(self.arena, start.expr);
1076 self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index } };
18341077
18351078 return DocData.WalkResult{
1836 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1837 .expr = .{ .binOpIndex = binop_index },
1079 .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
1080 .expr = .{ .sliceIndex = slice_index },
18381081 };
18391082 },
1840 .shl_exact => {
1083 .slice_end => {
18411084 const pl_node = data[inst_index].pl_node;
1842 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1085 const extra = file.zir.extraData(Zir.Inst.SliceEnd, pl_node.payload_index);
18431086
1844 const binop_index = self.exprs.items.len;
1845 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1087 const slice_index = self.exprs.items.len;
1088 try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
18461089
18471090 var lhs: DocData.WalkResult = try self.walkRef(
18481091 file,
......@@ -1850,62 +1093,38 @@ fn walkInstruction(
18501093 extra.data.lhs,
18511094 false,
18521095 );
1853 var rhs: DocData.WalkResult = try self.walkRef(
1854 file,
1855 parent_scope,
1856 extra.data.rhs,
1857 false,
1858 );
1859
1860 const lhs_index = self.exprs.items.len;
1861 try self.exprs.append(self.arena, lhs.expr);
1862 const rhs_index = self.exprs.items.len;
1863 try self.exprs.append(self.arena, rhs.expr);
1864 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 7 } };
1865
1866 return DocData.WalkResult{
1867 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1868 .expr = .{ .binOpIndex = binop_index },
1869 };
1870 },
1871 .shl_sat => {
1872 const pl_node = data[inst_index].pl_node;
1873 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1874
1875 const binop_index = self.exprs.items.len;
1876 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1877
1878 var lhs: DocData.WalkResult = try self.walkRef(
1096 var start: DocData.WalkResult = try self.walkRef(
18791097 file,
18801098 parent_scope,
1881 extra.data.lhs,
1099 extra.data.start,
18821100 false,
18831101 );
1884 var rhs: DocData.WalkResult = try self.walkRef(
1102 var end: DocData.WalkResult = try self.walkRef(
18851103 file,
18861104 parent_scope,
1887 extra.data.rhs,
1105 extra.data.end,
18881106 false,
18891107 );
18901108
18911109 const lhs_index = self.exprs.items.len;
18921110 try self.exprs.append(self.arena, lhs.expr);
1893 const rhs_index = self.exprs.items.len;
1894 try self.exprs.append(self.arena, rhs.expr);
1895 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .sat = true, .opKind = 7 } };
1111 const start_index = self.exprs.items.len;
1112 try self.exprs.append(self.arena, start.expr);
1113 const end_index = self.exprs.items.len;
1114 try self.exprs.append(self.arena, end.expr);
1115 self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index } };
18961116
18971117 return DocData.WalkResult{
1898 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1899 .expr = .{ .binOpIndex = binop_index },
1118 .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
1119 .expr = .{ .sliceIndex = slice_index },
19001120 };
19011121 },
1902
1903 .shr => {
1122 .slice_sentinel => {
19041123 const pl_node = data[inst_index].pl_node;
1905 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1124 const extra = file.zir.extraData(Zir.Inst.SliceSentinel, pl_node.payload_index);
19061125
1907 const binop_index = self.exprs.items.len;
1908 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1126 const slice_index = self.exprs.items.len;
1127 try self.exprs.append(self.arena, .{ .slice = .{ .lhs = 0, .start = 0 } });
19091128
19101129 var lhs: DocData.WalkResult = try self.walkRef(
19111130 file,
......@@ -1913,121 +1132,43 @@ fn walkInstruction(
19131132 extra.data.lhs,
19141133 false,
19151134 );
1916 var rhs: DocData.WalkResult = try self.walkRef(
1135 var start: DocData.WalkResult = try self.walkRef(
19171136 file,
19181137 parent_scope,
1919 extra.data.rhs,
1138 extra.data.start,
19201139 false,
19211140 );
1922
1923 const lhs_index = self.exprs.items.len;
1924 try self.exprs.append(self.arena, lhs.expr);
1925 const rhs_index = self.exprs.items.len;
1926 try self.exprs.append(self.arena, rhs.expr);
1927 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .opKind = 8 } };
1928
1929 return DocData.WalkResult{
1930 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1931 .expr = .{ .binOpIndex = binop_index },
1932 };
1933 },
1934 .shr_exact => {
1935 const pl_node = data[inst_index].pl_node;
1936 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1937
1938 const binop_index = self.exprs.items.len;
1939 try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1940
1941 var lhs: DocData.WalkResult = try self.walkRef(
1141 var end: DocData.WalkResult = try self.walkRef(
19421142 file,
19431143 parent_scope,
1944 extra.data.lhs,
1144 extra.data.end,
19451145 false,
19461146 );
1947 var rhs: DocData.WalkResult = try self.walkRef(
1147 var sentinel: DocData.WalkResult = try self.walkRef(
19481148 file,
19491149 parent_scope,
1950 extra.data.rhs,
1150 extra.data.sentinel,
19511151 false,
19521152 );
19531153
19541154 const lhs_index = self.exprs.items.len;
19551155 try self.exprs.append(self.arena, lhs.expr);
1956 const rhs_index = self.exprs.items.len;
1957 try self.exprs.append(self.arena, rhs.expr);
1958 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 8 } };
1156 const start_index = self.exprs.items.len;
1157 try self.exprs.append(self.arena, start.expr);
1158 const end_index = self.exprs.items.len;
1159 try self.exprs.append(self.arena, end.expr);
1160 const sentinel_index = self.exprs.items.len;
1161 try self.exprs.append(self.arena, sentinel.expr);
1162 self.exprs.items[slice_index] = .{ .slice = .{ .lhs = lhs_index, .start = start_index, .end = end_index, .sentinel = sentinel_index } };
19591163
19601164 return DocData.WalkResult{
1961 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1962 .expr = .{ .binOpIndex = binop_index },
1165 .typeRef = self.decls.items[lhs.expr.declRef].value.typeRef,
1166 .expr = .{ .sliceIndex = slice_index },
19631167 };
19641168 },
19651169
1966 // throwing this TODO
1967 // TODO: handle `Array` in tryResolveDeclPath.type
1968 // .array_cat => {
1969 // const pl_node = data[inst_index].pl_node;
1970 // const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
1971 //
1972 // const binop_index = self.exprs.items.len;
1973 // try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
1974 //
1975 // var lhs: DocData.WalkResult = try self.walkRef(
1976 // file,
1977 // parent_scope,
1978 // extra.data.lhs,
1979 // false,
1980 // );
1981 // var rhs: DocData.WalkResult = try self.walkRef(
1982 // file,
1983 // parent_scope,
1984 // extra.data.rhs,
1985 // false,
1986 // );
1987 //
1988 // const lhs_index = self.exprs.items.len;
1989 // try self.exprs.append(self.arena, lhs.expr);
1990 // const rhs_index = self.exprs.items.len;
1991 // try self.exprs.append(self.arena, rhs.expr);
1992 // self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 13 } };
1993 //
1994 // return DocData.WalkResult{
1995 // .typeRef = .{ .type = @enumToInt(Ref.type_type) },
1996 // .expr = .{ .binOpIndex = binop_index },
1997 // };
1998 // },
1999 // .array_mul => {
2000 // const pl_node = data[inst_index].pl_node;
2001 // const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
2002 //
2003 // const binop_index = self.exprs.items.len;
2004 // try self.exprs.append(self.arena, .{ .binOp = .{ .lhs = 0, .rhs = 0 } });
2005 //
2006 // var lhs: DocData.WalkResult = try self.walkRef(
2007 // file,
2008 // parent_scope,
2009 // extra.data.lhs,
2010 // false,
2011 // );
2012 // var rhs: DocData.WalkResult = try self.walkRef(
2013 // file,
2014 // parent_scope,
2015 // extra.data.rhs,
2016 // false,
2017 // );
2018 //
2019 // const lhs_index = self.exprs.items.len;
2020 // try self.exprs.append(self.arena, lhs.expr);
2021 // const rhs_index = self.exprs.items.len;
2022 // try self.exprs.append(self.arena, rhs.expr);
2023 // self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 14 } };
2024 //
2025 // return DocData.WalkResult{
2026 // .typeRef = .{ .type = @enumToInt(Ref.type_type) },
2027 // .expr = .{ .binOpIndex = binop_index },
2028 // };
2029 // },
2030 .vector_type => {
1170 // @check array_cat and array_mul
1171 .add, .addwrap, .add_sat, .sub, .subwrap, .sub_sat, .mul, .mulwrap, .mul_sat, .div, .shl, .shl_sat, .shr, .bit_or, .bit_and => {
20311172 const pl_node = data[inst_index].pl_node;
20321173 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
20331174
......@@ -2051,7 +1192,11 @@ fn walkInstruction(
20511192 try self.exprs.append(self.arena, lhs.expr);
20521193 const rhs_index = self.exprs.items.len;
20531194 try self.exprs.append(self.arena, rhs.expr);
2054 self.exprs.items[binop_index] = .{ .binOp = .{ .lhs = lhs_index, .rhs = rhs_index, .exact = true, .opKind = 15 } };
1195 self.exprs.items[binop_index] = .{ .binOp = .{
1196 .name = @tagName(tags[inst_index]),
1197 .lhs = lhs_index,
1198 .rhs = rhs_index,
1199 } };
20551200
20561201 return DocData.WalkResult{
20571202 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
......@@ -2104,7 +1249,28 @@ fn walkInstruction(
21041249 },
21051250 // @check
21061251 // .clz, .ctz, .pop_count, .byte_swap, .bit_reverse
2107 .float_to_int, .int_to_float, .int_to_ptr, .int_to_enum, .float_cast, .int_cast, .ptr_cast, .truncate, .align_cast, .has_decl, .has_field => {
1252 .float_to_int,
1253 .int_to_float,
1254 .int_to_ptr,
1255 .int_to_enum,
1256 .float_cast,
1257 .int_cast,
1258 .ptr_cast,
1259 .truncate,
1260 .align_cast,
1261 .has_decl,
1262 .has_field,
1263 .div_exact,
1264 .div_floor,
1265 .div_trunc,
1266 .mod,
1267 .rem,
1268 .mod_rem,
1269 .shl_exact,
1270 .shr_exact,
1271 .bitcast,
1272 .vector_type,
1273 => {
21081274 const pl_node = data[inst_index].pl_node;
21091275 const extra = file.zir.extraData(Zir.Inst.Bin, pl_node.payload_index);
21101276
......@@ -2629,106 +1795,22 @@ fn walkInstruction(
26291795 // WIP
26301796 const pl_node = data[inst_index].pl_node;
26311797 const extra = file.zir.extraData(Zir.Inst.SwitchBlock, pl_node.payload_index);
2632 const array_data = try self.arena.alloc(usize, extra.data.bits.scalar_cases_len);
2633 var extra_index = extra.end;
1798 const cond_index = self.exprs.items.len;
1799 _ = try self.walkRef(file, parent_scope, extra.data.operand, false);
1800
1801 const ast_index = self.ast_nodes.items.len - 1;
1802 const ast = self.ast_nodes.items[ast_index];
26341803
26351804 // const sep = "=" ** 200;
26361805 // std.debug.print("{s}\n", .{sep});
2637 // std.debug.print("pl_node = {any}\n", .{pl_node});
2638 // std.debug.print("extra = {any}\n", .{extra});
2639 // std.debug.print("{s}\n", .{sep});
2640
2641 const multi_cases_len = if (extra.data.bits.has_multi_cases) blk: {
2642 const multi_cases_len = file.zir.extra[extra_index];
2643 extra_index += 1;
2644 break :blk multi_cases_len;
2645 } else 0;
2646
2647 var else_index: ?usize = null;
2648 const special_prong = extra.data.bits.specialProng();
2649 if (special_prong != .none) {
2650 const body_len = file.zir.extra[extra_index];
2651 extra_index += 1;
2652 const body = file.zir.extra[extra_index..][0..body_len];
2653 extra_index += body.len;
2654 for (body) |_| {
2655 const item_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
2656 const item = try self.walkRef(file, parent_scope, item_ref, false);
2657 // std.debug.print("prong item_ref = {any}\n", .{item_ref});
2658 // std.debug.print("prong item = {any}\n", .{item});
2659 // std.debug.print("body member = {any}\n", .{body_member});
2660 const item_index = self.exprs.items.len;
2661 try self.exprs.append(self.arena, item.expr);
2662 else_index = item_index;
2663 }
2664 }
2665
2666 // var array_type: ?DocData.Expr = null;
2667 {
2668 const scalar_cases_len = extra.data.bits.scalar_cases_len;
2669 var scalar_i: usize = 0;
2670 while (scalar_i < scalar_cases_len) : (scalar_i += 1) {
2671 const item_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
2672 const item = try self.walkRef(file, parent_scope, item_ref, false);
2673 extra_index += 1;
2674 const body_len = file.zir.extra[extra_index];
2675 extra_index += 1;
2676 const body = file.zir.extra[extra_index..][0..body_len];
2677 extra_index += body_len;
2678 _ = body;
2679 array_data[scalar_i] = item.expr.as.exprArg;
2680
2681 const body_ref = @intToEnum(Ref, file.zir.extra[extra_index]);
2682 if (extra.data.bits.is_ref) {
2683 const body_item = try self.walkRef(file, parent_scope, body_ref, false);
2684 _ = body_item;
2685
2686 array_data[scalar_i] = item.expr.as.exprArg;
2687 } else {
2688 array_data[scalar_i] = 0;
2689 // TODO: this is wrong, decide an actual strategy
2690 }
2691 // std.debug.print("{s}\n", .{sep});
2692 // std.debug.print("body item_ref = {any}\n", .{item_ref});
2693 // std.debug.print("body item = {any}\n", .{item});
2694 // std.debug.print("body_len scalar cases = {any}\n", .{body_ref});
2695 // std.debug.print("body scalar cases = {any}\n", .{body_item});
2696 // std.debug.print("{s}\n", .{sep});
2697 }
2698 }
2699 {
2700 var multi_i: usize = 0;
2701 while (multi_i < multi_cases_len) : (multi_i += 1) {
2702 const items_len = file.zir.extra[extra_index];
2703 extra_index += 1;
2704 const ranges_len = file.zir.extra[extra_index];
2705 extra_index += 1;
2706 const body_len = file.zir.extra[extra_index];
2707 extra_index += 1;
2708 const items = file.zir.refSlice(extra_index, items_len);
2709 extra_index += items_len;
2710 _ = items;
2711
2712 var range_i: usize = 0;
2713 while (range_i < ranges_len) : (range_i += 1) {
2714 extra_index += 1;
2715 extra_index += 1;
2716 }
2717
2718 const body = file.zir.extra[extra_index..][0..body_len];
2719 extra_index += body_len;
2720 _ = body;
2721
2722 // std.debug.print("body multi_i = {any}\n", .{body});
2723 // std.debug.print("items = {any}\n", .{items});
2724 }
2725 }
2726
2727 // std.debug.print("multi_cases_len = {}\n", .{multi_cases_len});
1806 // std.debug.print("SWITCH BLOCK\n", .{});
1807 // std.debug.print("file path = {any}\n", .{file.sub_file_path});
1808 // std.debug.print("lazysrcloc = {any}\n", .{pl_node.src()});
1809 // std.debug.print("ast = {any}\n", .{ast});
27281810 // std.debug.print("{s}\n", .{sep});
27291811
27301812 const switch_index = self.exprs.items.len;
2731 try self.exprs.append(self.arena, .{ .switchOp = .{ .cases = array_data, .else_index = else_index } });
1813 try self.exprs.append(self.arena, .{ .switchOp = .{ .cond_index = cond_index, .node_name = ast.name orelse "", .file_name = file.sub_file_path, .line_start = ast.line } });
27321814
27331815 return DocData.WalkResult{
27341816 .typeRef = .{ .type = @enumToInt(Ref.type_type) },
......@@ -2746,13 +1828,6 @@ fn walkInstruction(
27461828 const operand_index = self.exprs.items.len;
27471829 try self.exprs.append(self.arena, operand.expr);
27481830
2749 // const sep = "=" ** 200;
2750 // std.debug.print("{s}\n", .{sep});
2751 // std.debug.print("SWITCH COND\n", .{});
2752 // std.debug.print("un_node {any} \n", .{un_node});
2753 // std.debug.print("operand {any} \n", .{operand});
2754 // std.debug.print("{s}\n", .{sep});
2755
27561831 return DocData.WalkResult{
27571832 .typeRef = operand.typeRef,
27581833 .expr = .{ .typeOf = operand_index },