refactor: clean up unwrap and clone (#17282)

Co-authored-by: Divy Srivastava <dj.srivastava23@gmail.com>

cli/args/config_file.rs

@@ -213,7 +213,7 @@ impl TsConfig {
   }
 
   pub fn as_bytes(&self) -> Vec<u8> {
-    let map = self.0.as_object().unwrap();
+    let map = self.0.as_object().expect("invalid tsconfig");
     let ordered: BTreeMap<_, _> = map.iter().collect();
     let value = json!(ordered);
     value.to_string().as_bytes().to_owned()

cli/args/flags.rs

@@ -465,30 +465,30 @@ impl Flags {
   /// If it returns None, the config file shouldn't be discovered at all.
   pub fn config_path_args(&self) -> Option<Vec<PathBuf>> {
     use DenoSubcommand::*;
-    if let Fmt(FmtFlags { files, .. }) = &self.subcommand {
-      Some(files.include.clone())
-    } else if let Lint(LintFlags { files, .. }) = &self.subcommand {
-      Some(files.include.clone())
-    } else if let Run(RunFlags { script }) = &self.subcommand {
-      if let Ok(module_specifier) = deno_core::resolve_url_or_path(script) {
-        if module_specifier.scheme() == "file"
-          || module_specifier.scheme() == "npm"
-        {
-          if let Ok(p) = module_specifier.to_file_path() {
-            Some(vec![p])
+
+    match &self.subcommand {
+      Fmt(FmtFlags { files, .. }) => Some(files.include.clone()),
+      Lint(LintFlags { files, .. }) => Some(files.include.clone()),
+      Run(RunFlags { script }) => {
+        if let Ok(module_specifier) = deno_core::resolve_url_or_path(script) {
+          if module_specifier.scheme() == "file"
+            || module_specifier.scheme() == "npm"
+          {
+            if let Ok(p) = module_specifier.to_file_path() {
+              Some(vec![p])
+            } else {
+              Some(vec![])
+            }
           } else {
-            Some(vec![])
+            // When the entrypoint doesn't have file: scheme (it's the remote
+            // script), then we don't auto discover config file.
+            None
           }
         } else {
-          // When the entrypoint doesn't have file: scheme (it's the remote
-          // script), then we don't auto discover config file.
-          None
+          Some(vec![])
         }
-      } else {
-        Some(vec![])
       }
-    } else {
-      Some(vec![])
+      _ => Some(vec![]),
     }
   }
 
@@ -583,15 +583,15 @@ pub fn flags_from_vec(args: Vec<String>) -> clap::Result<Flags> {
   if matches.is_present("unstable") {
     flags.unstable = true;
   }
-  if matches.is_present("log-level") {
-    flags.log_level = match matches.value_of("log-level").unwrap() {
-      "debug" => Some(Level::Debug),
-      "info" => Some(Level::Info),
-      _ => unreachable!(),
-    };
-  }
+
   if matches.is_present("quiet") {
     flags.log_level = Some(Level::Error);
+  } else {
+    match matches.value_of("log-level") {
+      Some("debug") => flags.log_level = Some(Level::Debug),
+      Some("info") => flags.log_level = Some(Level::Info),
+      _ => {}
+    }
   }
 
   match matches.subcommand() {
@@ -2556,11 +2556,9 @@ fn fmt_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
   } else {
     None
   };
-  let prose_wrap = if matches.is_present("options-prose-wrap") {
-    Some(matches.value_of("options-prose-wrap").unwrap().to_string())
-  } else {
-    None
-  };
+  let prose_wrap = matches
+    .value_of("options-prose-wrap")
+    .map(ToString::to_string);
 
   flags.subcommand = DenoSubcommand::Fmt(FmtFlags {
     check: matches.is_present("check"),
@@ -2597,12 +2595,7 @@ fn info_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
 fn install_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
   runtime_args_parse(flags, matches, true, true);
 
-  let root = if matches.is_present("root") {
-    let install_root = matches.value_of("root").unwrap();
-    Some(PathBuf::from(install_root))
-  } else {
-    None
-  };
+  let root = matches.value_of("root").map(PathBuf::from);
 
   let force = matches.is_present("force");
   let name = matches.value_of("name").map(|s| s.to_string());
@@ -2625,12 +2618,7 @@ fn install_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
 }
 
 fn uninstall_parse(flags: &mut Flags, matches: &clap::ArgMatches) {
-  let root = if matches.is_present("root") {
-    let install_root = matches.value_of("root").unwrap();
-    Some(PathBuf::from(install_root))
-  } else {
-    None
-  };
+  let root = matches.value_of("root").map(PathBuf::from);
 
   let name = matches.value_of("name").unwrap().to_string();
   flags.subcommand = DenoSubcommand::Uninstall(UninstallFlags { name, root });

cli/build.rs

@@ -219,7 +219,7 @@ mod ts {
           // if it comes from an op crate, we were supplied with the path to the
           // file.
           let path = if let Some(op_crate_lib) = op_crate_libs.get(lib) {
-            PathBuf::from(op_crate_lib).canonicalize().unwrap()
+            PathBuf::from(op_crate_lib).canonicalize()?
             // otherwise we are will generate the path ourself
           } else {
             path_dts.join(format!("lib.{}.d.ts", lib))

cli/deno_std.rs

@@ -8,4 +8,4 @@ use once_cell::sync::Lazy;
 static CURRENT_STD_URL_STR: &str = "https://deno.land/std@0.172.0/";
 
 pub static CURRENT_STD_URL: Lazy<Url> =
-  Lazy::new(|| Url::parse(CURRENT_STD_URL_STR).unwrap());
+  Lazy::new(|| Url::parse(CURRENT_STD_URL_STR).expect("invalid std url"));

cli/http_util.rs

@@ -53,7 +53,7 @@ pub fn resolve_redirect_from_response(
 ) -> Result<Url, AnyError> {
   debug_assert!(response.status().is_redirection());
   if let Some(location) = response.headers().get(LOCATION) {
-    let location_string = location.to_str().unwrap();
+    let location_string = location.to_str()?;
     log::debug!("Redirecting to {:?}...", &location_string);
     let new_url = resolve_url_from_location(request_url, location_string);
     Ok(new_url)

cli/npm/resolution/mod.rs

@@ -239,7 +239,7 @@ impl NpmResolution {
     package_reqs: Vec<NpmPackageReq>,
   ) -> Result<(), AnyError> {
     // only allow one thread in here at a time
-    let _permit = self.update_semaphore.acquire().await.unwrap();
+    let _permit = self.update_semaphore.acquire().await?;
     let snapshot = self.snapshot.read().clone();
 
     let snapshot = self
@@ -255,7 +255,7 @@ impl NpmResolution {
     package_reqs: HashSet<NpmPackageReq>,
   ) -> Result<(), AnyError> {
     // only allow one thread in here at a time
-    let _permit = self.update_semaphore.acquire().await.unwrap();
+    let _permit = self.update_semaphore.acquire().await?;
     let snapshot = self.snapshot.read().clone();
 
     let has_removed_package = !snapshot

cli/proc_state.rs

@@ -133,7 +133,7 @@ impl ProcState {
 
     // Add the extra files listed in the watch flag
     if let Some(watch_paths) = ps.options.watch_paths() {
-      files_to_watch_sender.send(watch_paths.clone()).unwrap();
+      files_to_watch_sender.send(watch_paths.clone())?;
     }
 
     if let Ok(Some(import_map_path)) = ps
@@ -141,7 +141,7 @@ impl ProcState {
       .resolve_import_map_specifier()
       .map(|ms| ms.and_then(|ref s| s.to_file_path().ok()))
     {
-      files_to_watch_sender.send(vec![import_map_path]).unwrap();
+      files_to_watch_sender.send(vec![import_map_path])?;
     }
 
     Ok(ps)
@@ -625,9 +625,9 @@ impl ProcState {
     // but sadly that's not the case due to missing APIs in V8.
     let is_repl = matches!(self.options.sub_command(), DenoSubcommand::Repl(_));
     let referrer = if referrer.is_empty() && is_repl {
-      deno_core::resolve_url_or_path("./$deno$repl.ts").unwrap()
+      deno_core::resolve_url_or_path("./$deno$repl.ts")?
     } else {
-      deno_core::resolve_url_or_path(referrer).unwrap()
+      deno_core::resolve_url_or_path(referrer)?
     };
 
     // FIXME(bartlomieju): this is another hack way to provide NPM specifier

cli/worker.rs

@@ -184,14 +184,10 @@ impl CliMainWorker {
     // Enable op call tracing in core to enable better debugging of op sanitizer
     // failures.
     if self.ps.options.trace_ops() {
-      self
-        .worker
-        .js_runtime
-        .execute_script(
-          &located_script_name!(),
-          "Deno.core.enableOpCallTracing();",
-        )
-        .unwrap();
+      self.worker.js_runtime.execute_script(
+        &located_script_name!(),
+        "Deno.core.enableOpCallTracing();",
+      )?;
     }
 
     let mut maybe_coverage_collector =
@@ -233,13 +229,10 @@ impl CliMainWorker {
   ) -> Result<(), AnyError> {
     self.enable_test();
 
-    self
-      .worker
-      .execute_script(
-        &located_script_name!(),
-        "Deno.core.enableOpCallTracing();",
-      )
-      .unwrap();
+    self.worker.execute_script(
+      &located_script_name!(),
+      "Deno.core.enableOpCallTracing();",
+    )?;
 
     if mode != TestMode::Documentation {
       // We execute the module module as a side module so that import.meta.main is not set.