authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-21 22:28:30-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2020-05-21 22:28:30-04:00
log9377af934f5be92821f36b5d2255f086e5a84cda
treee58814eecf85d3e59da6b7bc04c6a432fd1689cd
parentd37b81d43bc52daa94dd1ad1631018ea0cd11f77

stage2 parser: SwitchCase uses intrusive array instead of linkedlist

no perf impact, but the API is better

3 files changed, 49 insertions(+), 29 deletions(-)

lib/std/zig/ast.zig+30-9
......@@ -1552,28 +1552,35 @@ pub const Node = struct {
15521552 }
15531553 };
15541554
1555 /// Items sub-nodes appear in memory directly following SwitchCase.
15551556 pub const SwitchCase = struct {
15561557 base: Node = Node{ .id = .SwitchCase },
1557 items: ItemList,
15581558 arrow_token: TokenIndex,
15591559 payload: ?*Node,
15601560 expr: *Node,
1561 items_len: NodeIndex,
15611562
1562 pub const ItemList = LinkedList(*Node);
1563 /// After this the caller must initialize the fields_and_decls list.
1564 pub fn alloc(allocator: *mem.Allocator, items_len: NodeIndex) !*SwitchCase {
1565 const bytes = try allocator.alignedAlloc(u8, @alignOf(SwitchCase), sizeInBytes(items_len));
1566 return @ptrCast(*SwitchCase, bytes.ptr);
1567 }
1568
1569 pub fn free(self: *SwitchCase, allocator: *mem.Allocator) void {
1570 const bytes = @ptrCast([*]u8, self)[0..sizeInBytes(self.items_len)];
1571 allocator.free(bytes);
1572 }
15631573
15641574 pub fn iterate(self: *const SwitchCase) Node.Iterator {
1565 return .{ .parent_node = &self.base, .index = 0, .node = self.items.first };
1575 return .{ .parent_node = &self.base, .index = 0, .node = null };
15661576 }
15671577
15681578 pub fn iterateNext(self: *const SwitchCase, it: *Node.Iterator) ?*Node {
15691579 var i = it.index;
15701580 it.index += 1;
15711581
1572 if (it.node) |child| {
1573 it.index -= 1;
1574 it.node = child.next;
1575 return child.data;
1576 }
1582 if (i < self.items_len) return self.itemsConst()[i];
1583 i -= self.items_len;
15771584
15781585 if (self.payload) |payload| {
15791586 if (i < 1) return payload;
......@@ -1587,12 +1594,26 @@ pub const Node = struct {
15871594 }
15881595
15891596 pub fn firstToken(self: *const SwitchCase) TokenIndex {
1590 return self.items.first.?.data.firstToken();
1597 return self.itemsConst()[0].firstToken();
15911598 }
15921599
15931600 pub fn lastToken(self: *const SwitchCase) TokenIndex {
15941601 return self.expr.lastToken();
15951602 }
1603
1604 pub fn items(self: *SwitchCase) []*Node {
1605 const decls_start = @ptrCast([*]u8, self) + @sizeOf(SwitchCase);
1606 return @ptrCast([*]*Node, decls_start)[0..self.items_len];
1607 }
1608
1609 pub fn itemsConst(self: *const SwitchCase) []const *Node {
1610 const decls_start = @ptrCast([*]const u8, self) + @sizeOf(SwitchCase);
1611 return @ptrCast([*]const *Node, decls_start)[0..self.items_len];
1612 }
1613
1614 fn sizeInBytes(items_len: NodeIndex) usize {
1615 return @sizeOf(SwitchCase) + @sizeOf(*Node) * @as(usize, items_len);
1616 }
15961617 };
15971618
15981619 pub const SwitchElse = struct {
lib/std/zig/parse.zig+8-7
......@@ -2205,30 +2205,31 @@ const Parser = struct {
22052205 /// <- SwitchItem (COMMA SwitchItem)* COMMA?
22062206 /// / KEYWORD_else
22072207 fn parseSwitchCase(p: *Parser) !?*Node {
2208 var list = Node.SwitchCase.ItemList{};
2209 var list_it = &list.first;
2208 var list = std.ArrayList(*Node).init(p.gpa);
2209 defer list.deinit();
22102210
22112211 if (try p.parseSwitchItem()) |first_item| {
2212 list_it = try p.llpush(*Node, list_it, first_item);
2212 try list.append(first_item);
22132213 while (p.eatToken(.Comma) != null) {
22142214 const next_item = (try p.parseSwitchItem()) orelse break;
2215 list_it = try p.llpush(*Node, list_it, next_item);
2215 try list.append(next_item);
22162216 }
22172217 } else if (p.eatToken(.Keyword_else)) |else_token| {
22182218 const else_node = try p.arena.allocator.create(Node.SwitchElse);
22192219 else_node.* = .{
22202220 .token = else_token,
22212221 };
2222 list_it = try p.llpush(*Node, list_it, &else_node.base);
2222 try list.append(&else_node.base);
22232223 } else return null;
22242224
2225 const node = try p.arena.allocator.create(Node.SwitchCase);
2225 const node = try Node.SwitchCase.alloc(&p.arena.allocator, list.items.len);
22262226 node.* = .{
2227 .items = list,
2227 .items_len = list.items.len,
22282228 .arrow_token = undefined, // set by caller
22292229 .payload = null,
22302230 .expr = undefined, // set by caller
22312231 };
2232 std.mem.copy(*Node, node.items(), list.items);
22322233 return &node.base;
22332234 }
22342235
lib/std/zig/render.zig+11-13
......@@ -1613,37 +1613,35 @@ fn renderExpression(
16131613 .SwitchCase => {
16141614 const switch_case = @fieldParentPtr(ast.Node.SwitchCase, "base", base);
16151615
1616 assert(switch_case.items.first != null);
1616 assert(switch_case.items_len != 0);
16171617 const src_has_trailing_comma = blk: {
1618 const last_node = switch_case.items.first.?.findLast().data;
1618 const last_node = switch_case.items()[switch_case.items_len - 1];
16191619 const maybe_comma = tree.nextToken(last_node.lastToken());
16201620 break :blk tree.tokens[maybe_comma].id == .Comma;
16211621 };
16221622
1623 if (switch_case.items.first.?.next == null or !src_has_trailing_comma) {
1624 var it = switch_case.items.first;
1625 while (it) |node_node| : (it = node_node.next) {
1626 const node = node_node.data;
1627 if (node_node.next) |next_node| {
1623 if (switch_case.items_len == 1 or !src_has_trailing_comma) {
1624 const items = switch_case.items();
1625 for (items) |node, i| {
1626 if (i + 1 < items.len) {
16281627 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
16291628
16301629 const comma_token = tree.nextToken(node.lastToken());
16311630 try renderToken(tree, stream, comma_token, indent, start_col, Space.Space); // ,
1632 try renderExtraNewline(tree, stream, start_col, next_node.data);
1631 try renderExtraNewline(tree, stream, start_col, items[i + 1]);
16331632 } else {
16341633 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Space);
16351634 }
16361635 }
16371636 } else {
1638 var it = switch_case.items.first;
1639 while (it) |node_node| : (it = node_node.next) {
1640 const node = node_node.data;
1641 if (node_node.next) |next_node| {
1637 const items = switch_case.items();
1638 for (items) |node, i| {
1639 if (i + 1 < items.len) {
16421640 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.None);
16431641
16441642 const comma_token = tree.nextToken(node.lastToken());
16451643 try renderToken(tree, stream, comma_token, indent, start_col, Space.Newline); // ,
1646 try renderExtraNewline(tree, stream, start_col, next_node.data);
1644 try renderExtraNewline(tree, stream, start_col, items[i + 1]);
16471645 try stream.writeByteNTimes(' ', indent);
16481646 } else {
16491647 try renderExpression(allocator, stream, tree, indent, start_col, node, Space.Comma);