Remove unnecessary error handling from non-erroring netsurf event fun…

src/browser/ScriptManager.zig

@@ -649,10 +649,7 @@ const Script = struct {
                 defer parser.eventDestroy(loadevt);
 
                 var result: Env.Function.Result = undefined;
-                const iface = Event.toInterface(loadevt) catch |err| {
-                    log.err(.browser, "SM event interface", .{ .err = err });
-                    return;
-                };
+                const iface = Event.toInterface(loadevt);
                 f.tryCall(void, .{iface}, &result) catch {
                     log.warn(.user_script, "script callback", .{
                         .url = self.url,

src/browser/dom/MessageChannel.zig

@@ -252,7 +252,7 @@ pub const MessageEvent = struct {
         const event = try parser.eventCreate();
         defer parser.eventDestroy(event);
         try parser.eventInit(event, "message", .{});
-        try parser.eventSetInternalType(event, .message_event);
+        parser.eventSetInternalType(event, .message_event);
 
         return .{
             .proto = event.*,

src/browser/dom/mutation_observer.zig

@@ -278,7 +278,7 @@ const Observer = struct {
         var mutation_observer = self.mutation_observer;
 
         const node = blk: {
-            const event_target = try parser.eventTarget(event) orelse return;
+            const event_target = parser.eventTarget(event) orelse return;
             break :blk parser.eventTargetToNode(event_target);
         };
 

src/browser/events/event.zig

@@ -64,8 +64,8 @@ pub const Event = struct {
     pub const _AT_TARGET = 2;
     pub const _BUBBLING_PHASE = 3;
 
-    pub fn toInterface(evt: *parser.Event) !Union {
-        return switch (try parser.eventGetInternalType(evt)) {
+    pub fn toInterface(evt: *parser.Event) Union {
+        return switch (parser.eventGetInternalType(evt)) {
             .event, .abort_signal, .xhr_event => .{ .Event = evt },
             .custom_event => .{ .CustomEvent = @as(*CustomEvent, @ptrCast(evt)).* },
             .progress_event => .{ .ProgressEvent = @as(*ProgressEvent, @ptrCast(evt)).* },
@@ -89,41 +89,41 @@ pub const Event = struct {
     }
 
     pub fn get_target(self: *parser.Event, page: *Page) !?EventTargetUnion {
-        const et = try parser.eventTarget(self);
+        const et = parser.eventTarget(self);
         if (et == null) return null;
         return try EventTarget.toInterface(et.?, page);
     }
 
     pub fn get_currentTarget(self: *parser.Event, page: *Page) !?EventTargetUnion {
-        const et = try parser.eventCurrentTarget(self);
+        const et = parser.eventCurrentTarget(self);
         if (et == null) return null;
         return try EventTarget.toInterface(et.?, page);
     }
 
-    pub fn get_eventPhase(self: *parser.Event) !u8 {
-        return try parser.eventPhase(self);
+    pub fn get_eventPhase(self: *parser.Event) u8 {
+        return parser.eventPhase(self);
     }
 
-    pub fn get_bubbles(self: *parser.Event) !bool {
-        return try parser.eventBubbles(self);
+    pub fn get_bubbles(self: *parser.Event) bool {
+        return parser.eventBubbles(self);
     }
 
-    pub fn get_cancelable(self: *parser.Event) !bool {
-        return try parser.eventCancelable(self);
+    pub fn get_cancelable(self: *parser.Event) bool {
+        return parser.eventCancelable(self);
     }
 
-    pub fn get_defaultPrevented(self: *parser.Event) !bool {
-        return try parser.eventDefaultPrevented(self);
+    pub fn get_defaultPrevented(self: *parser.Event) bool {
+        return parser.eventDefaultPrevented(self);
     }
 
-    pub fn get_isTrusted(self: *parser.Event) !bool {
-        return try parser.eventIsTrusted(self);
+    pub fn get_isTrusted(self: *parser.Event) bool {
+        return parser.eventIsTrusted(self);
     }
 
     // Even though this is supposed to to provide microsecond resolution, browser
     // return coarser values to protect against fingerprinting. libdom returns
     // seconds, which is good enough.
-    pub fn get_timeStamp(self: *parser.Event) !u64 {
+    pub fn get_timeStamp(self: *parser.Event) u64 {
         return parser.eventTimestamp(self);
     }
 
@@ -143,19 +143,19 @@ pub const Event = struct {
     }
 
     pub fn _stopPropagation(self: *parser.Event) !void {
-        return try parser.eventStopPropagation(self);
+        return parser.eventStopPropagation(self);
     }
 
     pub fn _stopImmediatePropagation(self: *parser.Event) !void {
-        return try parser.eventStopImmediatePropagation(self);
+        return parser.eventStopImmediatePropagation(self);
     }
 
     pub fn _preventDefault(self: *parser.Event) !void {
-        return try parser.eventPreventDefault(self);
+        return parser.eventPreventDefault(self);
     }
 
     pub fn _composedPath(self: *parser.Event, page: *Page) ![]const EventTargetUnion {
-        const et_ = try parser.eventTarget(self);
+        const et_ = parser.eventTarget(self);
         const et = et_ orelse return &.{};
 
         var node: ?*parser.Node = switch (try parser.eventTargetInternalType(et)) {
@@ -326,11 +326,7 @@ pub const EventHandler = struct {
     }
 
     fn handle(node: *parser.EventNode, event: *parser.Event) void {
-        const ievent = Event.toInterface(event) catch |err| {
-            log.err(.app, "toInterface error", .{ .err = err });
-            return;
-        };
-
+        const ievent = Event.toInterface(event);
         const self: *EventHandler = @fieldParentPtr("node", node);
         var result: Function.Result = undefined;
         self.callback.tryCall(void, .{ievent}, &result) catch {
@@ -342,7 +338,7 @@ pub const EventHandler = struct {
         };
 
         if (self.once) {
-            const target = (parser.eventTarget(event) catch return).?;
+            const target = parser.eventTarget(event).?;
             const typ = parser.eventType(event) catch return;
             parser.eventTargetRemoveEventListener(
                 target,

src/browser/events/keyboard_event.zig

@@ -20,7 +20,7 @@ const std = @import("std");
 const log = @import("../../log.zig");
 const builtin = @import("builtin");
 
-const netsurf = @import("../netsurf.zig");
+const parser = @import("../netsurf.zig");
 const Event = @import("event.zig").Event;
 const JsObject = @import("../env.zig").JsObject;
 
@@ -30,13 +30,13 @@ const UIEvent = Event;
 
 // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent
 pub const KeyboardEvent = struct {
-    pub const Self = netsurf.KeyboardEvent;
+    pub const Self = parser.KeyboardEvent;
     pub const prototype = *UIEvent;
 
     pub const ConstructorOptions = struct {
         key: []const u8 = "",
         code: []const u8 = "",
-        location: netsurf.KeyboardEventOpts.LocationCode = .standard,
+        location: parser.KeyboardEventOpts.LocationCode = .standard,
         repeat: bool = false,
         isComposing: bool = false,
         // Currently not supported but we take as argument.
@@ -51,13 +51,13 @@ pub const KeyboardEvent = struct {
         metaKey: bool = false,
     };
 
-    pub fn constructor(event_type: []const u8, maybe_options: ?ConstructorOptions) !*netsurf.KeyboardEvent {
+    pub fn constructor(event_type: []const u8, maybe_options: ?ConstructorOptions) !*parser.KeyboardEvent {
         const options: ConstructorOptions = maybe_options orelse .{};
 
-        var event = try netsurf.keyboardEventCreate();
-        try netsurf.eventSetInternalType(@ptrCast(&event), .keyboard_event);
+        var event = try parser.keyboardEventCreate();
+        parser.eventSetInternalType(@ptrCast(&event), .keyboard_event);
 
-        try netsurf.keyboardEventInit(
+        try parser.keyboardEventInit(
             event,
             event_type,
             .{
@@ -122,19 +122,19 @@ pub const KeyboardEvent = struct {
     // Getters.
 
     pub fn get_altKey(self: *Self) bool {
-        return netsurf.keyboardEventKeyIsSet(self, .alt);
+        return parser.keyboardEventKeyIsSet(self, .alt);
     }
 
     pub fn get_ctrlKey(self: *Self) bool {
-        return netsurf.keyboardEventKeyIsSet(self, .ctrl);
+        return parser.keyboardEventKeyIsSet(self, .ctrl);
     }
 
     pub fn get_metaKey(self: *Self) bool {
-        return netsurf.keyboardEventKeyIsSet(self, .meta);
+        return parser.keyboardEventKeyIsSet(self, .meta);
     }
 
     pub fn get_shiftKey(self: *Self) bool {
-        return netsurf.keyboardEventKeyIsSet(self, .shift);
+        return parser.keyboardEventKeyIsSet(self, .shift);
     }
 
     pub fn get_isComposing(self: *Self) bool {
@@ -146,7 +146,7 @@ pub const KeyboardEvent = struct {
     }
 
     pub fn get_key(self: *Self) ![]const u8 {
-        return netsurf.keyboardEventGetKey(self);
+        return parser.keyboardEventGetKey(self);
     }
 
     pub fn get_repeat(self: *Self) bool {

src/browser/events/mouse_event.zig

@@ -56,7 +56,7 @@ pub const MouseEvent = struct {
         const opts = opts_ orelse MouseEventInit{};
 
         var mouse_event = try parser.mouseEventCreate();
-        try parser.eventSetInternalType(@ptrCast(&mouse_event), .mouse_event);
+        parser.eventSetInternalType(@ptrCast(&mouse_event), .mouse_event);
 
         try parser.mouseEventInit(mouse_event, event_type, .{
             .x = opts.clientX,

src/browser/html/AbortController.zig

@@ -91,7 +91,7 @@ pub const AbortSignal = struct {
         self.reason = reason_ orelse DEFAULT_REASON;
 
         const abort_event = try parser.eventCreate();
-        try parser.eventSetInternalType(abort_event, .abort_signal);
+        parser.eventSetInternalType(abort_event, .abort_signal);
 
         defer parser.eventDestroy(abort_event);
         try parser.eventInit(abort_event, "abort", .{});

src/browser/html/error_event.zig

@@ -42,7 +42,7 @@ pub const ErrorEvent = struct {
         const event = try parser.eventCreate();
         defer parser.eventDestroy(event);
         try parser.eventInit(event, event_type, .{});
-        try parser.eventSetInternalType(event, .event);
+        parser.eventSetInternalType(event, .event);
 
         const o = opts orelse ErrorEventInit{};
 

src/browser/netsurf.zig

@@ -456,87 +456,87 @@ pub fn eventType(evt: *Event) ![]const u8 {
     return strToData(s.?);
 }
 
-pub fn eventTarget(evt: *Event) !?*EventTarget {
+pub fn eventTarget(evt: *Event) ?*EventTarget {
     var et: ?*EventTarget = null;
     const err = c._dom_event_get_target(evt, &et);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return et;
 }
 
-pub fn eventCurrentTarget(evt: *Event) !?*EventTarget {
+pub fn eventCurrentTarget(evt: *Event) ?*EventTarget {
     var et: ?*EventTarget = null;
     const err = c._dom_event_get_current_target(evt, &et);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return et;
 }
 
-pub fn eventPhase(evt: *Event) !u8 {
+pub fn eventPhase(evt: *Event) u8 {
     var phase: c.dom_event_flow_phase = undefined;
     const err = c._dom_event_get_event_phase(evt, &phase);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return @as(u8, @intCast(phase));
 }
 
-pub fn eventBubbles(evt: *Event) !bool {
+pub fn eventBubbles(evt: *Event) bool {
     var res: bool = undefined;
     const err = c._dom_event_get_bubbles(evt, &res);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return res;
 }
 
-pub fn eventCancelable(evt: *Event) !bool {
+pub fn eventCancelable(evt: *Event) bool {
     var res: bool = undefined;
     const err = c._dom_event_get_cancelable(evt, &res);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return res;
 }
 
-pub fn eventDefaultPrevented(evt: *Event) !bool {
+pub fn eventDefaultPrevented(evt: *Event) bool {
     var res: bool = undefined;
     const err = c._dom_event_is_default_prevented(evt, &res);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return res;
 }
 
-pub fn eventIsTrusted(evt: *Event) !bool {
+pub fn eventIsTrusted(evt: *Event) bool {
     var res: bool = undefined;
     const err = c._dom_event_get_is_trusted(evt, &res);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return res;
 }
 
-pub fn eventTimestamp(evt: *Event) !u64 {
+pub fn eventTimestamp(evt: *Event) u64 {
     var ts: u64 = 0;
     const err = c._dom_event_get_timestamp(evt, &ts);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return ts;
 }
 
-pub fn eventStopPropagation(evt: *Event) !void {
+pub fn eventStopPropagation(evt: *Event) void {
     const err = c._dom_event_stop_propagation(evt);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
 }
 
-pub fn eventStopImmediatePropagation(evt: *Event) !void {
+pub fn eventStopImmediatePropagation(evt: *Event) void {
     const err = c._dom_event_stop_immediate_propagation(evt);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
 }
 
-pub fn eventPreventDefault(evt: *Event) !void {
+pub fn eventPreventDefault(evt: *Event) void {
     const err = c._dom_event_prevent_default(evt);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
 }
 
-pub fn eventGetInternalType(evt: *Event) !EventType {
+pub fn eventGetInternalType(evt: *Event) EventType {
     var res: u32 = undefined;
     const err = c._dom_event_get_internal_type(evt, &res);
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
     return @enumFromInt(res);
 }
 
-pub fn eventSetInternalType(evt: *Event, internal_type: EventType) !void {
+pub fn eventSetInternalType(evt: *Event, internal_type: EventType) void {
     const err = c._dom_event_set_internal_type(evt, @intFromEnum(internal_type));
-    try DOMErr(err);
+    std.debug.assert(err == c.DOM_NO_ERR);
 }
 
 pub const EventType = enum(u8) {

src/browser/page.zig

@@ -881,7 +881,7 @@ pub const Page = struct {
     }
 
     fn _windowClicked(self: *Page, event: *parser.Event) !void {
-        const target = (try parser.eventTarget(event)) orelse return;
+        const target = parser.eventTarget(event) orelse return;
         const node = parser.eventTargetToNode(target);
         const tag = (try parser.nodeHTMLGetTagType(node)) orelse return;
         switch (tag) {
@@ -958,7 +958,7 @@ pub const Page = struct {
     }
 
     fn _keydownCallback(self: *Page, event: *parser.Event) !void {
-        const target = (try parser.eventTarget(event)) orelse return;
+        const target = parser.eventTarget(event) orelse return;
         const node = parser.eventTargetToNode(target);
         const tag = (try parser.nodeHTMLGetTagType(node)) orelse return;
 

src/browser/xhr/progress_event.zig

@@ -41,7 +41,7 @@ pub const ProgressEvent = struct {
         const event = try parser.eventCreate();
         defer parser.eventDestroy(event);
         try parser.eventInit(event, event_type, .{});
-        try parser.eventSetInternalType(event, .progress_event);
+        parser.eventSetInternalType(event, .progress_event);
 
         const o = opts orelse EventInit{};
 

src/browser/xhr/xhr.zig

@@ -273,7 +273,7 @@ pub const XMLHttpRequest = struct {
         // We can we defer event destroy once the event is dispatched.
         defer parser.eventDestroy(evt);
 
-        try parser.eventSetInternalType(evt, .xhr_event);
+        parser.eventSetInternalType(evt, .xhr_event);
 
         try parser.eventInit(evt, typ, .{ .bubbles = true, .cancelable = true });
         _ = try parser.eventTargetDispatchEvent(@as(*parser.EventTarget, @ptrCast(self)), evt);