fix callback crash with Node.Union

sjorsdonkers · sjorsdonkers · commit 2842fcadde84 · 2025-07-11T09:58:37.000+02:00
diff --git a/src/browser/dom/node_filter.zig b/src/browser/dom/node_filter.zig
@@ -19,6 +19,7 @@
 const std = @import("std");
 const parser = @import("../netsurf.zig");
 const Env = @import("../env.zig").Env;
+const Node = @import("node.zig").Node;
 
 pub const NodeFilter = struct {
     pub const _FILTER_ACCEPT: u16 = 1;
@@ -63,7 +64,7 @@ pub fn verify(what_to_show: u32, filter: ?Env.Function, node: *parser.Node) !Ver
 
     // Verify that we aren't filtering it out.
     if (filter) |f| {
-        const acceptance = try f.call(u16, .{node});
+        const acceptance = try f.call(u16, .{try Node.toInterface(node)});
         return switch (acceptance) {
             NodeFilter._FILTER_ACCEPT => .accept,
             NodeFilter._FILTER_REJECT => .reject,
diff --git a/src/browser/dom/node_iterator.zig b/src/browser/dom/node_iterator.zig
@@ -20,9 +20,11 @@ const std = @import("std");
 const parser = @import("../netsurf.zig");
 const Env = @import("../env.zig").Env;
 const NodeFilter = @import("node_filter.zig");
+const Node = @import("node.zig").Node;
+const NodeUnion = @import("node.zig").Union;
 
 // https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator
-// While this is similar to TreeWalker it has it's own implementation as there are several suttle differences
+// While this is similar to TreeWalker it has its own implementation as there are several subtle differences
 // For example:
 // - nextNode returns the reference node, whereas TreeWalker returns the next node
 // - Skip and reject are equivalent for NodeIterator, for TreeWalker they are different
@@ -66,36 +68,36 @@ pub const NodeIterator = struct {
         return self.pointer_before_current;
     }
 
-    pub fn get_referenceNode(self: *const NodeIterator) *parser.Node {
-        return self.reference_node;
+    pub fn get_referenceNode(self: *const NodeIterator) !NodeUnion {
+        return try Node.toInterface(self.reference_node);
     }
 
-    pub fn get_root(self: *const NodeIterator) *parser.Node {
-        return self.root;
+    pub fn get_root(self: *const NodeIterator) !NodeUnion {
+        return try Node.toInterface(self.root);
     }
 
     pub fn get_whatToShow(self: *const NodeIterator) u32 {
         return self.what_to_show;
     }
 
-    pub fn _nextNode(self: *NodeIterator) !?*parser.Node {
+    pub fn _nextNode(self: *NodeIterator) !?NodeUnion {
         if (self.pointer_before_current) { // Unlike TreeWalker, NodeIterator starts at the first node
             self.pointer_before_current = false;
             if (.accept == try NodeFilter.verify(self.what_to_show, self.filter_func, self.reference_node)) {
-                return self.reference_node;
+                return try Node.toInterface(self.reference_node);
             }
         }
 
         if (try self.firstChild(self.reference_node)) |child| {
             self.reference_node = child;
-            return child;
+            return try Node.toInterface(child);
         }
 
         var current = self.reference_node;
         while (current != self.root) {
             if (try self.nextSibling(current)) |sibling| {
                 self.reference_node = sibling;
-                return sibling;
+                return try Node.toInterface(sibling);
             }
 
             current = (try parser.nodeParentNode(current)) orelse break;
@@ -104,11 +106,11 @@ pub const NodeIterator = struct {
         return null;
     }
 
-    pub fn _previousNode(self: *NodeIterator) !?*parser.Node {
+    pub fn _previousNode(self: *NodeIterator) !?NodeUnion {
         if (!self.pointer_before_current) {
             self.pointer_before_current = true;
             if (.accept == try NodeFilter.verify(self.what_to_show, self.filter_func, self.reference_node)) {
-                return self.reference_node; // Still need to verify as last may be first as well
+                return try Node.toInterface(self.reference_node); // Still need to verify as last may be first as well
             }
         }
         if (self.reference_node == self.root) return null;
@@ -122,18 +124,18 @@ pub const NodeIterator = struct {
                     // Get last child if it has one.
                     if (try self.lastChild(current)) |child| {
                         self.reference_node = child;
-                        return child;
+                        return try Node.toInterface(child);
                     }
 
                     // Otherwise, this node is our previous one.
                     self.reference_node = current;
-                    return current;
+                    return try Node.toInterface(current);
                 },
                 .reject, .skip => {
                     // Get last child if it has one.
                     if (try self.lastChild(current)) |child| {
                         self.reference_node = child;
-                        return child;
+                        return try Node.toInterface(child);
                     }
                 },
             }
@@ -142,7 +144,7 @@ pub const NodeIterator = struct {
         if (current != self.root) {
             if (try self.parentNode(current)) |parent| {
                 self.reference_node = parent;
-                return parent;
+                return try Node.toInterface(parent);
             }
         }
 
diff --git a/src/browser/dom/tree_walker.zig b/src/browser/dom/tree_walker.zig
@@ -22,6 +22,8 @@ const parser = @import("../netsurf.zig");
 const NodeFilter = @import("node_filter.zig");
 const Env = @import("../env.zig").Env;
 const Page = @import("../page.zig").Page;
+const Node = @import("node.zig").Node;
+const NodeUnion = @import("node.zig").Union;
 
 // https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
 pub const TreeWalker = struct {
@@ -55,12 +57,12 @@ pub const TreeWalker = struct {
         };
     }
 
-    pub fn get_root(self: *TreeWalker) *parser.Node {
-        return self.root;
+    pub fn get_root(self: *TreeWalker) !NodeUnion {
+        return try Node.toInterface(self.root);
     }
 
-    pub fn get_currentNode(self: *TreeWalker) *parser.Node {
-        return self.current_node;
+    pub fn get_currentNode(self: *TreeWalker) !NodeUnion {
+        return try Node.toInterface(self.current_node);
     }
 
     pub fn get_whatToShow(self: *TreeWalker) u32 {
@@ -157,35 +159,35 @@ pub const TreeWalker = struct {
         }
     }
 
-    pub fn _firstChild(self: *TreeWalker) !?*parser.Node {
+    pub fn _firstChild(self: *TreeWalker) !?NodeUnion {
         if (try self.firstChild(self.current_node)) |child| {
             self.current_node = child;
-            return child;
+            return try Node.toInterface(child);
         }
 
         return null;
     }
 
-    pub fn _lastChild(self: *TreeWalker) !?*parser.Node {
+    pub fn _lastChild(self: *TreeWalker) !?NodeUnion {
         if (try self.lastChild(self.current_node)) |child| {
             self.current_node = child;
-            return child;
+            return try Node.toInterface(child);
         }
 
         return null;
     }
 
-    pub fn _nextNode(self: *TreeWalker) !?*parser.Node {
+    pub fn _nextNode(self: *TreeWalker) !?NodeUnion {
         if (try self.firstChild(self.current_node)) |child| {
             self.current_node = child;
-            return child;
+            return try Node.toInterface(child);
         }
 
         var current = self.current_node;
         while (current != self.root) {
             if (try self.nextSibling(current)) |sibling| {
                 self.current_node = sibling;
-                return sibling;
+                return try Node.toInterface(sibling);
             }
 
             current = (try parser.nodeParentNode(current)) orelse break;
@@ -194,25 +196,25 @@ pub const TreeWalker = struct {
         return null;
     }
 
-    pub fn _nextSibling(self: *TreeWalker) !?*parser.Node {
+    pub fn _nextSibling(self: *TreeWalker) !?NodeUnion {
         if (try self.nextSibling(self.current_node)) |sibling| {
             self.current_node = sibling;
-            return sibling;
+            return try Node.toInterface(sibling);
         }
 
         return null;
     }
 
-    pub fn _parentNode(self: *TreeWalker) !?*parser.Node {
+    pub fn _parentNode(self: *TreeWalker) !?NodeUnion {
         if (try self.parentNode(self.current_node)) |parent| {
             self.current_node = parent;
-            return parent;
+            return try Node.toInterface(parent);
         }
 
         return null;
     }
 
-    pub fn _previousNode(self: *TreeWalker) !?*parser.Node {
+    pub fn _previousNode(self: *TreeWalker) !?NodeUnion {
         if (self.current_node == self.root) return null;
 
         var current = self.current_node;
@@ -224,19 +226,19 @@ pub const TreeWalker = struct {
                     // Get last child if it has one.
                     if (try self.lastChild(current)) |child| {
                         self.current_node = child;
-                        return child;
+                        return try Node.toInterface(child);
                     }
 
                     // Otherwise, this node is our previous one.
                     self.current_node = current;
-                    return current;
+                    return try Node.toInterface(current);
                 },
                 .reject => continue,
                 .skip => {
                     // Get last child if it has one.
                     if (try self.lastChild(current)) |child| {
                         self.current_node = child;
-                        return child;
+                        return try Node.toInterface(child);
                     }
                 },
             }
@@ -245,17 +247,17 @@ pub const TreeWalker = struct {
         if (current != self.root) {
             if (try self.parentNode(current)) |parent| {
                 self.current_node = parent;
-                return parent;
+                return try Node.toInterface(parent);
             }
         }
 
         return null;
     }
 
-    pub fn _previousSibling(self: *TreeWalker) !?*parser.Node {
+    pub fn _previousSibling(self: *TreeWalker) !?NodeUnion {
         if (try self.previousSibling(self.current_node)) |sibling| {
             self.current_node = sibling;
-            return sibling;
+            return try Node.toInterface(sibling);
         }
 
         return null;

Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,8 @@ const parser = @import("../netsurf.zig");`
`22`	`22`	`const NodeFilter = @import("node_filter.zig");`
`23`	`23`	`const Env = @import("../env.zig").Env;`
`24`	`24`	`const Page = @import("../page.zig").Page;`
	`25`	`+const Node = @import("node.zig").Node;`
	`26`	`+const NodeUnion = @import("node.zig").Union;`
`25`	`27`
`26`	`28`	`// https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker`
`27`	`29`	`pub const TreeWalker = struct {`
`@@ -55,12 +57,12 @@ pub const TreeWalker = struct {`
`55`	`57`	`};`
`56`	`58`	`}`
`57`	`59`
`58`		`- pub fn get_root(self: TreeWalker) parser.Node {`
`59`		`- return self.root;`
	`60`	`+ pub fn get_root(self: *TreeWalker) !NodeUnion {`
	`61`	`+ return try Node.toInterface(self.root);`
`60`	`62`	`}`
`61`	`63`
`62`		`- pub fn get_currentNode(self: TreeWalker) parser.Node {`
`63`		`- return self.current_node;`
	`64`	`+ pub fn get_currentNode(self: *TreeWalker) !NodeUnion {`
	`65`	`+ return try Node.toInterface(self.current_node);`
`64`	`66`	`}`
`65`	`67`
`66`	`68`	`pub fn get_whatToShow(self: *TreeWalker) u32 {`
`@@ -157,35 +159,35 @@ pub const TreeWalker = struct {`
`157`	`159`	`}`
`158`	`160`	`}`
`159`	`161`
`160`		`- pub fn _firstChild(self: TreeWalker) !?parser.Node {`
	`162`	`+ pub fn _firstChild(self: *TreeWalker) !?NodeUnion {`
`161`	`163`	`if (try self.firstChild(self.current_node)) \|child\| {`
`162`	`164`	`self.current_node = child;`
`163`		`- return child;`
	`165`	`+ return try Node.toInterface(child);`
`164`	`166`	`}`
`165`	`167`
`166`	`168`	`return null;`
`167`	`169`	`}`
`168`	`170`
`169`		`- pub fn _lastChild(self: TreeWalker) !?parser.Node {`
	`171`	`+ pub fn _lastChild(self: *TreeWalker) !?NodeUnion {`
`170`	`172`	`if (try self.lastChild(self.current_node)) \|child\| {`
`171`	`173`	`self.current_node = child;`
`172`		`- return child;`
	`174`	`+ return try Node.toInterface(child);`
`173`	`175`	`}`
`174`	`176`
`175`	`177`	`return null;`
`176`	`178`	`}`
`177`	`179`
`178`		`- pub fn _nextNode(self: TreeWalker) !?parser.Node {`
	`180`	`+ pub fn _nextNode(self: *TreeWalker) !?NodeUnion {`
`179`	`181`	`if (try self.firstChild(self.current_node)) \|child\| {`
`180`	`182`	`self.current_node = child;`
`181`		`- return child;`
	`183`	`+ return try Node.toInterface(child);`
`182`	`184`	`}`
`183`	`185`
`184`	`186`	`var current = self.current_node;`
`185`	`187`	`while (current != self.root) {`
`186`	`188`	`if (try self.nextSibling(current)) \|sibling\| {`
`187`	`189`	`self.current_node = sibling;`
`188`		`- return sibling;`
	`190`	`+ return try Node.toInterface(sibling);`
`189`	`191`	`}`
`190`	`192`
`191`	`193`	`current = (try parser.nodeParentNode(current)) orelse break;`
`@@ -194,25 +196,25 @@ pub const TreeWalker = struct {`
`194`	`196`	`return null;`
`195`	`197`	`}`
`196`	`198`
`197`		`- pub fn _nextSibling(self: TreeWalker) !?parser.Node {`
	`199`	`+ pub fn _nextSibling(self: *TreeWalker) !?NodeUnion {`
`198`	`200`	`if (try self.nextSibling(self.current_node)) \|sibling\| {`
`199`	`201`	`self.current_node = sibling;`
`200`		`- return sibling;`
	`202`	`+ return try Node.toInterface(sibling);`
`201`	`203`	`}`
`202`	`204`
`203`	`205`	`return null;`
`204`	`206`	`}`
`205`	`207`
`206`		`- pub fn _parentNode(self: TreeWalker) !?parser.Node {`
	`208`	`+ pub fn _parentNode(self: *TreeWalker) !?NodeUnion {`
`207`	`209`	`if (try self.parentNode(self.current_node)) \|parent\| {`
`208`	`210`	`self.current_node = parent;`
`209`		`- return parent;`
	`211`	`+ return try Node.toInterface(parent);`
`210`	`212`	`}`
`211`	`213`
`212`	`214`	`return null;`
`213`	`215`	`}`
`214`	`216`
`215`		`- pub fn _previousNode(self: TreeWalker) !?parser.Node {`
	`217`	`+ pub fn _previousNode(self: *TreeWalker) !?NodeUnion {`
`216`	`218`	`if (self.current_node == self.root) return null;`
`217`	`219`
`218`	`220`	`var current = self.current_node;`
`@@ -224,19 +226,19 @@ pub const TreeWalker = struct {`
`224`	`226`	`// Get last child if it has one.`
`225`	`227`	`if (try self.lastChild(current)) \|child\| {`
`226`	`228`	`self.current_node = child;`
`227`		`- return child;`
	`229`	`+ return try Node.toInterface(child);`
`228`	`230`	`}`
`229`	`231`
`230`	`232`	`// Otherwise, this node is our previous one.`
`231`	`233`	`self.current_node = current;`
`232`		`- return current;`
	`234`	`+ return try Node.toInterface(current);`
`233`	`235`	`},`
`234`	`236`	`.reject => continue,`
`235`	`237`	`.skip => {`
`236`	`238`	`// Get last child if it has one.`
`237`	`239`	`if (try self.lastChild(current)) \|child\| {`
`238`	`240`	`self.current_node = child;`
`239`		`- return child;`
	`241`	`+ return try Node.toInterface(child);`
`240`	`242`	`}`
`241`	`243`	`},`
`242`	`244`	`}`
`@@ -245,17 +247,17 @@ pub const TreeWalker = struct {`
`245`	`247`	`if (current != self.root) {`
`246`	`248`	`if (try self.parentNode(current)) \|parent\| {`
`247`	`249`	`self.current_node = parent;`
`248`		`- return parent;`
	`250`	`+ return try Node.toInterface(parent);`
`249`	`251`	`}`
`250`	`252`	`}`
`251`	`253`
`252`	`254`	`return null;`
`253`	`255`	`}`
`254`	`256`
`255`		`- pub fn _previousSibling(self: TreeWalker) !?parser.Node {`
	`257`	`+ pub fn _previousSibling(self: *TreeWalker) !?NodeUnion {`
`256`	`258`	`if (try self.previousSibling(self.current_node)) \|sibling\| {`
`257`	`259`	`self.current_node = sibling;`
`258`		`- return sibling;`
	`260`	`+ return try Node.toInterface(sibling);`
`259`	`261`	`}`
`260`	`262`
`261`	`263`	`return null;`