aboutsummaryrefslogtreecommitdiff
path: root/src/z/Env
diff options
context:
space:
mode:
authorNathan Reiner <nathan@nathanreiner.xyz>2026-10-06 08:41:03 +0200
committerNathan Reiner <nathan@nathanreiner.xyz>2026-10-06 08:41:03 +0200
commitdccd1987b418e47b4b82eda3aeaed40be18d9e45 (patch)
treecc7a48007a4fdda07c71c4cfd6f7359f48c17472 /src/z/Env
parent64146d3d4277b34946ab9a294b11e41979d7ac74 (diff)
wasm: make future hold error
Diffstat (limited to 'src/z/Env')
-rw-r--r--src/z/Env/Future.zig34
-rw-r--r--src/z/Env/future.zig59
-rw-r--r--src/z/Env/root.zig93
3 files changed, 107 insertions, 79 deletions
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 };