rusty_racer 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f26a45e0afbed589acb2749fc1817e7d8508622c81a70fc378dc4af4a0f54714
-  data.tar.gz: 718074b8d9f468b9ab3da144391ecbeff1d00db347812e5209cd11d866f78f6e
+  metadata.gz: 074b269481c924fc8e99f129e361d29fb4847c9c91ac4afee96378721fe9eebd
+  data.tar.gz: 68b312cba649752c393c0736e10efd8280f87ae0406ef7826b8d9fe3ec5505ce
 SHA512:
-  metadata.gz: 03b227aa3eba1f597b34bca826f947c4345a8c16accebce84f267d5fcb3df2e9c72e3343e261be857387ada97000769dfca0b449130c9056bc8c6aceb569cd03
-  data.tar.gz: fbe970e400edf1041271954df3ba7f3be5d1f8f3775ca29d09398065b85d9b813bc9ca8b9ae8302bd32757884f8c47af5ba9953937ca6de0486af8bd7e50959b
+  metadata.gz: c3ff8f690a9ad98912f2328d7be4bc10c3d1f38499365f628fbe4dac5e782832323bfc86976ac05fbe9406f288b75191fac11f1eb4f920d1caae056561d0eceb
+  data.tar.gz: a13dad93b256b9f15eef3baa27e79a97e2d7da61ec20c29aefc66907cd1cef4916fb0c84d65742233d182d48fed1fa369b48e86105bba7fede8a6afdaa008133

data/README.md

@@ -65,6 +65,7 @@ ctx.eval("({a: 1, b: [true, 'x']})")     # => {"a"=>1, "b"=>[true, "x"]}
 ctx.eval("function add(a, b) { return a + b }")
 ctx.call("add", 20, 22)                  # => 42
 ctx.call_void("doSideEffect")            # runs it; never marshals the return
+ctx.eval_void("globalThis.app = boot()") # ditto for the completion value
 
 # Ruby callbacks into JS; a raised Ruby exception becomes a JS exception.
 ctx.attach("rubyUpcase", ->(s) { s.upcase })
@@ -85,6 +86,14 @@ covers the library. Under it: `ParseError`, `RuntimeError`,
 `DisposedError` for using an isolate (or anything it handed out) after
 disposing it; `WrongThreadError` for reaching an isolate from the wrong thread.
 
