fix(repl): don't panic on lone surrogates

Cargo.toml

@@ -27,6 +27,10 @@ members = [
 ]
 exclude = ["test_util/std/hash/_wasm"]
 
+# use serde_json lucacasonato/json.git@5ec8141acf127d9dcbc01b2b63c6426d158ee1af
+[patch.crates-io]
+serde_json = { git = "https://github.com/lucacasonato/json", branch = "support_lone_surrogates_in_raw_value" }
+
 # NB: the `bench` and `release` profiles must remain EXACTLY the same.
 [profile.release]
 codegen-units = 1

cli/tools/coverage/mod.rs

@@ -43,36 +43,47 @@ impl CoverageCollector {
   }
 
   async fn enable_debugger(&mut self) -> Result<(), AnyError> {
-    self.session.post_message("Debugger.enable", None).await?;
+    self
+      .session
+      .post_message("Debugger.enable", None::<()>)
+      .await?;
     Ok(())
   }
 
   async fn enable_profiler(&mut self) -> Result<(), AnyError> {
-    self.session.post_message("Profiler.enable", None).await?;
+    self
+      .session
+      .post_message("Profiler.enable", None::<()>)
+      .await?;
     Ok(())
   }
 
   async fn disable_debugger(&mut self) -> Result<(), AnyError> {
-    self.session.post_message("Debugger.disable", None).await?;
+    self
+      .session
+      .post_message("Debugger.disable", None::<()>)
+      .await?;
     Ok(())
   }
 
   async fn disable_profiler(&mut self) -> Result<(), AnyError> {
-    self.session.post_message("Profiler.disable", None).await?;
+    self
+      .session
+      .post_message("Profiler.disable", None::<()>)
+      .await?;
     Ok(())
   }
 
   async fn start_precise_coverage(
     &mut self,
     parameters: StartPreciseCoverageParameters,
   ) -> Result<StartPreciseCoverageReturnObject, AnyError> {
-    let parameters_value = serde_json::to_value(parameters)?;
     let return_value = self
       .session
-      .post_message("Profiler.startPreciseCoverage", Some(parameters_value))
+      .post_message("Profiler.startPreciseCoverage", Some(parameters))
       .await?;
 
-    let return_object = serde_json::from_value(return_value)?;
+    let return_object = serde_json::from_str(return_value.get())?;
 
     Ok(return_object)
   }
@@ -82,10 +93,10 @@ impl CoverageCollector {
   ) -> Result<TakePreciseCoverageReturnObject, AnyError> {
     let return_value = self
       .session
-      .post_message("Profiler.takePreciseCoverage", None)
+      .post_message("Profiler.takePreciseCoverage", None::<()>)
       .await?;
 
-    let return_object = serde_json::from_value(return_value)?;
+    let return_object = serde_json::from_str(return_value.get())?;
 
     Ok(return_object)
   }

cli/tools/repl/channel.rs

@@ -2,6 +2,7 @@
 
 use deno_core::anyhow::anyhow;
 use deno_core::error::AnyError;
+use deno_core::serde_json::value::RawValue;
 use deno_core::serde_json::Value;
 use std::cell::RefCell;
 use tokio::sync::mpsc::channel;
@@ -35,17 +36,17 @@ pub fn rustyline_channel(
 
 pub enum RustylineSyncMessage {
   PostMessage {
-    method: String,
+    method: &'static str,
     params: Option<Value>,
   },
   LspCompletions {
-    line_text: String,
+    line_text: &'static str,
     position: usize,
   },
 }
 
 pub enum RustylineSyncResponse {
-  PostMessage(Result<Value, AnyError>),
+  PostMessage(Result<Box<RawValue>, AnyError>),
   LspCompletions(Vec<ReplCompletionItem>),
 }
 
@@ -57,16 +58,12 @@ pub struct RustylineSyncMessageSender {
 impl RustylineSyncMessageSender {
   pub fn post_message(
     &self,
-    method: &str,
+    method: &'static str,
     params: Option<Value>,
-  ) -> Result<Value, AnyError> {
-    if let Err(err) =
-      self
-        .message_tx
-        .blocking_send(RustylineSyncMessage::PostMessage {
-          method: method.to_string(),
-          params,
-        })
+  ) -> Result<Box<RawValue>, AnyError> {
+    if let Err(err) = self
+      .message_tx
+      .blocking_send(RustylineSyncMessage::PostMessage { method, params })
     {
       Err(anyhow!("{}", err))
     } else {