Rework HTMLAllCollection

Capture its unique properties:
1- instances are falsy, and
2- instance can be called as a function

The behavior is used for browser detection (i.e. duckduckgo treats us as a
legacy browser because we document.all != false)

src/browser/dom/html_collection.zig

@@ -149,17 +149,43 @@ pub fn HTMLCollectionByName(
     };
 }
 
-pub fn HTMLCollectionAll(
-    root: ?*parser.Node,
-    include_root: bool,
-) !HTMLCollection {
-    return HTMLCollection{
-        .root = root,
-        .walker = .{ .walkerDepthFirst = .{} },
-        .matcher = .{ .matchTrue = .{} },
-        .include_root = include_root,
+// HTMLAllCollection is a special type: instances of it are falsy. It's the only
+// object in the WebAPI that behaves like this - in fact, it's even a special
+// case in the JavaScript spec.
+// This is important, because a lot of browser detection rely on this behavior
+// to determine what browser is running.
+
+// It's also possible to use an instance like a function:
+//   document.all(3)
+//   document.all('some_id')
+pub const HTMLAllCollection = struct {
+    pub const prototype = *HTMLCollection;
+
+    proto: HTMLCollection,
+
+    pub const mark_as_undetectable = true;
+
+    pub fn init(root: ?*parser.Node) HTMLAllCollection {
+        return .{ .proto = .{
+            .root = root,
+            .walker = .{ .walkerDepthFirst = .{} },
+            .matcher = .{ .matchTrue = .{} },
+            .include_root = true,
+        } };
+    }
+
+    const CAllAsFunctionArg = union(enum) {
+        index: u32,
+        id: []const u8,
     };
-}
+
+    pub fn jsCallAsFunction(self: *HTMLAllCollection, arg: CAllAsFunctionArg) !?Union {
+        return switch (arg) {
+            .index => |i| self.proto._item(i),
+            .id => |id| self.proto._namedItem(id),
+        };
+    }
+};
 
 pub fn HTMLCollectionChildren(
     root: ?*parser.Node,

src/browser/dom/node.zig

@@ -33,6 +33,7 @@ const Document = @import("document.zig").Document;
 const DocumentType = @import("document_type.zig").DocumentType;
 const DocumentFragment = @import("document_fragment.zig").DocumentFragment;
 const HTMLCollection = @import("html_collection.zig").HTMLCollection;
+const HTMLAllCollection = @import("html_collection.zig").HTMLAllCollection;
 const HTMLCollectionIterator = @import("html_collection.zig").HTMLCollectionIterator;
 const Walker = @import("walker.zig").WalkerDepthFirst;
 
@@ -50,6 +51,7 @@ pub const Interfaces = .{
     DocumentType,
     DocumentFragment,
     HTMLCollection,
+    HTMLAllCollection,
     HTMLCollectionIterator,
     HTML.Interfaces,
 };

src/browser/html/document.zig

@@ -151,8 +151,8 @@ pub const HTMLDocument = struct {
         return try collection.HTMLCollectionByAnchors(parser.documentHTMLToNode(self), false);
     }
 
-    pub fn get_all(self: *parser.DocumentHTML) !collection.HTMLCollection {
-        return try collection.HTMLCollectionAll(parser.documentHTMLToNode(self), true);
+    pub fn get_all(self: *parser.DocumentHTML) collection.HTMLAllCollection {
+        return collection.HTMLAllCollection.init(parser.documentHTMLToNode(self));
     }
 
     pub fn get_currentScript(self: *parser.DocumentHTML) !?*parser.Script {
@@ -260,4 +260,11 @@ test "Browser.HTML.Document" {
         .{ "document.cookie = 'favorite_food=tripe; SameSite=None; Secure'", "favorite_food=tripe; SameSite=None; Secure" },
         .{ "document.cookie", "name=Oeschger; favorite_food=tripe" },
     }, .{});
+
+    try runner.testCases(&.{
+        .{ "!document.all", "true" },
+        .{ "!!document.all", "false" },
+        .{ "document.all(5)", "[object HTMLParagraphElement]" },
+        .{ "document.all('content')", "[object HTMLDivElement]" },
+    }, .{});
 }

src/runtime/js.zig

@@ -1213,6 +1213,7 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
 
             generateIndexer(Struct, template_proto);
             generateNamedIndexer(Struct, template_proto);
+            generateUndetectable(Struct, template.getInstanceTemplate());
         }
 
         // Even if a struct doesn't have a `constructor` function, we still
@@ -1412,6 +1413,32 @@ pub fn Env(comptime State: type, comptime WebApis: type) type {
             template_proto.setNamedProperty(configuration, null);
         }
 
+        fn generateUndetectable(comptime Struct: type, template: v8.ObjectTemplate) void {
+            const has_js_call_as_function = @hasDecl(Struct, "jsCallAsFunction");
+
+            if (has_js_call_as_function) {
+                template.setCallAsFunctionHandler(struct {
+                    fn callback(raw_info: ?*const v8.C_FunctionCallbackInfo) callconv(.c) void {
+                        const info = v8.FunctionCallbackInfo.initFromV8(raw_info);
+                        var caller = Caller(Self, State).init(info);
+                        defer caller.deinit();
+
+                        const named_function = comptime NamedFunction.init(Struct, "jsCallAsFunction");
+                        caller.method(Struct, named_function, info) catch |err| {
+                            caller.handleError(Struct, named_function, err, info);
+                        };
+                    }
+                }.callback);
+            }
+
+            if (@hasDecl(Struct, "mark_as_undetectable") and Struct.mark_as_undetectable) {
+                if (!has_js_call_as_function) {
+                    @compileError(@typeName(Struct) ++ ": mark_as_undetectable required jsCallAsFunction to be defined. This is a hard-coded requirement in V8, because mark_as_undetectable only exists for HTMLAllCollection which is also callable.");
+                }
+                template.markAsUndetectable();
+            }
+        }
+
         // Turns a Zig value into a JS one.
         fn zigValueToJs(
             templates: []v8.FunctionTemplate,