refactor: clean up unwrap and clone (denoland#17282)

Co-authored-by: Divy Srivastava <[email protected]>

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/[email protected]/";
 
 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,15 +133,15 @@ 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
  .options
  .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.

core/lib.rs

@@ -37,6 +37,8 @@ pub use sourcemap;
 pub use url;
 pub use v8;
 
+pub use deno_ops::op;
+
 pub use crate::async_cancel::CancelFuture;
 pub use crate::async_cancel::CancelHandle;
 pub use crate::async_cancel::CancelTryFuture;
@@ -110,13 +112,12 @@ pub use crate::runtime::Snapshot;
 pub use crate::runtime::V8_WRAPPER_OBJECT_INDEX;
 pub use crate::runtime::V8_WRAPPER_TYPE_INDEX;
 pub use crate::source_map::SourceMapGetter;
-pub use deno_ops::op;
 
 pub fn v8_version() -> &'static str {
  v8::V8::get_version()
 }
 
-/// An internal module re-exporting funcs used by the #[op] (`deno_ops`) macro
+/// An internal module re-exporting functions used by the #[op] (`deno_ops`) macro
 #[doc(hidden)]
 pub mod _ops {
  pub use super::bindings::throw_type_error;

core/module_specifier.rs

@@ -142,7 +142,7 @@ pub fn resolve_path(
  .map_err(|_| ModuleResolutionError::InvalidPath(path_str.into()))?
  .join(path_str);
  let path = normalize_path(path);
- Url::from_file_path(path.clone())
+ Url::from_file_path(&path)
  .map_err(|()| ModuleResolutionError::InvalidPath(path))
 }
 

ext/broadcast_channel/lib.rs

@@ -5,6 +5,10 @@ mod in_memory_broadcast_channel;
 pub use in_memory_broadcast_channel::InMemoryBroadcastChannel;
 pub use in_memory_broadcast_channel::InMemoryBroadcastChannelResource;
 
+use std::cell::RefCell;
+use std::path::PathBuf;
+use std::rc::Rc;
+
 use async_trait::async_trait;
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
@@ -14,9 +18,6 @@ use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
 use deno_core::ZeroCopyBuf;
-use std::cell::RefCell;
-use std::path::PathBuf;
-use std::rc::Rc;
 
 #[async_trait]
 pub trait BroadcastChannel: Clone {

ext/cache/lib.rs

@@ -1,24 +1,23 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
-mod sqlite;
-use deno_core::ByteString;
-pub use sqlite::SqliteBackedCache;
+use std::cell::RefCell;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::sync::Arc;
 
 use async_trait::async_trait;
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
 use deno_core::op;
 use deno_core::serde::Deserialize;
 use deno_core::serde::Serialize;
+use deno_core::ByteString;
 use deno_core::Extension;
 use deno_core::OpState;
 use deno_core::Resource;
 use deno_core::ResourceId;
-
-use std::cell::RefCell;
-use std::path::PathBuf;
-use std::rc::Rc;
-use std::sync::Arc;
+mod sqlite;
+pub use sqlite::SqliteBackedCache;
 
 #[derive(Clone)]
 pub struct CreateCache<C: Cache + 'static>(pub Arc<dyn Fn() -> C>);

ext/cache/sqlite.rs

@@ -1,5 +1,12 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
+use std::borrow::Cow;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::SystemTime;
+use std::time::UNIX_EPOCH;
+
 use async_trait::async_trait;
 use deno_core::error::AnyError;
 use deno_core::parking_lot::Mutex;
@@ -13,13 +20,6 @@ use rusqlite::OptionalExtension;
 use tokio::io::AsyncReadExt;
 use tokio::io::AsyncWriteExt;
 
-use std::borrow::Cow;
-use std::path::PathBuf;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::time::SystemTime;
-use std::time::UNIX_EPOCH;
-
 use crate::deserialize_headers;
 use crate::get_header;
 use crate::serialize_headers;

runtime/ops/web_worker/sync_fetch.rs

@@ -57,8 +57,7 @@ pub fn op_worker_sync_fetch(
  let runtime = tokio::runtime::Builder::new_current_thread()
  .enable_io()
  .enable_time()
- .build()
- .unwrap();
+ .build()?;
 
  let handles: Vec<_> = scripts
  .into_iter()

runtime/permissions/mod.rs

@@ -427,7 +427,7 @@ impl UnaryPermission<ReadDescriptor> {
  self.prompt,
  );
  if prompted {
- let resolved_path = resolve_from_cwd(path).unwrap();
+ let resolved_path = resolve_from_cwd(path)?;
  if result.is_ok() {
  self.granted_list.insert(ReadDescriptor(resolved_path));
  } else {
@@ -446,7 +446,7 @@ impl UnaryPermission<ReadDescriptor> {
  display: &str,
  api_name: &str,
  ) -> Result<(), AnyError> {
- let resolved_path = resolve_from_cwd(path).unwrap();
+ let resolved_path = resolve_from_cwd(path)?;
  let (result, prompted) = self.query(Some(&resolved_path)).check(
  self.name,
  Some(api_name),
@@ -600,7 +600,7 @@ impl UnaryPermission<WriteDescriptor> {
  self.prompt,
  );
  if prompted {
- let resolved_path = resolve_from_cwd(path).unwrap();
+ let resolved_path = resolve_from_cwd(path)?;
  if result.is_ok() {
  self.granted_list.insert(WriteDescriptor(resolved_path));
  } else {