+Reading a result is not passive — marshalling runs JS (getters, `Proxy` traps,
+`toString`), and a throw there fails the operation even though the code itself
+ran to completion. When the value is incidental, say so: `#eval_void`,
+`Script#run_void` and `#call_void` run for the effect and never touch the
+result. A statement list has a completion value whether you want one or not, so
+plumbing an object into a global (`globalThis.win = someProxy`) is enough to
+make a plain `#eval` fail after every one of its writes has landed.
+
 ES modules (the embedder owns the URL→module registry):
 
 ```ruby

data/ext/rusty_racer/Cargo.toml

@@ -5,7 +5,7 @@
 # links and loads with no custom archive.
 [package]
 name = "rusty_racer"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 publish = false
 

data/ext/rusty_racer/src/lib.rs

@@ -1997,8 +1997,16 @@ fn build_snapshot(code: &str, base: Option<Vec<u8>>, warmup: bool) -> Result<Vec
         {
             let cscope = &mut v8::ContextScope::new(scope, context);
             if !code.is_empty()
-                && let Err(e) =
-                    run_source(cscope, code, if warmup { "<warmup>" } else { "<snapshot>" })
+                && let Err(e) = run_source(
+                    cscope,
+                    code,
+                    if warmup { "<warmup>" } else { "<snapshot>" },
+                    // Snapshot/warmup code runs for its EFFECT (the heap it
+                    // leaves behind); nothing reads its completion value, so
+                    // don't marshal it — a bundle ending in an expression must
+                    // not fail the snapshot over a value no one wants.
+                    true,
+                )
             {
                 err = Some(match e {
                     VmError::Parse(m) | VmError::Runtime(m) => m,
@@ -2522,6 +2530,7 @@ impl Core {
         source: String,
         filename: String,
         timeout_ms: u64,
+        void: bool,
     ) -> Result<Value, Error> {
         let reply = self.run(
             ruby,
@@ -2530,6 +2539,7 @@ impl Core {
                 source,
                 filename,
                 timeout_ms,
+                void,
             },
         )?;
         self.reply_value(ruby, reply)
@@ -2773,12 +2783,13 @@ impl Core {
         }
     }
 
-    fn run_script(&self, ruby: &Ruby, script_id: i32) -> Result<Value, Error> {
+    fn run_script(&self, ruby: &Ruby, script_id: i32, void: bool) -> Result<Value, Error> {
         let reply = self.run(
             ruby,
             Request::RunScript {
                 script_id,
                 timeout_ms: self.default_timeout_ms,
+                void,
             },
         )?;
         self.reply_value(ruby, reply)
@@ -3008,12 +3019,14 @@ impl Context {
         Ok(())
     }
     // timeout_ms 0 = use the isolate's default; an explicit value overrides it.
+    // |void| discards the completion value instead of marshalling it.
     fn eval(
         ruby: &Ruby,
         rb_self: &Self,
         source: String,
         timeout_ms: u64,
         filename: String,
+        void: bool,
     ) -> Result<Value, Error> {
         rb_self.check_live(ruby)?;
         let timeout = if timeout_ms == 0 {
@@ -3023,7 +3036,7 @@ impl Context {
         };
         rb_self
             .core
-            .eval_t(ruby, rb_self.id, source, filename, timeout)
+            .eval_t(ruby, rb_self.id, source, filename, timeout, void)
     }
     fn call(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Value, Error> {
         rb_self.check_live(ruby)?;
@@ -3285,7 +3298,13 @@ impl Script {
     // thrown exception is a RuntimeError; a timeout/stop a ScriptTerminatedError.
     fn run(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
         rb_self.check_live(ruby)?;
-        rb_self.core.run_script(ruby, rb_self.script_id)
+        rb_self.core.run_script(ruby, rb_self.script_id, false)
+    }
+    // Run it for its effect only, discarding the completion value (see
+    // Context#eval_void) — what a <script> tag does.
+    fn run_void(ruby: &Ruby, rb_self: &Self) -> Result<Value, Error> {
+        rb_self.check_live(ruby)?;
+        rb_self.core.run_script(ruby, rb_self.script_id, true)
     }
     fn cached_data(ruby: &Ruby, rb_self: &Self) -> Value {
         code_cache_value(ruby, rb_self.cached_data.as_ref())
@@ -3506,8 +3525,9 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
 
     // A v8::Context (realm): eval/call/attach/compile_module.
     let context = module.define_class("Context", ruby.class_object())?;
-    // keyword-arg wrapper Context#eval(source, timeout_ms:, filename:) in lib.
-    context.define_method("_eval", method!(Context::eval, 3))?;
+    // Backs both keyword-arg wrappers in lib: Context#eval(source, timeout_ms:,
+    // filename:) and #eval_void, which differ only in the 4th arg (the void flag).
+    context.define_method("_eval", method!(Context::eval, 4))?;
     context.define_method("call", method!(Context::call, -1))?;
     context.define_method("call_void", method!(Context::call_void, -1))?;
     context.define_method("attach", method!(Context::attach, 2))?;
@@ -3523,6 +3543,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     // Classic compiled script: Context#compile -> #run / #cached_data.
     let script = module.define_class("Script", ruby.class_object())?;
     script.define_method("run", method!(Script::run, 0))?;
+    script.define_method("run_void", method!(Script::run_void, 0))?;
     script.define_method("cached_data", method!(Script::cached_data, 0))?;
     script.define_method("cache_rejected?", method!(Script::cache_rejected, 0))?;
     script.define_method("create_code_cache", method!(Script::create_code_cache, 0))?;

data/ext/rusty_racer/src/ops.rs

@@ -51,6 +51,11 @@ pub(crate) enum Request {
         source: String,
         filename: String,
         timeout_ms: u64,
+        // void = don't marshal the completion value (see Call's |void|). A
+        // statement-list eval run for its EFFECT still has one — the last
+        // statement's value — and marshalling it can throw (an accessor, a
+        // Proxy trap) or walk a huge graph, for a value the caller discards.
+        void: bool,
     },
     // Resolve a dotted function path on globalThis and invoke it with marshalled
     // args (v8::Function::call), preserving the holder as `this`. Distinct from
@@ -146,10 +151,12 @@ pub(crate) enum Request {
         produce_cache: bool,
         eager: bool,
     },
-    // Bind the script to its context and run it; returns the completion value.
+    // Bind the script to its context and run it; returns the completion value
+    // (unless |void| — see Eval).
     RunScript {
         script_id: i32,
         timeout_ms: u64,
+        void: bool,
     },
     DisposeScript {
         script_id: i32,
@@ -220,6 +227,7 @@ pub(crate) fn run_source(
     scope: &mut v8::PinScope<'_, '_>,
     source: &str,
     filename: &str,
+    void: bool,
 ) -> Result<JsVal, VmError> {
     v8::tc_scope!(let tc, scope);
     // Compile and run as distinct phases so a compile failure maps to
@@ -252,6 +260,7 @@ pub(crate) fn run_source(
         }
     };
     match script.run(tc) {
+        Some(_) if void => Ok(JsVal::Undefined),
         Some(value) => marshalled!(tc, value),
         None if tc.has_terminated() => Err(VmError::Terminated),
         None => {
@@ -448,7 +457,10 @@ fn dispatch_one(
             source,
             filename,
             timeout_ms,
-        } => op_eval(scope, context_id, source, filename, timeout_ms, outermost),
+            void,
+        } => op_eval(
+            scope, context_id, source, filename, timeout_ms, void, outermost,
+        ),
         Request::Call {
             context_id,
             name,
@@ -515,7 +527,8 @@ fn dispatch_one(
         Request::RunScript {
             script_id,
             timeout_ms,
-        } => op_run_script(scope, script_id, timeout_ms, outermost),
+            void,
+        } => op_run_script(scope, script_id, timeout_ms, void, outermost),
         Request::DisposeScript { script_id } => op_dispose_script(scope, script_id),
         // Serialize the script's CURRENT compile state. The stored handle is
         // the UnboundScript, which V8 fills in with inner-function bytecode as
@@ -558,12 +571,14 @@ fn op_low_memory_notification(scope: &mut v8::PinScope<'_, '_, ()>) -> VmReply {
     VmReply::Done(Ok(JsVal::Undefined))
 }
 
+#[allow(clippy::too_many_arguments)]
 fn op_eval(
     scope: &mut v8::PinScope<'_, '_, ()>,
     context_id: i32,
     source: String,
     filename: String,
     timeout_ms: u64,
+    void: bool,
     outermost: bool,
 ) -> VmReply {
     let outcome = run_js_bracketed(scope, outermost, timeout_ms, "eval", |scope, outermost| {
@@ -572,7 +587,7 @@ fn op_eval(
             Some(ctx) => {
                 let context = v8::Local::new(scope, &ctx);
                 let scope = &mut v8::ContextScope::new(scope, context);
-                let out = run_source(scope, &source, &filename);
+                let out = run_source(scope, &source, &filename, void);
                 auto_drain(scope, outermost);
                 (true, out)
             }
@@ -1278,6 +1293,7 @@ fn op_run_script(
     scope: &mut v8::PinScope<'_, '_, ()>,
     script_id: i32,
     timeout_ms: u64,
+    void: bool,
     outermost: bool,
 ) -> VmReply {
     let outcome = run_js_bracketed(
@@ -1302,6 +1318,7 @@ fn op_run_script(
                         let out = {
                             v8::tc_scope!(let tc, scope);
                             match script.run(tc) {
+                                Some(_) if void => Ok(JsVal::Undefined),
                                 Some(value) => marshalled!(tc, value),
                                 None if tc.has_terminated() => Err(VmError::Terminated),
                                 None => {

data/lib/rusty_racer/execjs.rb

@@ -35,9 +35,15 @@ module RustyRacer
         # ExecJS guarantees a bare global (no browser/Node ambient): V8 installs a
         # default `console`, so drop it to match the contract (consumers attach
         # their own if needed), exactly as the mini_racer runtime does.
-        @context.eval('delete globalThis.console')
+        @context.eval_void('delete globalThis.console')
         source = encode(source)
-        translate { @context.eval(source, filename: LOCATION) } if /\S/.match?(source)
+        # eval_void: a bundle is run to POPULATE the context, and its completion
+        # value — the last thing a UMD wrapper happened to evaluate — is nobody's
+        # answer. Marshalling it would walk the whole exports graph on every
+        # context creation, and a lazy/hostile property there would fail the
+        # constructor over a value ExecJS discards. #exec/#eval below must NOT
+        # use it: they read the JSON their wrapper returns.
+        translate { @context.eval_void(source, filename: LOCATION) } if /\S/.match?(source)
       end
 
       # Run statements in a function body and return what they `return` (nil when

data/lib/rusty_racer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RustyRacer
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

data/lib/rusty_racer.rb

@@ -112,7 +112,18 @@ module RustyRacer
     # `timeout_ms` (0 = the isolate default) caps this eval; `filename` names the
     # script in stack traces and parse-error locations.
     def eval(source, timeout_ms: 0, filename: '<eval>')
-      _eval(source, timeout_ms, filename)
+      _eval(source, timeout_ms, filename, false)
+    end
+
+    # Run `source` for its EFFECT and return nil, without marshalling its
+    # completion value — the counterpart of #call_void, and what a <script> tag
+    # does. Worth reaching for whenever the value is incidental: a statement
+    # list still has one (its last statement's), and marshalling reads the
+    # value, which runs JS — a getter or a Proxy trap can throw, failing an eval
+    # whose writes all landed. `globalThis.win = someProxy` is the shape that
+    # bites.
+    def eval_void(source, timeout_ms: 0, filename: '<eval>')
+      _eval(source, timeout_ms, filename, true)
     end
 
     # Compile a classic <script>; returns a RustyRacer::Script to #run.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rusty_racer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Keita Urashima