Propagate real filenames to JS_Eval for coverage

Add a filename field to the eval message payload. When a runtime
loads a script via the :script option, the file path is passed
through to JS_Eval so coverage reports show the actual source
filename instead of <eval>.

Inline eval/3 calls continue to use <eval> as the filename.

Author: dannote

lib/quickbeam/context_worker.zig

@@ -294,7 +294,7 @@ fn handle_ctx_eval(
     install_pump(pd, contexts, p.context_id, entry);
     qjs.JS_ResetContextReductionCount(entry.state.ctx);
     var result = worker.Result{};
-    entry.state.do_eval(p.code, &result);
+    entry.state.do_eval(p.code, "", &result);
     uninstall_pump(entry);
 
     pd.deadline = null;

lib/quickbeam/native.ex

@@ -154,7 +154,7 @@ defmodule QuickBEAM.Native do
     ],
     resources: [:RuntimeResource, :PoolResource, :WasmModuleResource, :WasmInstanceResource],
     nifs: [
-      eval: 3,
+      eval: 4,
       compile: 2,
       call_function: 4,
       load_module: 3,

lib/quickbeam/quickbeam.zig

@@ -104,7 +104,7 @@ pub fn start_runtime(owner_pid: beam.pid, opts: beam.term) !RuntimeResource {
     return res;
 }
 
-pub fn eval(resource: RuntimeResource, code: []const u8, timeout_ms: u64) beam.term {
+pub fn eval(resource: RuntimeResource, code: []const u8, timeout_ms: u64, filename: []const u8) beam.term {
     const data = resource.unpack();
     const env = beam.context.env orelse return beam.make(.{ .@"error", "no env" }, .{});
 
@@ -113,13 +113,18 @@ pub fn eval(resource: RuntimeResource, code: []const u8, timeout_ms: u64) beam.t
     const ref_term = e.enif_make_ref(ref_env);
 
     const code_copy = gpa.dupe(u8, code) catch return beam.make(.{ .@"error", "OOM" }, .{});
+    const fname_copy = if (filename.len > 0) gpa.dupe(u8, filename) catch {
+        gpa.free(code_copy);
+        return beam.make(.{ .@"error", "OOM" }, .{});
+    } else &[_]u8{};
 
     enqueue(data, .{ .eval = .{
         .code = code_copy,
         .caller_pid = caller_pid,
         .ref_env = ref_env,
         .ref_term = ref_term,
         .timeout_ns = if (timeout_ms > 0) timeout_ms * 1_000_000 else 0,
+        .filename = fname_copy,
     } });
 
     return beam.term{ .v = e.enif_make_copy(env, ref_term) };

lib/quickbeam/runtime.ex

@@ -342,7 +342,7 @@ defmodule QuickBEAM.Runtime do
   defp eval_script_async(state, path) do
     case read_script(path) do
       {:ok, code} ->
-        ref = QuickBEAM.Native.eval(state.resource, code, 0)
+        ref = QuickBEAM.Native.eval(state.resource, code, 0, path)
         await_ref_with_callbacks(ref, state, path)
 
       {:error, reason} when is_atom(reason) ->
@@ -405,7 +405,7 @@ defmodule QuickBEAM.Runtime do
   end
 
   defp sync_eval(resource, code) do
-    ref = QuickBEAM.Native.eval(resource, code, 0)
+    ref = QuickBEAM.Native.eval(resource, code, 0, "")
     await_ref(ref)
   end
 
@@ -458,7 +458,7 @@ defmodule QuickBEAM.Runtime do
       QuickBEAM.Native.define_global(state.resource, name, value)
     end)
 
-    ref = QuickBEAM.Native.eval(state.resource, code, timeout_ms)
+    ref = QuickBEAM.Native.eval(state.resource, code, timeout_ms, "")
 
     transform = fn result ->
       QuickBEAM.Native.delete_globals(state.resource, names)
@@ -539,7 +539,7 @@ defmodule QuickBEAM.Runtime do
 
   # ── NIF dispatch callbacks ──
 
-  defp nif_eval(state, code, timeout), do: QuickBEAM.Native.eval(state.resource, code, timeout)
+  defp nif_eval(state, code, timeout), do: QuickBEAM.Native.eval(state.resource, code, timeout, "")
 
   defp nif_call(state, fn_name, args, timeout),
     do: QuickBEAM.Native.call_function(state.resource, fn_name, args, timeout)

lib/quickbeam/types.zig

@@ -66,6 +66,7 @@ pub const AsyncRequestPayload = struct {
     ref_env: ?*e.ErlNifEnv,
     ref_term: e.ErlNifTerm,
     timeout_ns: u64 = 0,
+    filename: []const u8 = "",
 };
 
 pub const AsyncCallPayload = struct {

lib/quickbeam/worker.zig

@@ -382,19 +382,27 @@ pub const WorkerState = struct {
         self.drain_jobs();
     }
 
-    pub fn do_eval(self: *WorkerState, code: []const u8, result: *Result) void {
+    pub fn do_eval(self: *WorkerState, code: []const u8, filename: []const u8, result: *Result) void {
         const code_z = gpa.dupeZ(u8, code) catch {
             result.ok = false;
             result.json = "Out of memory";
             return;
         };
         defer gpa.free(code_z);
 
+        const fname = if (filename.len > 0) filename else "<eval>";
+        const fname_z = gpa.dupeZ(u8, fname) catch {
+            result.ok = false;
+            result.json = "Out of memory";
+            return;
+        };
+        defer gpa.free(fname_z);
+
         var flags: c_int = qjs.JS_EVAL_TYPE_GLOBAL;
         if (std.mem.indexOf(u8, code, "await") != null) {
             flags |= qjs.JS_EVAL_FLAG_ASYNC;
         }
-        const val = qjs.JS_Eval(self.ctx, code_z.ptr, code.len, "<eval>", flags);
+        const val = qjs.JS_Eval(self.ctx, code_z.ptr, code.len, fname_z.ptr, flags);
         defer qjs.JS_FreeValue(self.ctx, val);
         self.drain_jobs();
 
@@ -949,9 +957,10 @@ pub fn worker_main(rd: *types.RuntimeData, owner_pid: beam.pid) void {
                 .eval => |p| {
                     var result = Result{};
                     state.set_deadline(p.timeout_ns);
-                    state.do_eval(p.code, &result);
+                    state.do_eval(p.code, p.filename, &result);
                     state.clear_deadline();
                     gpa.free(p.code);
+                    if (p.filename.len > 0) gpa.free(p.filename);
                     types.send_reply(p.caller_pid, p.ref_env, p.ref_term, result.ok, result.env, result.term, result.json);
                 },
                 .compile => |p| {