From dccd1987b418e47b4b82eda3aeaed40be18d9e45 Mon Sep 17 00:00:00 2001 From: Nathan Reiner Date: Tue, 6 Oct 2026 08:41:03 +0200 Subject: wasm: make future hold error --- src/app/root.zig | 22 ++++++------- src/z/Env/Future.zig | 34 ------------------- src/z/Env/future.zig | 59 +++++++++++++++++++++++++++++++++ src/z/Env/root.zig | 93 +++++++++++++++++++++++++++------------------------- 4 files changed, 118 insertions(+), 90 deletions(-) delete mode 100644 src/z/Env/Future.zig create mode 100644 src/z/Env/future.zig (limited to 'src') diff --git a/src/app/root.zig b/src/app/root.zig index 730eb50..479af45 100644 --- a/src/app/root.zig +++ b/src/app/root.zig @@ -10,30 +10,30 @@ fn run_wrapped() !void { var env: z.Env = .init(std.heap.wasm_allocator); defer env.deinit(); - _ = try env.setProp(z.Env.window, "my_prop", 45); - _ = try env.deleteProp(z.Env.window, "my_prop"); + _ = env.setProp(z.Env.window, "my_prop", 45); + _ = env.deleteProp(z.Env.window, "my_prop"); - const console = (try env.getProp(z.Env.window, "console")).await(&env, .object); - const object = (try env.getProp(z.Env.window, "Object")).await(&env, .object); - const location = (try env.getProp(z.Env.window, "location")).await(&env, .object); + const console = try env.getProp(z.Env.window, "console").await(&env, .object); + const object = try env.getProp(z.Env.window, "Object").await(&env, .object); + const location = try env.getProp(z.Env.window, "location").await(&env, .object); - const obj = try env.new(object, .{}); - const hostname = (try env.getProp(location, "hostname")).await(&env, .string); + const obj = env.new(object, .{}); + const hostname = try env.getProp(location, "hostname").await(&env, .string); defer std.heap.wasm_allocator.free(hostname); - const call = try env.callMethod( + const call = env.callMethod( console, "log", .{ "hello, wasm!", - obj.await(&env, .object), + try obj.await(&env), hostname, }, ); - call.await(&env, .undefined); + try call.await(&env, .undefined); - _ = try env.free(console); + _ = env.free(console); } export fn run() void { diff --git a/src/z/Env/Future.zig b/src/z/Env/Future.zig deleted file mode 100644 index 1e28ac7..0000000 --- a/src/z/Env/Future.zig +++ /dev/null @@ -1,34 +0,0 @@ -const std = @import("std"); -const Env = @import("root.zig"); -const z = @import("../root.zig"); - -const Self = @This(); - -result: *Env.Value, - -pub fn await(self: *const Self, env: *Env, comptime kind: Env.Value.Kind) kind.asType() { - const result = self.awaitAny(env); - - if (kind != result.kind) { - std.log.err("unexpected {}, expected {}", .{result.kind, kind}); - @panic("type error"); - } - - return switch (kind) { - .uninit => @panic("uninitialized result"), - .string => result.value.string.ptr[0..result.value.string.len], - else => @field(result.value, @tagName(kind)), - }; -} - -pub fn awaitAny(self: *const Self, env: *Env) Env.Value { - defer env.pool.destroy(self.result); - - if (self.result.kind != .uninit) { - return self.result.*; - } - - env.flush(); - - return self.result.*; -} diff --git a/src/z/Env/future.zig b/src/z/Env/future.zig new file mode 100644 index 0000000..a014990 --- /dev/null +++ b/src/z/Env/future.zig @@ -0,0 +1,59 @@ +const std = @import("std"); +const Env = @import("root.zig"); +const z = @import("../root.zig"); + + +pub fn Future(comptime kind: Env.Value.Kind) type { + return struct { + const Self = @This(); + + future: AnyFuture, + + pub fn fromAny(future: AnyFuture) Self { + return .{ .future = future }; + } + + pub fn await(self: *const Self, env: *Env) !kind.asType() { + return self.future.await(env, kind); + } + }; +} + +pub const AnyFuture = union(enum) { + const Self = @This(); + + result: *Env.Value, + err: anyerror, + + pub fn await(self: *const Self, env: *Env, comptime kind: Env.Value.Kind) !kind.asType() { + const result = try self.awaitAny(env); + + if (kind != result.kind) { + std.log.err("unexpected {}, expected {}", .{ result.kind, kind }); + @panic("type error"); + } + + return switch (kind) { + .uninit => @panic("uninitialized result"), + .string => result.value.string.ptr[0..result.value.string.len], + else => @field(result.value, @tagName(kind)), + }; + } + + pub fn awaitAny(self: *const Self, env: *Env) !Env.Value { + switch (self.*) { + .err => |err| return err, + .result => |result| { + defer env.pool.destroy(result); + + if (result.kind != .uninit) { + return result.*; + } + + env.flush(); + + return result.*; + } + } + } +}; diff --git a/src/z/Env/root.zig b/src/z/Env/root.zig index c4979b9..99b47c5 100644 --- a/src/z/Env/root.zig +++ b/src/z/Env/root.zig @@ -6,7 +6,9 @@ const js = @import("js.zig"); const Self = @This(); pub const Call = @import("call.zig").Call; -pub const Future = @import("Future.zig"); +const future = @import("future.zig"); +pub const AnyFuture = future.AnyFuture; +pub const Future = future.Future; pub const Value = @import("value.zig").Value; pub const Object = extern struct {}; @@ -22,15 +24,15 @@ pub fn init(gpa: std.mem.Allocator) Self { return .{ .gpa = gpa }; } -pub fn getProp(self: *Self, object: *Object, key: anytype) !Future { - try self.calls.append(self.gpa, .{ +pub fn getProp(self: *Self, object: *Object, key: anytype) AnyFuture { + self.calls.append(self.gpa, .{ .kind = .get_prop, .num_args = 2, - }); - try self.values.append(self.gpa, .from(object)); - try self.values.append(self.gpa, .from(key)); + }) catch |err| return .{ .err = err }; + self.values.append(self.gpa, .from(object)) catch |err| return .{ .err = err }; + self.values.append(self.gpa, .from(key)) catch |err| return .{ .err = err }; - return self.registerFuture(); + return self.registerFuture() catch |err| .{ .err = err }; } pub fn setProp( @@ -38,33 +40,33 @@ pub fn setProp( object: *Object, key: anytype, value: anytype, -) !Future { - try self.calls.append(self.gpa, .{ +) Future(.undefined) { + self.calls.append(self.gpa, .{ .kind = .set_prop, .num_args = 3, - }); + }) catch |err| return .fromAny(.{ .err = err }); - try self.values.append(self.gpa, .from(object)); - try self.values.append(self.gpa, .from(key)); - try self.values.append(self.gpa, .from(value)); + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); + self.values.append(self.gpa, .from(key)) catch |err| return .fromAny(.{ .err = err }); + self.values.append(self.gpa, .from(value)) catch |err| return .fromAny(.{ .err = err }); - return self.registerFuture(); + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); } pub fn deleteProp( self: *Self, object: *Object, key: []const u8, -) !Future { - try self.calls.append(self.gpa, .{ +) Future(.undefined) { + self.calls.append(self.gpa, .{ .kind = .del_prop, .num_args = 2, - }); + }) catch |err| return .fromAny(.{ .err = err }); - try self.values.append(self.gpa, .from(object)); - try self.values.append(self.gpa, .from(key)); + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); + self.values.append(self.gpa, .from(key)) catch |err| return .fromAny(.{ .err = err }); - return self.registerFuture(); + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); } pub fn callMethod( @@ -72,65 +74,66 @@ pub fn callMethod( object: *Object, key: []const u8, args: anytype, -) !Future { - try self.calls.append(self.gpa, .{ +) AnyFuture { + self.calls.append(self.gpa, .{ .kind = .call_method, .num_args = 2 + args.len, - }); + }) catch |err| return .{ .err = err }; - try self.values.append(self.gpa, .from(object)); - try self.values.append(self.gpa, .from(key)); + self.values.append(self.gpa, .from(object)) catch |err| return .{ .err = err }; + self.values.append(self.gpa, .from(key)) catch |err| return .{ .err = err }; inline for (args) |arg| { - try self.values.append(self.gpa, .from(arg)); + self.values.append(self.gpa, .from(arg)) catch |err| return .{ .err = err }; } - return self.registerFuture(); + return self.registerFuture() catch |err| return .{ .err = err }; } -pub fn call(self: *Self, object: *Object, args: anytype) !Future { - try self.calls.append(self.gpa, .{ +pub fn call(self: *Self, object: *Object, args: anytype) AnyFuture { + self.calls.append(self.gpa, .{ .kind = .call, .num_args = 1 + args.len, - }); + }) catch |err| return .{ .err = err }; - try self.values.append(self.gpa, .from(object)); + self.values.append(self.gpa, .from(object)) catch |err| return .{ .err = err }; inline for (args) |arg| { - try self.values.append(self.gpa, .from(arg)); + self.values.append(self.gpa, .from(arg)) catch |err| return .{ .err = err }; } - return self.registerFuture(); + return self.registerFuture() catch |err| return .{ .err = err }; } -pub fn free(self: *Self, object: *Object) !Future { - try self.calls.append(self.gpa, .{ +pub fn free(self: *Self, object: *Object) Future(.undefined) { + self.calls.append(self.gpa, .{ .kind = .free, .num_args = 1, - }); + }) catch |err| return .fromAny(.{ .err = err }); - try self.values.append(self.gpa, .from(object)); + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); - return self.registerFuture(); + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); } -pub fn new(self: *Self, object: *Object, args: anytype) !Future { - try self.calls.append(self.gpa, .{ +pub fn new(self: *Self, object: *Object, args: anytype) Future(.object) { + self.calls.append(self.gpa, .{ .kind = .new, .num_args = 1 + args.len, - }); + }) catch |err| return .fromAny(.{ .err = err }); - try self.values.append(self.gpa, .from(object)); + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); inline for (args) |arg| { - try self.values.append(self.gpa, .from(arg)); + self.values.append(self.gpa, .from(arg)) catch |err| return .fromAny(.{ .err = err }); } - return self.registerFuture(); + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); } -fn registerFuture(self: *Self) !Future { +fn registerFuture(self: *Self) !AnyFuture { const result = try self.pool.create(self.gpa); + errdefer self.pool.destroy(result); result.kind = .uninit; try self.results.append(self.gpa, result); return .{ .result = result }; -- cgit v1.2.3-70-g09d2