| ... | ... | @@ -60,6 +60,7 @@ pub const Node = extern union { |
| 60 | 60 | tuple, |
| 61 | 61 | container_init, |
| 62 | 62 | std_meta_cast, |
| 63 | /// _ = operand; |
| 63 | 64 | discard, |
| 64 | 65 | |
| 65 | 66 | // a + b |
| ... | ... | @@ -67,43 +68,30 @@ pub const Node = extern union { |
| 67 | 68 | // a = b |
| 68 | 69 | add_assign, |
| 69 | 70 | // c = (a = b) |
| 70 | | add_assign_value, |
| 71 | 71 | add_wrap, |
| 72 | 72 | add_wrap_assign, |
| 73 | | add_wrap_assign_value, |
| 74 | 73 | sub, |
| 75 | 74 | sub_assign, |
| 76 | | sub_assign_value, |
| 77 | 75 | sub_wrap, |
| 78 | 76 | sub_wrap_assign, |
| 79 | | sub_wrap_assign_value, |
| 80 | 77 | mul, |
| 81 | 78 | mul_assign, |
| 82 | | mul_assign_value, |
| 83 | 79 | mul_wrap, |
| 84 | 80 | mul_wrap_assign, |
| 85 | | mul_wrap_assign_value, |
| 86 | 81 | div, |
| 87 | 82 | div_assign, |
| 88 | | div_assign_value, |
| 89 | 83 | shl, |
| 90 | 84 | shl_assign, |
| 91 | | shl_assign_value, |
| 92 | 85 | shr, |
| 93 | 86 | shr_assign, |
| 94 | | shr_assign_value, |
| 95 | 87 | mod, |
| 96 | 88 | mod_assign, |
| 97 | | mod_assign_value, |
| 98 | 89 | @"and", |
| 99 | 90 | and_assign, |
| 100 | | and_assign_value, |
| 101 | 91 | @"or", |
| 102 | 92 | or_assign, |
| 103 | | or_assign_value, |
| 104 | 93 | xor, |
| 105 | 94 | xor_assign, |
| 106 | | xor_assign_value, |
| 107 | 95 | less_than, |
| 108 | 96 | less_than_equal, |
| 109 | 97 | greater_than, |
| ... | ... | @@ -207,9 +195,6 @@ pub const Node = extern union { |
| 207 | 195 | /// [1]type{val} ** count |
| 208 | 196 | array_filler, |
| 209 | 197 | |
| 210 | | /// _ = operand; |
| 211 | | ignore, |
| 212 | | |
| 213 | 198 | pub const last_no_payload_tag = Tag.usingnamespace_builtins; |
| 214 | 199 | pub const no_payload_count = @enumToInt(last_no_payload_tag) + 1; |
| 215 | 200 | |
| ... | ... | @@ -249,7 +234,6 @@ pub const Node = extern union { |
| 249 | 234 | .while_true, |
| 250 | 235 | .if_not_break, |
| 251 | 236 | .switch_else, |
| 252 | | .ignore, |
| 253 | 237 | .block_single, |
| 254 | 238 | .std_meta_sizeof, |
| 255 | 239 | .bool_to_int, |
| ... | ... | @@ -260,43 +244,30 @@ pub const Node = extern union { |
| 260 | 244 | |
| 261 | 245 | .add, |
| 262 | 246 | .add_assign, |
| 263 | | .add_assign_value, |
| 264 | 247 | .add_wrap, |
| 265 | 248 | .add_wrap_assign, |
| 266 | | .add_wrap_assign_value, |
| 267 | 249 | .sub, |
| 268 | 250 | .sub_assign, |
| 269 | | .sub_assign_value, |
| 270 | 251 | .sub_wrap, |
| 271 | 252 | .sub_wrap_assign, |
| 272 | | .sub_wrap_assign_value, |
| 273 | 253 | .mul, |
| 274 | 254 | .mul_assign, |
| 275 | | .mul_assign_value, |
| 276 | 255 | .mul_wrap, |
| 277 | 256 | .mul_wrap_assign, |
| 278 | | .mul_wrap_assign_value, |
| 279 | 257 | .div, |
| 280 | 258 | .div_assign, |
| 281 | | .div_assign_value, |
| 282 | 259 | .shl, |
| 283 | 260 | .shl_assign, |
| 284 | | .shl_assign_value, |
| 285 | 261 | .shr, |
| 286 | 262 | .shr_assign, |
| 287 | | .shr_assign_value, |
| 288 | 263 | .mod, |
| 289 | 264 | .mod_assign, |
| 290 | | .mod_assign_value, |
| 291 | 265 | .@"and", |
| 292 | 266 | .and_assign, |
| 293 | | .and_assign_value, |
| 294 | 267 | .@"or", |
| 295 | 268 | .or_assign, |
| 296 | | .or_assign_value, |
| 297 | 269 | .xor, |
| 298 | 270 | .xor_assign, |
| 299 | | .xor_assign_value, |
| 300 | 271 | .less_than, |
| 301 | 272 | .less_than_equal, |
| 302 | 273 | .greater_than, |
| ... | ... | @@ -869,6 +840,14 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex { |
| 869 | 840 | .rhs = undefined, |
| 870 | 841 | }, |
| 871 | 842 | }), |
| 843 | .noreturn_type => return try c.addNode(.{ |
| 844 | .tag = .identifier, |
| 845 | .main_token = try c.addToken(.identifier, "noreturn"), |
| 846 | .data = .{ |
| 847 | .lhs = undefined, |
| 848 | .rhs = undefined, |
| 849 | }, |
| 850 | }), |
| 872 | 851 | .type => { |
| 873 | 852 | const payload = node.castTag(.type).?.data; |
| 874 | 853 | return c.addNode(.{ |
| ... | ... | @@ -880,6 +859,17 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex { |
| 880 | 859 | }, |
| 881 | 860 | }); |
| 882 | 861 | }, |
| 862 | .log2_int_type => { |
| 863 | const payload = node.castTag(.log2_int_type).?.data; |
| 864 | return c.addNode(.{ |
| 865 | .tag = .identifier, |
| 866 | .main_token = try c.addTokenFmt(.identifier, "u{d}", .{payload}), |
| 867 | .data = .{ |
| 868 | .lhs = undefined, |
| 869 | .rhs = undefined, |
| 870 | }, |
| 871 | }); |
| 872 | }, |
| 883 | 873 | .identifier => { |
| 884 | 874 | const payload = node.castTag(.identifier).?.data; |
| 885 | 875 | return c.addNode(.{ |
| ... | ... | @@ -1058,6 +1048,51 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex { |
| 1058 | 1048 | const payload = node.castTag(.ptr_cast).?.data; |
| 1059 | 1049 | return renderBuiltinCall(c, "@ptrCast", &.{ payload.lhs, payload.rhs }); |
| 1060 | 1050 | }, |
| 1051 | .sizeof => { |
| 1052 | const payload = node.castTag(.sizeof).?.data; |
| 1053 | return renderBuiltinCall(c, "@sizeOf", &.{payload}); |
| 1054 | }, |
| 1055 | .alignof => { |
| 1056 | const payload = node.castTag(.alignof).?.data; |
| 1057 | return renderBuiltinCall(c, "@alignOf", &.{payload}); |
| 1058 | }, |
| 1059 | .typeof => { |
| 1060 | const payload = node.castTag(.typeof).?.data; |
| 1061 | return renderBuiltinCall(c, "@TypeOf", &.{payload}); |
| 1062 | }, |
| 1063 | .negate => return renderPrefixOp(c, node, .negation, .minus, "-"), |
| 1064 | .negate_wrap => return renderPrefixOp(c, node, .negation_wrap, .minus_percent, "-%"), |
| 1065 | .bit_not => return renderPrefixOp(c, node, .bit_not, .tilde, "~"), |
| 1066 | .not => return renderPrefixOp(c, node, .bool_not, .bang, "!"), |
| 1067 | .optional_type => return renderPrefixOp(c, node, .optional_type, .question_mark, "?"), |
| 1068 | .address_of => return renderPrefixOp(c, node, .address_of, .ampersand, "&"), |
| 1069 | .deref => { |
| 1070 | const payload = node.castTag(.deref).?.data; |
| 1071 | const operand = try renderNodeGrouped(c, payload); |
| 1072 | const deref_tok = try c.addToken(.period_asterisk, ".*"); |
| 1073 | return c.addNode(.{ |
| 1074 | .tag = .deref, |
| 1075 | .main_token = deref_tok, |
| 1076 | .data = .{ |
| 1077 | .lhs = operand, |
| 1078 | .rhs = undefined, |
| 1079 | }, |
| 1080 | }); |
| 1081 | }, |
| 1082 | .unwrap => { |
| 1083 | const payload = node.castTag(.unwrap).?.data; |
| 1084 | const operand = try renderNodeGrouped(c, payload); |
| 1085 | const period = try c.addToken(.period, "."); |
| 1086 | const question_mark = try c.addToken(.question_mark, "?"); |
| 1087 | return c.addNode(.{ |
| 1088 | .tag = .unwrap_optional, |
| 1089 | .main_token = period, |
| 1090 | .data = .{ |
| 1091 | .lhs = operand, |
| 1092 | .rhs = question_mark, |
| 1093 | }, |
| 1094 | }); |
| 1095 | }, |
| 1061 | 1096 | else => return c.addNode(.{ |
| 1062 | 1097 | .tag = .identifier, |
| 1063 | 1098 | .main_token = try c.addTokenFmt(.identifier, "@\"TODO {}\"", .{node.tag()}), |
| ... | ... | @@ -1069,6 +1104,173 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex { |
| 1069 | 1104 | } |
| 1070 | 1105 | } |
| 1071 | 1106 | |
| 1107 | fn renderNodeGrouped(c: *Context, node: Node) !NodeIndex { |
| 1108 | switch (node.tag()) { |
| 1109 | .null_literal, |
| 1110 | .undefined_literal, |
| 1111 | .true_literal, |
| 1112 | .false_literal, |
| 1113 | .return_void, |
| 1114 | .zero_literal, |
| 1115 | .one_literal, |
| 1116 | .void_type, |
| 1117 | .noreturn_type, |
| 1118 | .@"anytype", |
| 1119 | .div_trunc, |
| 1120 | .rem, |
| 1121 | .int_cast, |
| 1122 | .as, |
| 1123 | .truncate, |
| 1124 | .bit_cast, |
| 1125 | .float_cast, |
| 1126 | .float_to_int, |
| 1127 | .int_to_float, |
| 1128 | .int_to_enum, |
| 1129 | .int_to_ptr, |
| 1130 | .std_mem_zeroes, |
| 1131 | .std_math_Log2Int, |
| 1132 | .log2_int_type, |
| 1133 | .ptr_to_int, |
| 1134 | .enum_to_int, |
| 1135 | .sizeof, |
| 1136 | .alignof, |
| 1137 | .typeof, |
| 1138 | .std_meta_sizeof, |
| 1139 | .std_meta_cast, |
| 1140 | .std_mem_zeroinit, |
| 1141 | .integer_literal, |
| 1142 | .float_literal, |
| 1143 | .string_literal, |
| 1144 | .char_literal, |
| 1145 | .identifier, |
| 1146 | .field_access, |
| 1147 | .ptr_cast, |
| 1148 | .type, |
| 1149 | .array_access, |
| 1150 | .align_cast, |
| 1151 | => { |
| 1152 | // no grouping needed |
| 1153 | return renderNode(c, node); |
| 1154 | }, |
| 1155 | |
| 1156 | .negate, |
| 1157 | .negate_wrap, |
| 1158 | .bit_not, |
| 1159 | .opaque_literal, |
| 1160 | .not, |
| 1161 | .optional_type, |
| 1162 | .address_of, |
| 1163 | .unwrap, |
| 1164 | .deref, |
| 1165 | .empty_array, |
| 1166 | .block_single, |
| 1167 | .bool_to_int, |
| 1168 | .add, |
| 1169 | .add_wrap, |
| 1170 | .sub, |
| 1171 | .sub_wrap, |
| 1172 | .mul, |
| 1173 | .mul_wrap, |
| 1174 | .div, |
| 1175 | .shl, |
| 1176 | .shr, |
| 1177 | .mod, |
| 1178 | .@"and", |
| 1179 | .@"or", |
| 1180 | .xor, |
| 1181 | .less_than, |
| 1182 | .less_than_equal, |
| 1183 | .greater_than, |
| 1184 | .greater_than_equal, |
| 1185 | .equal, |
| 1186 | .not_equal, |
| 1187 | .bit_and, |
| 1188 | .bit_or, |
| 1189 | .bit_xor, |
| 1190 | .empty_block, |
| 1191 | .array_cat, |
| 1192 | .array_filler, |
| 1193 | .@"if", |
| 1194 | .call, |
| 1195 | .@"enum", |
| 1196 | .@"struct", |
| 1197 | .@"union", |
| 1198 | .array_init, |
| 1199 | .tuple, |
| 1200 | .container_init, |
| 1201 | .block, |
| 1202 | .c_pointer, |
| 1203 | .single_pointer, |
| 1204 | .array_type, |
| 1205 | => return c.addNode(.{ |
| 1206 | .tag = .grouped_expression, |
| 1207 | .main_token = try c.addToken(.l_paren, "("), |
| 1208 | .data = .{ |
| 1209 | .lhs = try renderNode(c, node), |
| 1210 | .rhs = try c.addToken(.r_paren, ")"), |
| 1211 | }, |
| 1212 | }), |
| 1213 | .ellipsis3, |
| 1214 | .switch_prong, |
| 1215 | .warning, |
| 1216 | .var_decl, |
| 1217 | .func, |
| 1218 | .fail_decl, |
| 1219 | .arg_redecl, |
| 1220 | .alias, |
| 1221 | .var_simple, |
| 1222 | .pub_var_simple, |
| 1223 | .enum_redecl, |
| 1224 | .@"while", |
| 1225 | .@"switch", |
| 1226 | .@"break", |
| 1227 | .break_val, |
| 1228 | .pub_inline_fn, |
| 1229 | .discard, |
| 1230 | .@"continue", |
| 1231 | .@"return", |
| 1232 | .usingnamespace_builtins, |
| 1233 | .while_true, |
| 1234 | .if_not_break, |
| 1235 | .switch_else, |
| 1236 | .add_assign, |
| 1237 | .add_wrap_assign, |
| 1238 | .sub_assign, |
| 1239 | .sub_wrap_assign, |
| 1240 | .mul_assign, |
| 1241 | .mul_wrap_assign, |
| 1242 | .div_assign, |
| 1243 | .shl_assign, |
| 1244 | .shr_assign, |
| 1245 | .mod_assign, |
| 1246 | .and_assign, |
| 1247 | .or_assign, |
| 1248 | .xor_assign, |
| 1249 | .bit_and_assign, |
| 1250 | .bit_or_assign, |
| 1251 | .bit_xor_assign, |
| 1252 | .assign, |
| 1253 | => { |
| 1254 | // these should never appear in places where grouping might be needed. |
| 1255 | unreachable; |
| 1256 | }, |
| 1257 | } |
| 1258 | } |
| 1259 | |
| 1260 | fn renderPrefixOp(c: *Context, node: Node, tag: std.zig.ast.Node.Tag, tok_tag: TokenTag, bytes: []const u8) !NodeIndex { |
| 1261 | const payload = @fieldParentPtr(Payload.UnOp, "base", node.ptr_otherwise).data; |
| 1262 | const tok = try c.addToken(tok_tag, bytes); |
| 1263 | const operand = try renderNodeGrouped(c, payload); |
| 1264 | return c.addNode(.{ |
| 1265 | .tag = tag, |
| 1266 | .main_token = tok, |
| 1267 | .data = .{ |
| 1268 | .lhs = operand, |
| 1269 | .rhs = undefined, |
| 1270 | }, |
| 1271 | }); |
| 1272 | } |
| 1273 | |
| 1072 | 1274 | fn renderStdImport(c: *Context, first: []const u8, second: []const u8) !NodeIndex { |
| 1073 | 1275 | const import_tok = try c.addToken(.builtin, "@import"); |
| 1074 | 1276 | _ = try c.addToken(.l_paren, "("); |
Veikka Tuominen <git@vexu.eu> 2021-02-13 21:24:40+02:00