authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-23 16:24:03-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-23 16:24:03-04:00
log1a90a5e63adfd585836aee2658275c02856a4427
tree5155190e962f0b9099f7bbd5ac91b1f07e0450c1
parente072692e1ffb6012d3d75051996bfcbbbd80e093

translate-c is building again, but I have 1 `@panic` in there

2 files changed, 106 insertions(+), 83 deletions(-)

src-self-hosted/main.zig+5-5
......@@ -743,15 +743,15 @@ fn printErrMsgToFile(
743743 const span_first = lok_token;
744744 const span_last = lok_token;
745745
746 const first_token = tree.tokens[span_first];
747 const last_token = tree.tokens[span_last];
748 const start_loc = tree.tokenLocationPtr(0, first_token);
749 const end_loc = tree.tokenLocationPtr(first_token.end, last_token);
746 const first_token = tree.token_locs[span_first];
747 const last_token = tree.token_locs[span_last];
748 const start_loc = tree.tokenLocationLoc(0, first_token);
749 const end_loc = tree.tokenLocationLoc(first_token.end, last_token);
750750
751751 var text_buf = std.ArrayList(u8).init(gpa);
752752 defer text_buf.deinit();
753753 const out_stream = text_buf.outStream();
754 try parse_error.render(tree.tokens, out_stream);
754 try parse_error.render(tree.token_ids, out_stream);
755755 const text = text_buf.span();
756756
757757 const stream = file.outStream();
src-self-hosted/translate_c.zig+101-78
......@@ -59,7 +59,7 @@ const Scope = struct {
5959 /// into the main arena.
6060 const Switch = struct {
6161 base: Scope,
62 pending_block: *Block,
62 pending_block: Block,
6363 cases: []*ast.Node,
6464 case_index: usize,
6565 has_default: bool = false,
......@@ -102,7 +102,7 @@ const Scope = struct {
102102 },
103103 .statements = std.ArrayList(*ast.Node).init(c.gpa),
104104 .variables = AliasList.init(c.gpa),
105 .label = if (self.label) |l| blk: {
105 .label = if (label) |l| blk: {
106106 const ll = try appendIdentifier(c, l);
107107 _ = try appendToken(c, .Colon, ":");
108108 break :blk ll;
......@@ -118,7 +118,10 @@ const Scope = struct {
118118 }
119119
120120 fn complete(self: *Block, c: *Context) !*ast.Node.Block {
121 const node = try ast.Node.Block.alloc(c.arena, self.statements.items.len);
121 // We reserve 1 extra statement if the parent is a Loop. This is in case of
122 // do while, we want to put `if (cond) break;` at the end.
123 const alloc_len = self.statements.items.len + @boolToInt(self.base.parent.?.id == .Loop);
124 const node = try ast.Node.Block.alloc(c.arena, alloc_len);
122125 node.* = .{
123126 .statements_len = self.statements.items.len,
124127 .lbrace = self.lbrace,
......@@ -137,13 +140,12 @@ const Scope = struct {
137140 scope.mangle_count += 1;
138141 proposed_name = try std.fmt.allocPrint(c.arena, "{}_{}", .{ name, scope.mangle_count });
139142 }
140 try scope.variables.push(.{ .name = name, .alias = proposed_name });
143 try scope.variables.append(.{ .name = name, .alias = proposed_name });
141144 return proposed_name;
142145 }
143146
144147 fn getAlias(scope: *Block, name: []const u8) []const u8 {
145 var it = scope.variables.iterator(0);
146 while (it.next()) |p| {
148 for (scope.variables.items) |p| {
147149 if (mem.eql(u8, p.name, name))
148150 return p.alias;
149151 }
......@@ -151,8 +153,7 @@ const Scope = struct {
151153 }
152154
153155 fn localContains(scope: *Block, name: []const u8) bool {
154 var it = scope.variables.iterator(0);
155 while (it.next()) |p| {
156 for (scope.variables.items) |p| {
156157 if (mem.eql(u8, p.name, name))
157158 return true;
158159 }
......@@ -407,7 +408,7 @@ pub fn translate(
407408
408409 if (false) {
409410 std.debug.warn("debug source:\n{}\n==EOF==\ntokens:\n", .{source_buffer.items});
410 for (context.tokens.items) |token| {
411 for (context.token_ids.items) |token| {
411412 std.debug.warn("{}\n", .{token});
412413 }
413414 }
......@@ -581,7 +582,7 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
581582 var scope = &block_scope.base;
582583
583584 var param_id: c_uint = 0;
584 for (proto_node.params()) |param, i| {
585 for (proto_node.params()) |*param, i| {
585586 const param_name = if (param.name_token) |name_tok|
586587 tokenSlice(c, name_tok)
587588 else if (param.param_type == .var_args) {
......@@ -623,7 +624,8 @@ fn visitFnDecl(c: *Context, fn_decl: *const ZigClangFunctionDecl) Error!void {
623624 error.UnsupportedType,
624625 => return failDecl(c, fn_decl_loc, fn_name, "unable to translate function", .{}),
625626 };
626 proto_node.body_node = try block_scope.complete(rp.c);
627 const body_node = try block_scope.complete(rp.c);
628 proto_node.body_node = &body_node.base;
627629 return addTopLevelDecl(c, fn_name, &proto_node.base);
628630}
629631
......@@ -964,7 +966,7 @@ fn transRecordDecl(c: *Context, record_decl: *const ZigClangRecordDecl) Error!?*
964966
965967 try addTopLevelDecl(c, name, &node.base);
966968 if (!is_unnamed)
967 try c.alias_list.push(.{ .alias = bare_name, .name = name });
969 try c.alias_list.append(.{ .alias = bare_name, .name = name });
968970 return transCreateNodeIdentifier(c, name);
969971}
970972
......@@ -1114,7 +1116,7 @@ fn transEnumDecl(c: *Context, enum_decl: *const ZigClangEnumDecl) Error!?*ast.No
11141116
11151117 try addTopLevelDecl(c, name, &node.base);
11161118 if (!is_unnamed)
1117 try c.alias_list.push(.{ .alias = bare_name, .name = name });
1119 try c.alias_list.append(.{ .alias = bare_name, .name = name });
11181120 return transCreateNodeIdentifier(c, name);
11191121}
11201122
......@@ -1245,7 +1247,7 @@ fn transBinaryOperator(
12451247 const rhs = try transExpr(rp, &block_scope.base, ZigClangBinaryOperator_getRHS(stmt), .used, .r_value);
12461248 if (expr) {
12471249 _ = try appendToken(rp.c, .Semicolon, ";");
1248 const break_node = try transCreateNodeBreak(rp.c, block_scope.label);
1250 const break_node = try transCreateNodeBreakToken(rp.c, block_scope.label);
12491251 break_node.rhs = rhs;
12501252 try block_scope.statements.append(&break_node.base);
12511253 const block_node = try block_scope.complete(rp.c);
......@@ -1418,7 +1420,7 @@ fn transCompoundStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCompo
14181420 var block_scope = try Scope.Block.init(rp.c, scope, null);
14191421 defer block_scope.deinit();
14201422 try transCompoundStmtInline(rp, &block_scope.base, stmt, &block_scope);
1421 const node = block_scope.complete(c);
1423 const node = try block_scope.complete(rp.c);
14221424 return &node.base;
14231425}
14241426
......@@ -1493,7 +1495,7 @@ fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt)
14931495
14941496 const mangled_name = try block_scope.makeMangledName(c, name);
14951497 if (checkForBuiltinTypedef(name)) |builtin| {
1496 try block_scope.variables.push(.{
1498 try block_scope.variables.append(.{
14971499 .alias = builtin,
14981500 .name = mangled_name,
14991501 });
......@@ -1511,7 +1513,8 @@ fn transDeclStmt(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangDeclStmt)
15111513 ),
15121514 }
15131515 }
1514 return &block_scope.block_node.base;
1516
1517 @panic("previously the code was returning the containing block scope node here and I do not understand why it would do that");
15151518}
15161519
15171520fn transDeclRefExpr(
......@@ -2135,11 +2138,11 @@ fn transInitListExprRecord(
21352138 _ = try appendToken(rp.c, .Comma, ",");
21362139 }
21372140
2138 _ = try appendToken(c, .LBrace, "{");
2141 _ = try appendToken(rp.c, .LBrace, "{");
21392142
21402143 const node = try ast.Node.StructInitializer.alloc(rp.c.arena, field_inits.items.len);
21412144 node.* = .{
2142 .lhs = ty,
2145 .lhs = ty_node,
21432146 .rtoken = try appendToken(rp.c, .RBrace, "}"),
21442147 .list_len = field_inits.items.len,
21452148 };
......@@ -2187,7 +2190,7 @@ fn transInitListExprArray(
21872190 const all_count = ZigClangAPInt_getLimitedValue(size_ap_int, math.maxInt(usize));
21882191 const leftover_count = all_count - init_count;
21892192
2190 var init_node: *ast.Node.SuffixOp = undefined;
2193 var init_node: *ast.Node.ArrayInitializer = undefined;
21912194 var cat_tok: ast.TokenIndex = undefined;
21922195 if (init_count != 0) {
21932196 const ty_node = try transCreateNodeArrayType(
......@@ -2196,11 +2199,19 @@ fn transInitListExprArray(
21962199 ZigClangQualType_getTypePtr(child_qt),
21972200 init_count,
21982201 );
2199 init_node = try transCreateNodeArrayInitializer(rp.c, ty_node);
2202 _ = try appendToken(rp.c, .LBrace, "{");
2203 init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, init_count);
2204 init_node.* = .{
2205 .lhs = ty_node,
2206 .rtoken = undefined,
2207 .list_len = init_count,
2208 };
2209 const init_list = init_node.list();
2210
22002211 var i: c_uint = 0;
22012212 while (i < init_count) : (i += 1) {
22022213 const elem_expr = ZigClangInitListExpr_getInit(expr, i);
2203 try init_node.op.ArrayInitializer.push(try transExpr(rp, scope, elem_expr, .used, .r_value));
2214 init_list[i] = try transExpr(rp, scope, elem_expr, .used, .r_value);
22042215 _ = try appendToken(rp.c, .Comma, ",");
22052216 }
22062217 init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
......@@ -2211,9 +2222,14 @@ fn transInitListExprArray(
22112222 }
22122223
22132224 const ty_node = try transCreateNodeArrayType(rp, loc, ZigClangQualType_getTypePtr(child_qt), 1);
2214 var filler_init_node = try transCreateNodeArrayInitializer(rp.c, ty_node);
2225 const filler_init_node = try ast.Node.ArrayInitializer.alloc(rp.c.arena, 1);
2226 filler_init_node.* = .{
2227 .lhs = ty_node,
2228 .rtoken = undefined,
2229 .list_len = 1,
2230 };
22152231 const filler_val_expr = ZigClangInitListExpr_getArrayFiller(expr);
2216 try filler_init_node.op.ArrayInitializer.push(try transExpr(rp, scope, filler_val_expr, .used, .r_value));
2232 filler_init_node.list()[0] = try transExpr(rp, scope, filler_val_expr, .used, .r_value);
22172233 filler_init_node.rtoken = try appendToken(rp.c, .RBrace, "}");
22182234
22192235 const rhs_node = if (leftover_count == 1)
......@@ -2443,7 +2459,8 @@ fn transDoWhileLoop(
24432459 // zig: b;
24442460 // zig: if (!cond) break;
24452461 // zig: }
2446 break :blk (try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value)).cast(ast.Node.Block).?;
2462 const node = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value);
2463 break :blk node.cast(ast.Node.Block).?;
24472464 } else blk: {
24482465 // the C statement is without a block, so we need to create a block to contain it.
24492466 // c: do
......@@ -2454,12 +2471,15 @@ fn transDoWhileLoop(
24542471 // zig: if (!cond) break;
24552472 // zig: }
24562473 new = true;
2457 const block = try transCreateNodeBlock(rp.c, null);
2458 try block.statements.push(try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value));
2474 const block = try rp.c.createBlock(null, 2);
2475 block.statements_len = 1; // over-allocated so we can add another below
2476 block.statements()[0] = try transStmt(rp, &loop_scope, ZigClangDoStmt_getBody(stmt), .unused, .r_value);
24592477 break :blk block;
24602478 };
24612479
2462 try body_node.statements.push(&if_node.base);
2480 // In both cases above, we reserved 1 extra statement.
2481 body_node.statements()[body_node.statements_len] = &if_node.base;
2482 body_node.statements_len += 1;
24632483 if (new)
24642484 body_node.rbrace = try appendToken(rp.c, .RBrace, "}");
24652485 while_node.body = &body_node.base;
......@@ -2482,8 +2502,8 @@ fn transForLoop(
24822502 if (ZigClangForStmt_getInit(stmt)) |init| {
24832503 block_scope = try Scope.Block.init(rp.c, scope, null);
24842504 loop_scope.parent = &block_scope.?.base;
2485 const result = try transStmt(rp, &block_scope.?.base, init, .unused, .r_value);
2486 try block_scope.statements.push(result);
2505 const init_node = try transStmt(rp, &block_scope.?.base, init, .unused, .r_value);
2506 try block_scope.?.statements.append(init_node);
24872507 }
24882508 var cond_scope = Scope.Condition{
24892509 .base = .{
......@@ -2509,8 +2529,8 @@ fn transForLoop(
25092529
25102530 while_node.body = try transStmt(rp, &loop_scope, ZigClangForStmt_getBody(stmt), .unused, .r_value);
25112531 if (block_scope) |*bs| {
2512 try bs.statements.push(&while_node.base);
2513 const node = bs.complete(rp.c);
2532 try bs.statements.append(&while_node.base);
2533 const node = try bs.complete(rp.c);
25142534 return &node.base;
25152535 } else {
25162536 _ = try appendToken(rp.c, .Semicolon, ";");
......@@ -2519,9 +2539,15 @@ fn transForLoop(
25192539}
25202540
25212541fn getSwitchCaseCount(stmt: *const ZigClangSwitchStmt) usize {
2522 const stmt = ZigClangSwitchStmt_getBody(stmt);
2523 const comp = ZigClangStmtExpr_getSubStmt(stmt);
2524 return ZigClangCompoundStmt_body_end(comp) - ZigClangCompoundStmt_body_begin(comp);
2542 const body = ZigClangSwitchStmt_getBody(stmt);
2543 assert(ZigClangStmt_getStmtClass(body) == .StmtExprClass);
2544 const stmt_expr = @ptrCast(*const ZigClangStmtExpr, body);
2545 const comp = ZigClangStmtExpr_getSubStmt(stmt_expr);
2546 // TODO https://github.com/ziglang/zig/issues/1738
2547 // return ZigClangCompoundStmt_body_end(comp) - ZigClangCompoundStmt_body_begin(comp);
2548 const start_addr = @ptrToInt(ZigClangCompoundStmt_body_begin(comp));
2549 const end_addr = @ptrToInt(ZigClangCompoundStmt_body_end(comp));
2550 return (end_addr - start_addr) / @sizeOf(*ZigClangStmt);
25252551}
25262552
25272553fn transSwitch(
......@@ -2532,7 +2558,7 @@ fn transSwitch(
25322558 const switch_tok = try appendToken(rp.c, .Keyword_switch, "switch");
25332559 _ = try appendToken(rp.c, .LParen, "(");
25342560
2535 const cases_len = getSwitchCaseCount(ZigClangSwitchStmt_getBody(stmt));
2561 const cases_len = getSwitchCaseCount(stmt);
25362562
25372563 var cond_scope = Scope.Condition{
25382564 .base = .{
......@@ -2594,8 +2620,8 @@ fn transSwitch(
25942620 const else_prong = try transCreateNodeSwitchCase(rp.c, try transCreateNodeSwitchElse(rp.c));
25952621 else_prong.expr = &(try transCreateNodeBreak(rp.c, "__switch")).base;
25962622 _ = try appendToken(rp.c, .Comma, ",");
2597 switch_node.cases[switch_node.case_index] = &else_prong.base;
2598 switch_node.case_index += 1;
2623 switch_scope.cases[switch_scope.case_index] = &else_prong.base;
2624 switch_scope.case_index += 1;
25992625 }
26002626 // We overallocated in case there was no default, so now we correct
26012627 // the number of cases in the AST node.
......@@ -2613,7 +2639,7 @@ fn transCase(
26132639) TransError!*ast.Node {
26142640 const block_scope = scope.findBlockScope(rp.c) catch unreachable;
26152641 const switch_scope = scope.getSwitch();
2616 const label = try std.fmt.allocPrint(rp.c.arena, "__case_{}", .{switch_scope.cases.len() - @boolToInt(switch_scope.has_default)});
2642 const label = try std.fmt.allocPrint(rp.c.arena, "__case_{}", .{switch_scope.case_index - @boolToInt(switch_scope.has_default)});
26172643 _ = try appendToken(rp.c, .Semicolon, ";");
26182644
26192645 const expr = if (ZigClangCaseStmt_getRHS(stmt)) |rhs| blk: {
......@@ -2775,7 +2801,7 @@ fn transStmtExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangStmtExpr,
27752801 return transCompoundStmt(rp, scope, comp);
27762802 }
27772803 const lparen = try appendToken(rp.c, .LParen, "(");
2778 const block_scope = try Scope.Block.init(rp.c, scope, "blk");
2804 var block_scope = try Scope.Block.init(rp.c, scope, "blk");
27792805 defer block_scope.deinit();
27802806
27812807 var it = ZigClangCompoundStmt_body_begin(comp);
......@@ -2892,7 +2918,7 @@ fn transCallExpr(rp: RestorePoint, scope: *Scope, stmt: *const ZigClangCallExpr,
28922918 raw_fn_expr;
28932919
28942920 const num_args = ZigClangCallExpr_getNumArgs(stmt);
2895 const node = try c.createCall(fn_expr, num_args);
2921 const node = try rp.c.createCall(fn_expr, num_args);
28962922 const call_params = node.params();
28972923
28982924 const args = ZigClangCallExpr_getArgs(stmt);
......@@ -3091,9 +3117,9 @@ fn transCreatePreCrement(
30913117 const assign = try transCreateNodeInfixOp(rp, scope, ref_node, op, token, one, .used, false);
30923118 try block_scope.statements.append(assign);
30933119
3094 const break_node = try transCreateNodeBreak(rp.c, block_scope.label);
3120 const break_node = try transCreateNodeBreakToken(rp.c, block_scope.label);
30953121 break_node.rhs = ref_node;
3096 try block_scope.statements.push(&break_node.base);
3122 try block_scope.statements.append(&break_node.base);
30973123 const block_node = try block_scope.complete(rp.c);
30983124 // semicolon must immediately follow rbrace because it is the last token in a block
30993125 _ = try appendToken(rp.c, .Semicolon, ";");
......@@ -3146,7 +3172,7 @@ fn transCreatePostCrement(
31463172 rhs_node.rhs = try transExpr(rp, scope, op_expr, .used, .r_value);
31473173 node.init_node = &rhs_node.base;
31483174 node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
3149 try block_scope.statements.push(&node.base);
3175 try block_scope.statements.append(&node.base);
31503176
31513177 const lhs_node = try transCreateNodeIdentifier(rp.c, ref);
31523178 const ref_node = try transCreateNodePtrDeref(rp.c, lhs_node);
......@@ -3157,17 +3183,17 @@ fn transCreatePostCrement(
31573183 tmp_node.eq_token = try appendToken(rp.c, .Equal, "=");
31583184 tmp_node.init_node = ref_node;
31593185 tmp_node.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
3160 try block_scope.statements.push(&tmp_node.base);
3186 try block_scope.statements.append(&tmp_node.base);
31613187
31623188 const token = try appendToken(rp.c, op_tok_id, bytes);
31633189 const one = try transCreateNodeInt(rp.c, 1);
31643190 _ = try appendToken(rp.c, .Semicolon, ";");
31653191 const assign = try transCreateNodeInfixOp(rp, scope, ref_node, op, token, one, .used, false);
3166 try block_scope.statements.push(assign);
3192 try block_scope.statements.append(assign);
31673193
3168 const break_node = try transCreateNodeBreak(rp.c, block_scope.label);
3194 const break_node = try transCreateNodeBreakToken(rp.c, block_scope.label);
31693195 break_node.rhs = try transCreateNodeIdentifier(rp.c, tmp);
3170 try block_scope.statements.push(&break_node.base);
3196 try block_scope.statements.append(&break_node.base);
31713197 _ = try appendToken(rp.c, .Semicolon, ";");
31723198 const block_node = try block_scope.complete(rp.c);
31733199 const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression);
......@@ -3337,7 +3363,7 @@ fn transCreateCompoundAssign(
33373363 try block_scope.statements.append(assign);
33383364 }
33393365
3340 const break_node = try transCreateNodeBreak(rp.c, block_scope.label);
3366 const break_node = try transCreateNodeBreakToken(rp.c, block_scope.label);
33413367 break_node.rhs = ref_node;
33423368 try block_scope.statements.append(&break_node.base);
33433369 const block_node = try block_scope.complete(rp.c);
......@@ -3457,7 +3483,7 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const
34573483 tmp_var.semicolon_token = try appendToken(rp.c, .Semicolon, ";");
34583484 try block_scope.statements.append(&tmp_var.base);
34593485
3460 const break_node = try transCreateNodeBreak(rp.c, block_scope.label);
3486 const break_node = try transCreateNodeBreakToken(rp.c, block_scope.label);
34613487
34623488 const if_node = try transCreateNodeIf(rp.c);
34633489 var cond_scope = Scope.Condition{
......@@ -3482,7 +3508,7 @@ fn transBinaryConditionalOperator(rp: RestorePoint, scope: *Scope, stmt: *const
34823508 break_node.rhs = &if_node.base;
34833509 _ = try appendToken(rp.c, .Semicolon, ";");
34843510 try block_scope.statements.append(&break_node.base);
3485 const block_node = block_scope.complete(rp.c);
3511 const block_node = try block_scope.complete(rp.c);
34863512
34873513 const grouped_expr = try rp.c.arena.create(ast.Node.GroupedExpression);
34883514 grouped_expr.* = .{
......@@ -3884,7 +3910,8 @@ fn transCreateNodeAssign(
38843910 // zig: lhs = _tmp;
38853911 // zig: break :blk _tmp
38863912 // zig: })
3887 var block_scope = try Scope.Block.init(rp.c, scope, "blk");
3913 const label_name = "blk";
3914 var block_scope = try Scope.Block.init(rp.c, scope, label_name);
38883915 defer block_scope.deinit();
38893916
38903917 const tmp = try block_scope.makeMangledName(rp.c, "tmp");
......@@ -3910,7 +3937,7 @@ fn transCreateNodeAssign(
39103937 const assign = try transCreateNodeInfixOp(rp, &block_scope.base, lhs_node, .Assign, eq_token, ident, .used, false);
39113938 try block_scope.statements.append(assign);
39123939
3913 const break_node = try transCreateNodeBreak(rp.c, block_scope.label);
3940 const break_node = try transCreateNodeBreak(rp.c, label_name);
39143941 break_node.rhs = try transCreateNodeIdentifier(rp.c, tmp);
39153942 _ = try appendToken(rp.c, .Semicolon, ";");
39163943 try block_scope.statements.append(&break_node.base);
......@@ -4134,19 +4161,6 @@ fn transCreateNodeBoolLiteral(c: *Context, value: bool) !*ast.Node {
41344161 return &node.base;
41354162}
41364163
4137fn transCreateNodeArrayInitializer(c: *Context, ty: *ast.Node) !*ast.Node.SuffixOp {
4138 _ = try appendToken(c, .LBrace, "{");
4139 const node = try c.arena.create(ast.Node.SuffixOp);
4140 node.* = .{
4141 .lhs = ty,
4142 .op = .{
4143 .ArrayInitializer = ast.Node.SuffixOp.Op.InitList{},
4144 },
4145 .rtoken = undefined, // set after appending values
4146 };
4147 return node;
4148}
4149
41504164fn transCreateNodeInt(c: *Context, int: var) !*ast.Node {
41514165 const token = try appendTokenFmt(c, .IntegerLiteral, "{}", .{int});
41524166 const node = try c.arena.create(ast.Node.IntegerLiteral);
......@@ -4306,6 +4320,13 @@ fn transCreateNodeElse(c: *Context) !*ast.Node.Else {
43064320 return node;
43074321}
43084322
4323fn transCreateNodeBreakToken(c: *Context, label: ?ast.TokenIndex) !*ast.Node.ControlFlowExpression {
4324 const other_token = label orelse return transCreateNodeBreak(c, null);
4325 const loc = c.token_locs.items[other_token];
4326 const label_name = c.source_buffer.items[loc.start..loc.end];
4327 return transCreateNodeBreak(c, label_name);
4328}
4329
43094330fn transCreateNodeBreak(c: *Context, label: ?[]const u8) !*ast.Node.ControlFlowExpression {
43104331 const ltoken = try appendToken(c, .Keyword_break, "break");
43114332 const label_node = if (label) |l| blk: {
......@@ -4379,14 +4400,14 @@ fn transCreateNodeContinue(c: *Context) !*ast.Node {
43794400fn transCreateNodeSwitchCase(c: *Context, lhs: *ast.Node) !*ast.Node.SwitchCase {
43804401 const arrow_tok = try appendToken(c, .EqualAngleBracketRight, "=>");
43814402
4382 const node = try c.arena.create(ast.Node.SwitchCase);
4403 const node = try ast.Node.SwitchCase.alloc(c.arena, 1);
43834404 node.* = .{
4384 .items = ast.Node.SwitchCase.ItemList{},
4405 .items_len = 1,
43854406 .arrow_token = arrow_tok,
43864407 .payload = null,
43874408 .expr = undefined,
43884409 };
4389 try node.items.push(lhs);
4410 node.items()[0] = lhs;
43904411 return node;
43914412}
43924413
......@@ -4464,7 +4485,8 @@ const RestorePoint = struct {
44644485 src_buf_index: usize,
44654486
44664487 fn activate(self: RestorePoint) void {
4467 self.c.tokens.shrink(self.c.gpa, self.token_index);
4488 self.c.token_ids.shrink(self.c.gpa, self.token_index);
4489 self.c.token_locs.shrink(self.c.gpa, self.token_index);
44684490 self.c.source_buffer.shrink(self.src_buf_index);
44694491 }
44704492};
......@@ -4472,7 +4494,7 @@ const RestorePoint = struct {
44724494fn makeRestorePoint(c: *Context) RestorePoint {
44734495 return RestorePoint{
44744496 .c = c,
4475 .token_index = c.tokens.items.len,
4497 .token_index = c.token_ids.items.len,
44764498 .src_buf_index = c.source_buffer.items.len,
44774499 };
44784500}
......@@ -5233,7 +5255,7 @@ fn transMacroFnDefine(c: *Context, it: *CTokenList.Iterator, source: []const u8,
52335255 _ = try appendToken(c, .Semicolon, ";");
52345256 const type_of_arg = if (expr.id != .Block) expr else blk: {
52355257 const blk = @fieldParentPtr(ast.Node.Block, "base", expr);
5236 const blk_last = blk.statements.first.?.findLast().data;
5258 const blk_last = blk.statements()[blk.statements_len - 1];
52375259 std.debug.assert(blk_last.id == .ControlFlowExpression);
52385260 const br = @fieldParentPtr(ast.Node.ControlFlowExpression, "base", blk_last);
52395261 break :blk br.rhs.?;
......@@ -5276,7 +5298,8 @@ fn parseCExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8, source_
52765298 },
52775299 .Comma => {
52785300 _ = try appendToken(c, .Semicolon, ";");
5279 var block_scope = try Scope.Block.init(c, scope, "blk");
5301 const label_name = "blk";
5302 var block_scope = try Scope.Block.init(c, scope, label_name);
52805303 defer block_scope.deinit();
52815304
52825305 var last = node;
......@@ -5301,7 +5324,7 @@ fn parseCExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8, source_
53015324 }
53025325 }
53035326
5304 const break_node = try transCreateNodeBreak(c, block_scope.label);
5327 const break_node = try transCreateNodeBreak(c, label_name);
53055328 break_node.rhs = last;
53065329 try block_scope.statements.append(&break_node.base);
53075330 const block_node = try block_scope.complete(c);
......@@ -5638,7 +5661,7 @@ fn parseCPrimaryExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
56385661 //else
56395662 // @as(dest, x) )
56405663 const if_node = try transCreateNodeIf(c);
5641 const type_info_node = try rp.c.createBuiltinCall("@typeInfo", 1);
5664 const type_info_node = try c.createBuiltinCall("@typeInfo", 1);
56425665 type_info_node.params()[0] = inner_node;
56435666 type_info_node.rparen_token = try appendToken(c, .LParen, ")");
56445667 const cmp_node = try c.arena.create(ast.Node.InfixOp);
......@@ -5710,7 +5733,7 @@ fn parseCPrimaryExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
57105733 .rhs = child_ident,
57115734 };
57125735
5713 const align_of = try rp.c.createBuiltinCall("@alignOf", 1);
5736 const align_of = try c.createBuiltinCall("@alignOf", 1);
57145737 align_of.params()[0] = &inner_node_child.base;
57155738 align_of.rparen_token = try appendToken(c, .RParen, ")");
57165739 // hack to get zig fmt to render a comma in builtin calls
......@@ -5818,7 +5841,7 @@ fn macroBoolToInt(c: *Context, node: *ast.Node) !*ast.Node {
58185841 return &group_node.base;
58195842 }
58205843
5821 const builtin_node = try rp.c.createBuiltinCall("@boolToInt", 1);
5844 const builtin_node = try c.createBuiltinCall("@boolToInt", 1);
58225845 builtin_node.params()[0] = node;
58235846 builtin_node.rparen_token = try appendToken(c, .RParen, ")");
58245847 return &builtin_node.base;
......@@ -6115,7 +6138,7 @@ fn parseCPrefixOpExpr(c: *Context, it: *CTokenList.Iterator, source: []const u8,
61156138}
61166139
61176140fn tokenSlice(c: *Context, token: ast.TokenIndex) []u8 {
6118 const tok = c.tokens.items[token];
6141 const tok = c.token_locs.items[token];
61196142 const slice = c.source_buffer.span()[tok.start..tok.end];
61206143 return if (mem.startsWith(u8, slice, "@\""))
61216144 slice[2 .. slice.len - 1]