refactor: factor out CDP message types (denoland#13551)

cli/main.rs

@@ -2,6 +2,7 @@
 
 mod auth_tokens;
 mod cache;
+mod cdp;
 mod checksum;
 mod compat;
 mod config_file;

cli/tests/integration/repl_tests.rs

@@ -122,6 +122,23 @@ fn pty_complete_primitives() {
   });
 }
 
+#[test]
+fn pty_complete_expression() {
+  util::with_pty(&["repl"], |mut console| {
+    console.write_text("Deno.\t\t");
+    console.write_text("y");
+    console.write_line("");
+    console.write_line("close();");
+    let output = console.read_all_output();
+    assert!(output.contains("Display all"));
+    assert!(output.contains("core"));
+    assert!(output.contains("args"));
+    assert!(output.contains("exit"));
+    assert!(output.contains("symlink"));
+    assert!(output.contains("permissions"));
+  });
+}
+
 #[test]
 fn pty_complete_imports() {
   util::with_pty(&["repl"], |mut console| {

cli/tools/coverage/mod.rs

@@ -43,33 +43,44 @@ 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)?;
@@ -82,7 +93,7 @@ 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)?;
@@ -592,8 +603,8 @@ pub async fn cover_files(
         })?
     };
     let file = maybe_file.ok_or_else(|| {
-      anyhow!("Failed to fetch \"{}\" from cache. 
-          Before generating coverage report, run `deno test --coverage` to ensure consistent state.", 
+      anyhow!("Failed to fetch \"{}\" from cache.
+          Before generating coverage report, run `deno test --coverage` to ensure consistent state.",
           module_specifier
         )
     })?;

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))

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,57 +74,68 @@ 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(
     &self,
     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)

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;