refactor: factor out CDP message types (#13551)

1 files changed, 43 insertions, 38 deletions

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)