perf(html): reduce memory usage

5 files changed, 114 insertions, 53 deletions

diff --git a/src/eval/html/Content.zig b/src/eval/html/Content.zig
index f21bcf3..aed3a0e 100644
--- a/src/eval/html/Content.zig
+++ b/src/eval/html/Content.zig
@@ -1,11 +1,15 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const List = std.ArrayList;
 const Element = @import("Element.zig");
+const Node = Element.Node;
 const Error = Element.Error;
 
 base: Element.Void,
-content: List(Element),
+content: ?Element = null,
+node: Node = .{
+    .ptr = undefined,
+    .vtable = .{ .element = fromNode },
+},
 
 pub const Self = @This();
 
@@ -18,17 +22,23 @@ pub fn init(alloc: Allocator, tag: []const u8) Error!*Self {
             .attributes = .init(alloc),
             .class_list = .init(alloc),
         },
-        .content = try .initCapacity(alloc, 2),
     };
+    v.node.ptr = v;
     return v;
 }
 
 pub fn element(self: *Self) Element {
-    return .{ .vtable = .{ .render = Self.render }, .ptr = self };
+    return .{ .vtable = .{ .render = render, .node = getNode }, .ptr = self };
 }
 
-pub fn append(self: *Self, content: Element) Error!void {
-    return self.content.append(self.base.alloc, content);
+fn getNode(context: *anyopaque) *Node {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return &self.node;
+}
+
+fn fromNode(context: *anyopaque) Element {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return self.element();
 }
 
 fn render(context: *anyopaque, alloc: Allocator) Error![]const u8 {
@@ -36,14 +46,15 @@ fn render(context: *anyopaque, alloc: Allocator) Error![]const u8 {
     var base = self.base;
     const b = try base.element().render(alloc);
     defer alloc.free(b);
-    var acc = try List(u8).initCapacity(alloc, b.len + self.content.items.len);
+    var acc = try std.ArrayList(u8).initCapacity(alloc, b.len * 2);
     try acc.appendSlice(alloc, b);
-    for (self.content.items) |it| {
-        var v = it;
-        const sub = try v.render(alloc);
+
+    if (self.content) |it| {
+        const sub = try it.render(alloc);
         defer alloc.free(sub);
         try acc.appendSlice(alloc, sub);
     }
+
     try acc.appendSlice(alloc, "</");
     try acc.appendSlice(alloc, base.tag);
     try acc.append(alloc, '>');
diff --git a/src/eval/html/Element.zig b/src/eval/html/Element.zig
index 6bccc0f..6073e6a 100644
--- a/src/eval/html/Element.zig
+++ b/src/eval/html/Element.zig
@@ -2,28 +2,47 @@ const std = @import("std");
 const Arena = std.heap.ArenaAllocator;
 const Allocator = std.mem.Allocator;
 const eql = std.mem.eql;
-const List = std.ArrayList;
 const html = @import("html.zig");
 
 pub const Void = @import("Void.zig");
-pub const Content  = @import("Content.zig");
+pub const Content = @import("Content.zig");
 pub const Literal = @import("Literal.zig");
 pub const Root = @import("Root.zig");
 
 pub const Error = html.Error || Allocator.Error;
 
-const Element = @This();
+pub const Node = struct {
+    ptr: *anyopaque,
+    vtable: struct { element: *const fn (*anyopaque) Self },
+    node: std.DoublyLinkedList.Node = .{},
+
+    pub fn from(n: *std.DoublyLinkedList.Node) *Node {
+        const v: *Node = @fieldParentPtr("node", n);
+        return v;
+    }
+
+    pub fn element(self: Node) Self {
+        return self.vtable.element(self.ptr);
+    }
+};
+
+const Self = @This();
 
 vtable: struct {
     render: *const fn (self: *anyopaque, alloc: Allocator) Error![]const u8,
+    node: *const fn (self: *anyopaque) *Node,
 },
 ptr: *anyopaque,
 
-pub fn render(self: Element, alloc: Allocator) Error![]const u8 {
+pub fn render(self: Self, alloc: Allocator) Error![]const u8 {
     return self.vtable.render(self.ptr, alloc);
 }
 
-fn doTest(alloc: Allocator, el: Element, exp: []const u8) !void {
+pub fn node(self: Self) *Node {
+    return self.vtable.node(self.ptr);
+}
+
+fn doTest(alloc: Allocator, el: Self, exp: []const u8) !void {
     const got = try el.render(alloc);
     defer alloc.free(got);
     std.testing.expect(eql(u8, got, exp)) catch |err| {
@@ -54,33 +73,21 @@ test "content" {
     const alloc = arena.allocator();
 
     var p = try Content.init(alloc, "p");
+    var root = try Root.init(alloc);
+    p.content = root.element();
 
     var content = try Literal.init(alloc, "hello world");
-    try p.append(content.element());
+    root.append(content.element());
 
     try doTest(alloc, content.element(), "hello world");
     try doTest(alloc, p.element(), "<p>hello world</p>");
 
     var div = try Content.init(alloc, "div");
+    var rootDiv = try Root.init(alloc);
+    div.content = rootDiv.element();
     try div.base.appendClass("foo-bar");
-    try div.append(p.element());
-    try div.append((try Void.init(alloc, "br")).element());
+    rootDiv.append(p.element());
+    rootDiv.append((try Void.init(alloc, "br")).element());
 
     try doTest(alloc, div.element(), "<div class=\"foo-bar\"><p>hello world</p><br></div>");
 }
-
-test "root" {
-    const root = try Root.init(std.testing.allocator);
-    defer root.deinit();
-    const alloc = root.allocator();
-
-    var p = try Content.init(alloc, "p");
-    var content = try Literal.init(alloc, "hello world");
-    try p.append(content.element());
-    try root.append(p.element());
-
-    var br = try Void.init(alloc, "br");
-    try root.append(br.element());
-
-    try doTest(alloc, root.element(), "<p>hello world</p><br>");
-}
diff --git a/src/eval/html/Literal.zig b/src/eval/html/Literal.zig
index d3b697f..ccad004 100644
--- a/src/eval/html/Literal.zig
+++ b/src/eval/html/Literal.zig
@@ -1,22 +1,37 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
-const List = std.ArrayList;
 const html = @import("html.zig");
 const Element = @import("Element.zig");
+const Node = Element.Node;
 const Error = Element.Error;
 
 literal: []const u8,
+node: Node = .{
+    .ptr = undefined,
+    .vtable = .{ .element = fromNode },
+},
 
 const Self = @This();
 
 pub fn init(alloc: Allocator, literal: []const u8) Error!*Element.Literal {
     const v = try alloc.create(Self);
     v.* = .{ .literal = try html.escape(alloc, literal) };
+    v.node.ptr = v;
     return v;
 }
 
 pub fn element(self: *Self) Element {
-    return .{ .vtable = .{ .render = Self.render }, .ptr = self };
+    return .{ .vtable = .{ .render = render, .node = getNode }, .ptr = self };
+}
+
+fn getNode(context: *anyopaque) *Node {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return &self.node;
+}
+
+fn fromNode(context: *anyopaque) Element {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return self.element();
 }
 
 fn render(context: *anyopaque, alloc: Allocator) Error![]const u8 {
diff --git a/src/eval/html/Root.zig b/src/eval/html/Root.zig
index 80c556a..440667a 100644
--- a/src/eval/html/Root.zig
+++ b/src/eval/html/Root.zig
@@ -1,24 +1,25 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const Arena = std.heap.ArenaAllocator;
-const List = std.ArrayList;
 const Element = @import("Element.zig");
+const Node = Element.Node;
 const Error = Element.Error;
 
-content: List(Element),
+content: std.DoublyLinkedList = .{},
 arena: Arena,
+node: Node = .{
+    .ptr = undefined,
+    .vtable = .{ .element = fromNode },
+},
 
 const Self = @This();
 
 pub fn init(parent: Allocator) Error!*Self {
-    var s = Self{
-        .content = undefined,
-        .arena = .init(parent),
-    };
+    var s = Self{ .arena = .init(parent) };
     var alloc = s.arena.allocator();
-    s.content = try .initCapacity(alloc, 2);
     const v = try alloc.create(Self);
     v.* = s;
+    v.node.ptr = v;
     return v;
 }
 
@@ -27,28 +28,39 @@ pub fn deinit(self: *Self) void {
 }
 
 pub fn element(self: *Self) Element {
-    return .{ .vtable = .{ .render = Self.render, }, .ptr = self };
+    return .{ .vtable = .{
+        .render = render,
+        .node = getNode,
+    }, .ptr = self };
 }
 
 pub fn allocator(self: *Self) Allocator {
     return self.arena.allocator();
 }
 
-pub fn append(self: *Self, el: Element) Error!void {
-    try self.content.append(self.allocator(), el);
+pub fn append(self: *Self, el: Element) void {
+    self.content.append(&el.node().node);
+}
+
+fn getNode(context: *anyopaque) *Node {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return &self.node;
+}
+
+fn fromNode(context: *anyopaque) Element {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return self.element();
 }
 
 fn render(context: *anyopaque, alloc: Allocator) Error![]const u8 {
     const self: *Self = @ptrCast(@alignCast(context));
-    if (self.content.items.len == 0) return "";
-    var acc = try List(u8).initCapacity(alloc, self.content.items.len);
+    if (self.content.first == null) return "";
+    var acc = try std.ArrayList(u8).initCapacity(alloc, 8);
     errdefer acc.deinit(alloc);
 
     var arena = Arena.init(alloc);
     defer arena.deinit();
-    for (self.content.items) |it| {
-        const res = try it.render(arena.allocator());
-        try acc.appendSlice(alloc, res);
-    }
+    var v = self.content.first;
+    while (v) |it| : (v = it.next) try acc.appendSlice(alloc, try Node.from(it).element().render(arena.allocator()));
     return acc.toOwnedSlice(alloc);
 }
diff --git a/src/eval/html/Void.zig b/src/eval/html/Void.zig
index ec35fc7..99bc923 100644
--- a/src/eval/html/Void.zig
+++ b/src/eval/html/Void.zig
@@ -3,12 +3,17 @@ const Allocator = std.mem.Allocator;
 const List = std.ArrayList;
 const html = @import("html.zig");
 const Element = @import("Element.zig");
+const Node = Element.Node;
 const Error = Element.Error;
 
 alloc: Allocator,
 tag: []const u8,
 attributes: std.StringArrayHashMap([]const u8),
 class_list: std.BufSet,
+node: Node = .{
+    .ptr = undefined,
+    .vtable = .{ .element = fromNode },
+},
 
 pub const Self = @This();
 
@@ -20,11 +25,12 @@ pub fn init(alloc: Allocator, tag: []const u8) Error!*Self {
         .attributes = .init(alloc),
         .class_list = .init(alloc),
     };
+    v.node.ptr = v;
     return v;
 }
 
 pub fn element(self: *Self) Element {
-    return .{ .vtable = .{ .render = Self.render }, .ptr = self };
+    return .{ .vtable = .{ .render = render, .node = getNode }, .ptr = self };
 }
 
 pub fn setAttribute(self: *Self, k: []const u8, v: []const u8) Error!void {
@@ -51,6 +57,16 @@ pub fn removeClass(self: *Self, v: []const u8) void {
     self.class_list.remove(v);
 }
 
+fn getNode(context: *anyopaque) *Node {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return &self.node;
+}
+
+fn fromNode(context: *anyopaque) Element {
+    const self: *Self = @ptrCast(@alignCast(context));
+    return self.element();
+}
+
 fn render(context: *anyopaque, alloc: Allocator) Error![]const u8 {
     const self: *Self = @ptrCast(@alignCast(context));
     const attr = try renderAttribute(alloc, &self.attributes, &self.class_list);