summaryrefslogtreecommitdiff
path: root/cli/tools/repl
diff options
context:
space:
mode:
Diffstat (limited to 'cli/tools/repl')
-rw-r--r--cli/tools/repl/channel.rs9
-rw-r--r--cli/tools/repl/editor.rs81
-rw-r--r--cli/tools/repl/mod.rs5
-rw-r--r--cli/tools/repl/session.rs148
4 files changed, 144 insertions, 99 deletions
diff --git a/cli/tools/repl/channel.rs b/cli/tools/repl/channel.rs
index 7cc802905..4f2086fb5 100644
--- a/cli/tools/repl/channel.rs
+++ b/cli/tools/repl/channel.rs
@@ -2,6 +2,7 @@
use deno_core::anyhow::anyhow;
use deno_core::error::AnyError;
+use deno_core::serde_json;
use deno_core::serde_json::Value;
use std::cell::RefCell;
use tokio::sync::mpsc::channel;
@@ -55,17 +56,19 @@ pub struct RustylineSyncMessageSender {
}
impl RustylineSyncMessageSender {
- pub fn post_message(
+ pub fn post_message<T: serde::Serialize>(
&self,
method: &str,
- params: Option<Value>,
+ params: Option<T>,
) -> Result<Value, AnyError> {
if let Err(err) =
self
.message_tx
.blocking_send(RustylineSyncMessage::PostMessage {
method: method.to_string(),
- params,
+ params: params
+ .map(|params| serde_json::to_value(params))
+ .transpose()?,
})
{
Err(anyhow!("{}", err))
diff --git a/cli/tools/repl/editor.rs b/cli/tools/repl/editor.rs
index 30b9fba87..ea62bd49f 100644
--- a/cli/tools/repl/editor.rs
+++ b/cli/tools/repl/editor.rs
@@ -1,13 +1,13 @@
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+use crate::cdp;
use crate::colors;
use deno_ast::swc::parser::error::SyntaxError;
use deno_ast::swc::parser::token::Token;
use deno_ast::swc::parser::token::Word;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
-use deno_core::serde_json::json;
-use deno_core::serde_json::Value;
+use deno_core::serde_json;
use rustyline::completion::Completer;
use rustyline::error::ReadlineError;
use rustyline::highlight::Highlighter;
@@ -39,20 +39,14 @@ impl EditorHelper {
.sync_sender
.post_message(
"Runtime.globalLexicalScopeNames",
- Some(json!({
- "executionContextId": self.context_id,
- })),
+ Some(cdp::GlobalLexicalScopeNamesArgs {
+ execution_context_id: Some(self.context_id),
+ }),
)
.unwrap();
-
- evaluate_response
- .get("names")
- .unwrap()
- .as_array()
- .unwrap()
- .iter()
- .map(|n| n.as_str().unwrap().to_string())
- .collect()
+ let evaluate_response: cdp::GlobalLexicalScopeNamesResponse =
+ serde_json::from_value(evaluate_response).unwrap();
+ evaluate_response.names
}
pub fn get_expression_property_names(&self, expr: &str) -> Vec<String> {
@@ -80,12 +74,7 @@ impl EditorHelper {
}
fn get_expression_type(&self, expr: &str) -> Option<String> {
- self
- .evaluate_expression(expr)?
- .get("result")?
- .get("type")?
- .as_str()
- .map(|s| s.to_string())
+ self.evaluate_expression(expr).map(|res| res.result.kind)
}
fn get_object_expr_properties(
@@ -93,44 +82,60 @@ impl EditorHelper {
object_expr: &str,
) -> Option<Vec<String>> {
let evaluate_result = self.evaluate_expression(object_expr)?;
- let object_id = evaluate_result.get("result")?.get("objectId")?;
+ let object_id = evaluate_result.result.object_id?;
let get_properties_response = self
.sync_sender
.post_message(
"Runtime.getProperties",
- Some(json!({
- "objectId": object_id,
- })),
+ Some(cdp::GetPropertiesArgs {
+ object_id,
+ own_properties: None,
+ accessor_properties_only: None,
+ generate_preview: None,
+ non_indexed_properties_only: None,
+ }),
)
.ok()?;
-
+ let get_properties_response: cdp::GetPropertiesResponse =
+ serde_json::from_value(get_properties_response).ok()?;
Some(
get_properties_response
- .get("result")?
- .as_array()
- .unwrap()
- .iter()
- .map(|r| r.get("name").unwrap().as_str().unwrap().to_string())
+ .result
+ .into_iter()
+ .map(|prop| prop.name)
.collect(),
)
}
- fn evaluate_expression(&self, expr: &str) -> Option<Value> {
+ fn evaluate_expression(&self, expr: &str) -> Option<cdp::EvaluateResponse> {
let evaluate_response = self
.sync_sender
.post_message(
"Runtime.evaluate",
- Some(json!({
- "contextId": self.context_id,
- "expression": expr,
- "throwOnSideEffect": true,
- "timeout": 200,
- })),
+ Some(cdp::EvaluateArgs {
+ expression: expr.to_string(),
+ object_group: None,
+ include_command_line_api: None,
+ silent: None,
+ context_id: Some(self.context_id),
+ return_by_value: None,
+ generate_preview: None,
+ user_gesture: None,
+ await_promise: None,
+ throw_on_side_effect: Some(true),
+ timeout: Some(200),
+ disable_breaks: None,
+ repl_mode: None,
+ allow_unsafe_eval_blocked_by_csp: None,
+ unique_context_id: None,
+ }),
)
.ok()?;
+ let evaluate_response: cdp::EvaluateResponse =
+ serde_json::from_value(evaluate_response).ok()?;
- if evaluate_response.get("exceptionDetails").is_some() {
+ if evaluate_response.exception_details.is_some() {
None
} else {
Some(evaluate_response)
diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs
index 0c9fdbfb0..b49c641c4 100644
--- a/cli/tools/repl/mod.rs
+++ b/cli/tools/repl/mod.rs
@@ -33,10 +33,7 @@ async fn read_line_and_poll(
}
result = message_handler.recv() => {
match result {
- Some(RustylineSyncMessage::PostMessage {
- method,
- params
- }) => {
+ Some(RustylineSyncMessage::PostMessage { method, params }) => {
let result = repl_session
.post_message_with_event_loop(&method, params)
.await;
diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs
index 5d458189f..57109eb1d 100644
--- a/cli/tools/repl/session.rs
+++ b/cli/tools/repl/session.rs
@@ -1,12 +1,13 @@
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+use crate::cdp;
use crate::colors;
use crate::lsp::ReplLanguageServer;
use deno_ast::DiagnosticsError;
use deno_ast::ImportsNotUsedAsValues;
use deno_core::error::AnyError;
use deno_core::futures::FutureExt;
-use deno_core::serde_json::json;
+use deno_core::serde_json;
use deno_core::serde_json::Value;
use deno_core::LocalInspectorSession;
use deno_runtime::worker::MainWorker;
@@ -58,7 +59,7 @@ impl std::fmt::Display for EvaluationOutput {
struct TsEvaluateResponse {
ts_code: String,
- value: Value,
+ value: cdp::EvaluateResponse,
}
pub struct ReplSession {
@@ -75,7 +76,9 @@ impl ReplSession {
worker
.with_event_loop(
- session.post_message("Runtime.enable", None).boxed_local(),
+ session
+ .post_message::<()>("Runtime.enable", None)
+ .boxed_local(),
)
.await?;
@@ -115,9 +118,8 @@ impl ReplSession {
let closed = self
.evaluate_expression("(this.closed)")
.await?
- .get("result")
- .unwrap()
- .get("value")
+ .result
+ .value
.unwrap()
.as_bool()
.unwrap();
@@ -125,10 +127,10 @@ impl ReplSession {
Ok(closed)
}
- pub async fn post_message_with_event_loop(
+ pub async fn post_message_with_event_loop<T: serde::Serialize>(
&mut self,
method: &str,
- params: Option<Value>,
+ params: Option<T>,
) -> Result<Value, AnyError> {
self
.worker
@@ -156,23 +158,24 @@ impl ReplSession {
match self.evaluate_line_with_object_wrapping(line).await {
Ok(evaluate_response) => {
- let evaluate_result = evaluate_response.value.get("result").unwrap();
- let evaluate_exception_details =
- evaluate_response.value.get("exceptionDetails");
+ let cdp::EvaluateResponse {
+ result,
+ exception_details,
+ } = evaluate_response.value;
- if evaluate_exception_details.is_some() {
- self.set_last_thrown_error(evaluate_result).await?;
+ if exception_details.is_some() {
+ self.set_last_thrown_error(&result).await?;
} else {
self
.language_server
.commit_text(&evaluate_response.ts_code)
.await;
- self.set_last_eval_result(evaluate_result).await?;
+ self.set_last_eval_result(&result).await?;
}
- let value = self.get_eval_value(evaluate_result).await?;
- Ok(match evaluate_exception_details {
+ let value = self.get_eval_value(&result).await?;
+ Ok(match exception_details {
Some(_) => EvaluationOutput::Error(format!("Uncaught {}", value)),
None => EvaluationOutput::Value(value),
})
@@ -224,7 +227,7 @@ impl ReplSession {
.as_ref()
.unwrap()
.value
- .get("exceptionDetails")
+ .exception_details
.is_some())
{
self.evaluate_ts_expression(line).await
@@ -235,66 +238,90 @@ impl ReplSession {
async fn set_last_thrown_error(
&mut self,
- error: &Value,
+ error: &cdp::RemoteObject,
) -> Result<(), AnyError> {
self.post_message_with_event_loop(
"Runtime.callFunctionOn",
- Some(json!({
- "executionContextId": self.context_id,
- "functionDeclaration": "function (object) { Deno[Deno.internal].lastThrownError = object; }",
- "arguments": [
- error,
- ],
- })),
+ Some(cdp::CallFunctionOnArgs {
+ function_declaration: "function (object) { Deno[Deno.internal].lastThrownError = object; }".to_string(),
+ object_id: None,
+ arguments: Some(vec![error.into()]),
+ silent: None,
+ return_by_value: None,
+ generate_preview: None,
+ user_gesture: None,
+ await_promise: None,
+ execution_context_id: Some(self.context_id),
+ object_group: None,
+ throw_on_side_effect: None
+ }),
).await?;
Ok(())
}
async fn set_last_eval_result(
&mut self,
- evaluate_result: &Value,
+ evaluate_result: &cdp::RemoteObject,
) -> Result<(), AnyError> {
- self.post_message_with_event_loop(
- "Runtime.callFunctionOn",
- Some(json!({
- "executionContextId": self.context_id,
- "functionDeclaration": "function (object) { Deno[Deno.internal].lastEvalResult = object; }",
- "arguments": [
- evaluate_result,
- ],
- })),
- ).await?;
+ self
+ .post_message_with_event_loop(
+ "Runtime.callFunctionOn",
+ Some(cdp::CallFunctionOnArgs {
+ function_declaration:
+ "function (object) { Deno[Deno.internal].lastEvalResult = object; }"
+ .to_string(),
+ object_id: None,
+ arguments: Some(vec![evaluate_result.into()]),
+ silent: None,
+ return_by_value: None,
+ generate_preview: None,
+ user_gesture: None,
+ await_promise: None,
+ execution_context_id: Some(self.context_id),
+ object_group: None,
+ throw_on_side_effect: None,
+ }),
+ )
+ .await?;
Ok(())
}
pub async fn get_eval_value(
&mut self,
- evaluate_result: &Value,
+ evaluate_result: &cdp::RemoteObject,
) -> Result<String, AnyError> {
// TODO(caspervonb) we should investigate using previews here but to keep things
// consistent with the previous implementation we just get the preview result from
// Deno.inspectArgs.
let inspect_response = self.post_message_with_event_loop(
"Runtime.callFunctionOn",
- Some(json!({
- "executionContextId": self.context_id,
- "functionDeclaration": r#"function (object) {
+ Some(cdp::CallFunctionOnArgs {
+ function_declaration: r#"function (object) {
try {
return Deno[Deno.internal].inspectArgs(["%o", object], { colors: !Deno.noColor });
} catch (err) {
return Deno[Deno.internal].inspectArgs(["%o", err]);
}
- }"#,
- "arguments": [
- evaluate_result,
- ],
- })),
+ }"#.to_string(),
+ object_id: None,
+ arguments: Some(vec![evaluate_result.into()]),
+ silent: None,
+ return_by_value: None,
+ generate_preview: None,
+ user_gesture: None,
+ await_promise: None,
+ execution_context_id: Some(self.context_id),
+ object_group: None,
+ throw_on_side_effect: None
+ }),
).await?;
- let inspect_result = inspect_response.get("result").unwrap();
- let value = inspect_result.get("value").unwrap().as_str().unwrap();
+ let response: cdp::CallFunctionOnResponse =
+ serde_json::from_value(inspect_response)?;
+ let value = response.result.value.unwrap();
+ let s = value.as_str().unwrap();
- Ok(value.to_string())
+ Ok(s.to_string())
}
async fn evaluate_ts_expression(
@@ -344,16 +371,29 @@ impl ReplSession {
async fn evaluate_expression(
&mut self,
expression: &str,
- ) -> Result<Value, AnyError> {
+ ) -> Result<cdp::EvaluateResponse, AnyError> {
self
.post_message_with_event_loop(
"Runtime.evaluate",
- Some(json!({
- "expression": expression,
- "contextId": self.context_id,
- "replMode": true,
- })),
+ Some(cdp::EvaluateArgs {
+ expression: expression.to_string(),
+ object_group: None,
+ include_command_line_api: None,
+ silent: None,
+ context_id: Some(self.context_id),
+ return_by_value: None,
+ generate_preview: None,
+ user_gesture: None,
+ await_promise: None,
+ throw_on_side_effect: None,
+ timeout: None,
+ disable_breaks: None,
+ repl_mode: Some(true),
+ allow_unsafe_eval_blocked_by_csp: None,
+ unique_context_id: None,
+ }),
)
.await
+ .and_then(|res| serde_json::from_value(res).map_err(|e| e.into()))
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-31 00:58:08 +0000