chore: use Rust 1.65.0 (#16688)

.github/workflows/ci.yml

@@ -157,15 +157,15 @@ jobs:
           # to complete.
           sudo apt-get remove --purge -y man-db
 
-          # Install clang-14, lld-14, and debootstrap.
+          # Install clang-15, lld-15, and debootstrap.
-          echo "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main" |
+          echo "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-15 main" |
-            sudo dd of=/etc/apt/sources.list.d/llvm-toolchain-focal-14.list
+            sudo dd of=/etc/apt/sources.list.d/llvm-toolchain-focal-15.list
           curl https://apt.llvm.org/llvm-snapshot.gpg.key |
             gpg --dearmor                                 |
           sudo dd of=/etc/apt/trusted.gpg.d/llvm-snapshot.gpg
           sudo apt-get update
           sudo apt-get install --no-install-recommends debootstrap     \
-                                                       clang-14 lld-14
+                                                       clang-15 lld-15
 
           # Create ubuntu-16.04 sysroot environment, which is used to avoid
           # depending on a very recent version of glibc.
@@ -190,8 +190,8 @@ jobs:
           CARGO_PROFILE_RELEASE_LTO=false
           RUSTFLAGS<<__1
             -C linker-plugin-lto=true
-            -C linker=clang-14
+            -C linker=clang-15
-            -C link-arg=-fuse-ld=lld-14
+            -C link-arg=-fuse-ld=lld-15
             -C link-arg=--sysroot=/sysroot
             -C link-arg=-Wl,--allow-shlib-undefined
             -C link-arg=-Wl,--thinlto-cache-dir=$(pwd)/target/release/lto-cache
@@ -200,15 +200,15 @@ jobs:
           __1
           RUSTDOCFLAGS<<__1
             -C linker-plugin-lto=true
-            -C linker=clang-14
+            -C linker=clang-15
-            -C link-arg=-fuse-ld=lld-14
+            -C link-arg=-fuse-ld=lld-15
             -C link-arg=--sysroot=/sysroot
             -C link-arg=-Wl,--allow-shlib-undefined
             -C link-arg=-Wl,--thinlto-cache-dir=$(pwd)/target/release/lto-cache
             -C link-arg=-Wl,--thinlto-cache-policy,cache_size_bytes=700m
             ${{ env.RUSTFLAGS }}
           __1
-          CC=clang-14
+          CC=clang-15
           CFLAGS=-flto=thin --sysroot=/sysroot
           __0
 

cli/args/flags.rs

@@ -637,7 +637,7 @@ fn clap_root(version: &str) -> Command {
         .help("Set log level")
         .hide(true)
         .takes_value(true)
-        .possible_values(&["debug", "info"])
+        .possible_values(["debug", "info"])
         .global(true),
     )
     .arg(
@@ -811,7 +811,7 @@ fn compile_subcommand<'a>() -> Command<'a> {
         .long("target")
         .help("Target OS architecture")
         .takes_value(true)
-        .possible_values(&[
+        .possible_values([
           "x86_64-unknown-linux-gnu",
           "x86_64-pc-windows-msvc",
           "x86_64-apple-darwin",
@@ -848,7 +848,7 @@ fn completions_subcommand<'a>() -> Command<'a> {
     .disable_help_subcommand(true)
     .arg(
       Arg::new("shell")
-        .possible_values(&["bash", "fish", "powershell", "zsh", "fig"])
+        .possible_values(["bash", "fish", "powershell", "zsh", "fig"])
         .required(true),
     )
     .about("Generate shell completions")
@@ -1049,7 +1049,7 @@ This command has implicit access to all permissions (--allow-all).",
         .help("Set standard input (stdin) content type")
         .takes_value(true)
         .default_value("js")
-        .possible_values(&["ts", "tsx", "js", "jsx"]),
+        .possible_values(["ts", "tsx", "js", "jsx"]),
     )
     .arg(
       Arg::new("print")
@@ -1106,7 +1106,7 @@ Ignore formatting a file by adding an ignore comment at the top of the file:
         .help("Set standard input (stdin) content type")
         .takes_value(true)
         .default_value("ts")
-        .possible_values(&["ts", "tsx", "js", "jsx", "md", "json", "jsonc"]),
+        .possible_values(["ts", "tsx", "js", "jsx", "md", "json", "jsonc"]),
     )
     .arg(
       Arg::new("ignore")
@@ -1165,7 +1165,7 @@ Ignore formatting a file by adding an ignore comment at the top of the file:
       Arg::new("options-prose-wrap")
         .long("options-prose-wrap")
         .takes_value(true)
-        .possible_values(&["always", "never", "preserve"])
+        .possible_values(["always", "never", "preserve"])
         .help("Define how prose should be wrapped. Defaults to always."),
     )
 }

cli/bench/main.rs

@@ -343,7 +343,7 @@ fn run_max_mem_benchmark(deno_exe: &Path) -> Result<HashMap<String, i64>> {
 
   for (name, args, return_code) in EXEC_TIME_BENCHMARKS {
     let proc = Command::new("time")
-      .args(&["-v", deno_exe.to_str().unwrap()])
+      .args(["-v", deno_exe.to_str().unwrap()])
       .args(args.iter())
       .stdout(Stdio::null())
       .stderr(Stdio::piped())
@@ -501,7 +501,7 @@ async fn main() -> Result<()> {
       let mut file = secure_tempfile::NamedTempFile::new()?;
 
       let exit_status = Command::new("strace")
-        .args(&[
+        .args([
           "-c",
           "-f",
           "-o",

cli/build.rs

@@ -39,7 +39,7 @@ fn create_snapshot(
   }
 
   let snapshot = js_runtime.snapshot();
-  let snapshot_slice: &[u8] = &*snapshot;
+  let snapshot_slice: &[u8] = &snapshot;
   println!("Snapshot size: {}", snapshot_slice.len());
 
   let compressed_snapshot_with_size = {
@@ -64,7 +64,7 @@ fn create_snapshot(
     compressed_snapshot_with_size.len()
   );
 
-  std::fs::write(&snapshot_path, compressed_snapshot_with_size).unwrap();
+  std::fs::write(snapshot_path, compressed_snapshot_with_size).unwrap();
   println!("Snapshot written to: {} ", snapshot_path.display());
 }
 

cli/cache/disk_cache.rs

@@ -40,7 +40,7 @@ impl DiskCache {
     if path.is_dir() {
       return Ok(());
     }
-    fs::create_dir_all(&path).map_err(|e| {
+    fs::create_dir_all(path).map_err(|e| {
       io::Error::new(e.kind(), format!(
         "Could not create TypeScript compiler cache location: {:?}\nCheck the permission of the directory.",
         path

cli/fs_util.rs

@@ -333,9 +333,9 @@ pub async fn remove_dir_all_if_exists(path: &Path) -> std::io::Result<()> {
 ///
 /// Note: Does not handle symlinks.
 pub fn copy_dir_recursive(from: &Path, to: &Path) -> Result<(), AnyError> {
-  std::fs::create_dir_all(&to)
+  std::fs::create_dir_all(to)
     .with_context(|| format!("Creating {}", to.display()))?;
-  let read_dir = std::fs::read_dir(&from)
+  let read_dir = std::fs::read_dir(from)
     .with_context(|| format!("Reading {}", from.display()))?;
 
   for entry in read_dir {
@@ -362,9 +362,9 @@ pub fn copy_dir_recursive(from: &Path, to: &Path) -> Result<(), AnyError> {
 ///
 /// Note: Does not handle symlinks.
 pub fn hard_link_dir_recursive(from: &Path, to: &Path) -> Result<(), AnyError> {
-  std::fs::create_dir_all(&to)
+  std::fs::create_dir_all(to)
     .with_context(|| format!("Creating {}", to.display()))?;
-  let read_dir = std::fs::read_dir(&from)
+  let read_dir = std::fs::read_dir(from)
     .with_context(|| format!("Reading {}", from.display()))?;
 
   for entry in read_dir {
@@ -451,7 +451,7 @@ pub fn symlink_dir(oldpath: &Path, newpath: &Path) -> Result<(), AnyError> {
   #[cfg(unix)]
   {
     use std::os::unix::fs::symlink;
-    symlink(&oldpath, &newpath).map_err(err_mapper)?;
+    symlink(oldpath, newpath).map_err(err_mapper)?;
   }
   #[cfg(not(unix))]
   {

cli/http_cache.rs

@@ -123,7 +123,7 @@ impl HttpCache {
     if path.is_dir() {
       return Ok(());
     }
-    fs::create_dir_all(&path).map_err(|e| {
+    fs::create_dir_all(path).map_err(|e| {
       io::Error::new(
         e.kind(),
         format!(

cli/lsp/completions.rs

@@ -469,7 +469,7 @@ fn get_workspace_completions(
   specifier_strings
     .into_iter()
     .filter_map(|label| {
-      if label.starts_with(&current) {
+      if label.starts_with(current) {
         let detail = Some(
           if label.starts_with("http:") || label.starts_with("https:") {
             "(remote)".to_string()

cli/lsp/path_to_regex.rs

@@ -877,7 +877,7 @@ mod tests {
     assert!(result.is_ok(), "Could not parse path: \"{}\"", path);
     let (re, _) = result.unwrap();
     for (fixture, expected) in fixtures {
-      let result = re.find(*fixture);
+      let result = re.find(fixture);
       assert!(
         result.is_ok(),
         "Find failure for path \"{}\" and fixture \"{}\"",

cli/main.rs

@@ -772,7 +772,7 @@ async fn test_command(
   test_flags: TestFlags,
 ) -> Result<i32, AnyError> {
   if let Some(ref coverage_dir) = flags.coverage_dir {
-    std::fs::create_dir_all(&coverage_dir)?;
+    std::fs::create_dir_all(coverage_dir)?;
     env::set_var(
       "DENO_UNSTABLE_COVERAGE_DIR",
       PathBuf::from(coverage_dir).canonicalize()?,
@@ -994,7 +994,7 @@ pub fn main() {
       Err(err) => unwrap_or_exit(Err(AnyError::from(err))),
     };
     if !flags.v8_flags.is_empty() {
-      init_v8_flags(&*flags.v8_flags);
+      init_v8_flags(&flags.v8_flags);
     }
 
     logger::init(flags.log_level);

cli/module_loader.rs

@@ -140,7 +140,7 @@ impl CliModuleLoader {
       let file_path = specifier.to_file_path().unwrap();
       let code = std::fs::read_to_string(&file_path).with_context(|| {
         let mut msg = "Unable to load ".to_string();
-        msg.push_str(&*file_path.to_string_lossy());
+        msg.push_str(&file_path.to_string_lossy());
         if let Some(referrer) = &maybe_referrer {
           msg.push_str(" imported from ");
           msg.push_str(referrer.as_str());

cli/npm/cache.rs

@@ -78,7 +78,7 @@ pub fn with_folder_sync_lock(
   match inner(output_folder, action) {
     Ok(()) => Ok(()),
     Err(err) => {
-      if let Err(remove_err) = fs::remove_dir_all(&output_folder) {
+      if let Err(remove_err) = fs::remove_dir_all(output_folder) {
         if remove_err.kind() != std::io::ErrorKind::NotFound {
           bail!(
             concat!(
@@ -156,7 +156,7 @@ impl ReadonlyNpmCache {
       root_dir: &Path,
     ) -> Result<PathBuf, AnyError> {
       if !root_dir.exists() {
-        std::fs::create_dir_all(&root_dir)
+        std::fs::create_dir_all(root_dir)
           .with_context(|| format!("Error creating {}", root_dir.display()))?;
       }
       Ok(crate::fs_util::canonicalize_path(root_dir)?)

cli/npm/registry.rs

@@ -397,7 +397,7 @@ impl RealNpmRegistryApiInner {
   ) -> Result<(), AnyError> {
     let file_cache_path = self.get_package_file_cache_path(name);
     let file_text = serde_json::to_string(&package_info)?;
-    std::fs::create_dir_all(&file_cache_path.parent().unwrap())?;
+    std::fs::create_dir_all(file_cache_path.parent().unwrap())?;
     fs_util::atomic_write_file(&file_cache_path, file_text, CACHE_PERM)?;
     Ok(())
   }

cli/npm/resolution/specifier.rs

@@ -245,7 +245,7 @@ pub fn resolve_npm_package_reqs(graph: &ModuleGraph) -> Vec<NpmPackageReq> {
     for specifier in &specifiers {
       if let Ok(npm_ref) = NpmPackageReference::from_specifier(specifier) {
         leaf.reqs.insert(npm_ref.req);
-      } else if !specifier.as_str().starts_with(&parent_specifier.as_str()) {
+      } else if !specifier.as_str().starts_with(parent_specifier.as_str()) {
         leaf
           .dependencies
           .insert(get_folder_path_specifier(specifier));

cli/npm/resolvers/common.rs

@@ -104,7 +104,7 @@ pub fn ensure_registry_read_permission(
   path: &Path,
 ) -> Result<(), AnyError> {
   // allow reading if it's in the node_modules
-  if path.starts_with(&registry_path)
+  if path.starts_with(registry_path)
     && path
       .components()
       .all(|c| !matches!(c, std::path::Component::ParentDir))

cli/npm/tarball.rs

@@ -110,8 +110,8 @@ fn extract_tarball(data: &[u8], output_folder: &Path) -> Result<(), AnyError> {
       absolute_path.parent().unwrap()
     };
     if created_dirs.insert(dir_path.to_path_buf()) {
-      fs::create_dir_all(&dir_path)?;
+      fs::create_dir_all(dir_path)?;
-      let canonicalized_dir = fs::canonicalize(&dir_path)?;
+      let canonicalized_dir = fs::canonicalize(dir_path)?;
       if !canonicalized_dir.starts_with(&output_folder) {
         bail!(
           "Extracted directory '{}' of npm tarball was not in output directory.",

cli/tests/integration/info_tests.rs

@@ -15,7 +15,7 @@ fn info_with_compiled_source() {
     .env("DENO_DIR", t.path())
     .current_dir(util::testdata_path())
     .arg("cache")
-    .arg(&module_path)
+    .arg(module_path)
     .spawn()
     .unwrap();
   let status = deno.wait().unwrap();
@@ -26,7 +26,7 @@ fn info_with_compiled_source() {
     .env("NO_COLOR", "1")
     .current_dir(util::testdata_path())
     .arg("info")
-    .arg(&module_path)
+    .arg(module_path)
     .output()
     .unwrap();
 

cli/tests/integration/lsp_tests.rs

@@ -6077,7 +6077,7 @@ Deno.test({
   }
 });
 "#;
-  fs::write(&module_path, &contents).unwrap();
+  fs::write(&module_path, contents).unwrap();
   fs::write(temp_dir.path().join("./deno.jsonc"), r#"{}"#).unwrap();
 
   params.root_uri = Some(root_specifier);

cli/tests/integration/run_tests.rs

@@ -1703,8 +1703,7 @@ fn exec_path() {
     .unwrap();
   assert!(output.status.success());
   let stdout_str = std::str::from_utf8(&output.stdout).unwrap().trim();
-  let actual =
+  let actual = std::fs::canonicalize(std::path::Path::new(stdout_str)).unwrap();
-    std::fs::canonicalize(&std::path::Path::new(stdout_str)).unwrap();
   let expected = std::fs::canonicalize(util::deno_exe_path()).unwrap();
   assert_eq!(expected, actual);
 }

cli/tests/integration/upgrade_tests.rs

@@ -120,7 +120,7 @@ fn upgrade_with_out_in_tmpdir() {
     .arg("--version")
     .arg("1.11.5")
     .arg("--output")
-    .arg(&new_exe_path.to_str().unwrap())
+    .arg(new_exe_path.to_str().unwrap())
     .spawn()
     .unwrap()
     .wait()

cli/tests/integration/vendor_tests.rs

@@ -262,7 +262,7 @@ fn existing_import_map_no_remote() {
   let import_map_filename = "imports2.json";
   let import_map_text =
     r#"{ "imports": { "http://localhost:4545/vendor/": "./logger/" } }"#;
-  t.write(import_map_filename, &import_map_text);
+  t.write(import_map_filename, import_map_text);
   t.create_dir_all("logger");
   t.write("logger/logger.ts", "export class Logger {}");
 

cli/tests/integration/watcher_tests.rs

@@ -219,7 +219,7 @@ fn lint_all_files_on_each_change_test() {
   let mut child = util::deno_cmd()
     .current_dir(util::testdata_path())
     .arg("lint")
-    .arg(&t.path())
+    .arg(t.path())
     .arg("--watch")
     .arg("--unstable")
     .stdout(std::process::Stdio::piped())
@@ -349,7 +349,7 @@ fn fmt_check_all_files_on_each_change_test() {
   let mut child = util::deno_cmd()
     .current_dir(&fmt_testdata_path)
     .arg("fmt")
-    .arg(&t.path())
+    .arg(t.path())
     .arg("--watch")
     .arg("--check")
     .arg("--unstable")
@@ -832,7 +832,7 @@ fn test_watch() {
     .arg("--watch")
     .arg("--unstable")
     .arg("--no-check")
-    .arg(&t.path())
+    .arg(t.path())
     .env("NO_COLOR", "1")
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
@@ -973,7 +973,7 @@ fn test_watch_doc() {
     .arg("--watch")
     .arg("--doc")
     .arg("--unstable")
-    .arg(&t.path())
+    .arg(t.path())
     .env("NO_COLOR", "1")
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())

cli/tools/bench.rs

@@ -210,7 +210,7 @@ impl BenchReporter for ConsoleReporter {
           println!();
         }
 
-        if None == self.group || group != self.group.as_ref().unwrap() {
+        if self.group.is_none() || group != self.group.as_ref().unwrap() {
           self.report_group_summary();
         }
 

cli/tools/coverage/merge.rs

@@ -126,8 +126,7 @@ pub fn merge_functions(
       trees.push(tree);
     }
   }
-  let merged =
+  let merged = RangeTree::normalize(merge_range_trees(&rta, trees).unwrap());
-    RangeTree::normalize(&rta, merge_range_trees(&rta, trees).unwrap());
   let ranges = merged.to_ranges();
   let is_block_coverage: bool = !(ranges.len() == 1 && ranges[0].count == 0);
 

cli/tools/coverage/range_tree.rs

@@ -71,10 +71,7 @@ impl<'rt> RangeTree<'rt> {
     (rta.alloc(left), rta.alloc(right))
   }
 
-  pub fn normalize<'a>(
+  pub fn normalize<'a>(tree: &'a mut RangeTree<'a>) -> &'a mut RangeTree<'a> {
-    rta: &'a RangeTreeArena<'a>,
-    tree: &'a mut RangeTree<'a>,
-  ) -> &'a mut RangeTree<'a> {
     tree.children = {
       let mut children: Vec<&'a mut RangeTree<'a>> = Vec::new();
       let mut chain: Vec<&'a mut RangeTree<'a>> = Vec::new();
@@ -96,7 +93,7 @@ impl<'rt> RangeTree<'rt> {
               head.children.push(sub_child);
             }
           }
-          children.push(RangeTree::normalize(rta, head));
+          children.push(RangeTree::normalize(head));
         }
         chain.push(child)
       }
@@ -110,7 +107,7 @@ impl<'rt> RangeTree<'rt> {
             head.children.push(sub_child);
           }
         }
-        children.push(RangeTree::normalize(rta, head));
+        children.push(RangeTree::normalize(head));
       }
 
       if children.len() == 1

cli/tools/fmt.rs

@@ -635,7 +635,7 @@ struct FileContents {
 }
 
 fn read_file_contents(file_path: &Path) -> Result<FileContents, AnyError> {
-  let file_bytes = fs::read(&file_path)
+  let file_bytes = fs::read(file_path)
     .with_context(|| format!("Error reading {}", file_path.display()))?;
   let charset = text_encoding::detect_charset(&file_bytes);
   let file_text = text_encoding::convert_to_utf8(&file_bytes, charset)?;

cli/tools/standalone.rs

@@ -85,9 +85,9 @@ async fn download_base_binary(
     std::process::exit(1)
   };
 
-  std::fs::create_dir_all(&output_directory)?;
+  std::fs::create_dir_all(output_directory)?;
   let output_path = output_directory.join(binary_path_suffix);
-  std::fs::create_dir_all(&output_path.parent().unwrap())?;
+  std::fs::create_dir_all(output_path.parent().unwrap())?;
   tokio::fs::write(output_path, binary_content).await?;
   Ok(())
 }

cli/tools/test.rs

@@ -742,9 +742,7 @@ fn extract_files_from_regex_blocks(
   let files = blocks_regex
     .captures_iter(source)
     .filter_map(|block| {
-      if block.get(1) == None {
+      block.get(1)?;
-        return None;
-      }
 
       let maybe_attributes: Option<Vec<_>> = block
         .get(1)

cli/tools/vendor/build.rs

@@ -502,7 +502,7 @@ mod test {
     let output = builder
       .with_loader(|loader| {
         loader
-          .add("/mod.ts", &mod_file_text)
+          .add("/mod.ts", mod_file_text)
           .add("https://localhost/mod.ts", "export class Example {}");
       })
       .build()

cli/tools/vendor/mod.rs

@@ -113,7 +113,7 @@ fn validate_options(
     .and_then(|p| fs_util::canonicalize_path(&p).ok())
   {
     // make the output directory in order to canonicalize it for the check below
-    std::fs::create_dir_all(&output_dir)?;
+    std::fs::create_dir_all(output_dir)?;
     let output_dir =
       fs_util::canonicalize_path(output_dir).with_context(|| {
         format!("Failed to canonicalize: {}", output_dir.display())
@@ -248,7 +248,7 @@ fn update_config_text(
 }
 
 fn is_dir_empty(dir_path: &Path) -> Result<bool, AnyError> {
-  match std::fs::read_dir(&dir_path) {
+  match std::fs::read_dir(dir_path) {
     Ok(mut dir) => Ok(dir.next().is_none()),
     Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(true),
     Err(err) => {

cli/tsc.rs

@@ -80,7 +80,7 @@ pub static COMPILER_SNAPSHOT: Lazy<Box<[u8]>> = Lazy::new(
 );
 
 pub fn compiler_snapshot() -> Snapshot {
-  Snapshot::Static(&*COMPILER_SNAPSHOT)
+  Snapshot::Static(&COMPILER_SNAPSHOT)
 }
 
 macro_rules! inc {

core/async_cell.rs

@@ -220,13 +220,13 @@ impl<T> Deref for RcRef<T> {
 
 impl<T> Borrow<T> for RcRef<T> {
   fn borrow(&self) -> &T {
-    &**self
+    self
   }
 }
 
 impl<T> AsRef<T> for RcRef<T> {
   fn as_ref(&self) -> &T {
-    &**self
+    self
   }
 }
 
@@ -478,13 +478,13 @@ mod internal {
 
   impl<T, M: BorrowModeTrait> Borrow<T> for AsyncBorrowImpl<T, M> {
     fn borrow(&self) -> &T {
-      &**self
+      self
     }
   }
 
   impl<T, M: BorrowModeTrait> AsRef<T> for AsyncBorrowImpl<T, M> {
     fn as_ref(&self) -> &T {
-      &**self
+      self
     }
   }
 
@@ -500,13 +500,13 @@ mod internal {
 
   impl<T> BorrowMut<T> for AsyncBorrowImpl<T, Exclusive> {
     fn borrow_mut(&mut self) -> &mut T {
-      &mut **self
+      self
     }
   }
 
   impl<T> AsMut<T> for AsyncBorrowImpl<T, Exclusive> {
     fn as_mut(&mut self) -> &mut T {
-      &mut **self
+      self
     }
   }
 

core/error.rs

@@ -242,7 +242,7 @@ impl JsError {
         serde_v8::from_v8(scope, exception.into()).unwrap_or_default();
       // Get the message by formatting error.name and error.message.
       let name = e.name.clone().unwrap_or_else(|| "Error".to_string());
-      let message_prop = e.message.clone().unwrap_or_else(|| "".to_string());
+      let message_prop = e.message.clone().unwrap_or_default();
       let exception_message = exception_message.unwrap_or_else(|| {
         if !name.is_empty() && !message_prop.is_empty() {
           format!("Uncaught {}: {}", name, message_prop)

core/examples/http_bench_json_ops.rs

@@ -131,7 +131,7 @@ fn create_js_runtime() -> JsRuntime {
 fn op_listen(state: &mut OpState) -> Result<ResourceId, Error> {
   log::debug!("listen");
   let addr = "127.0.0.1:4570".parse::<SocketAddr>().unwrap();
-  let std_listener = std::net::TcpListener::bind(&addr)?;
+  let std_listener = std::net::TcpListener::bind(addr)?;
   std_listener.set_nonblocking(true)?;
   let listener = TcpListener::try_from(std_listener)?;
   let rid = state.resource_table.add(listener);

core/runtime.rs

@@ -2888,7 +2888,7 @@ pub mod tests {
         ..Default::default()
       });
       runtime.execute_script("a.js", "a = 1 + 2").unwrap();
-      let snap: &[u8] = &*runtime.snapshot();
+      let snap: &[u8] = &runtime.snapshot();
       Vec::from(snap).into_boxed_slice()
     };
 
@@ -4051,7 +4051,7 @@ Deno.core.ops.op_async_serialize_object_with_numbers_as_keys({
         will_snapshot: true,
         ..Default::default()
       });
-      let snap: &[u8] = &*runtime.snapshot();
+      let snap: &[u8] = &runtime.snapshot();
       Vec::from(snap).into_boxed_slice()
     };
 

ext/crypto/lib.rs

@@ -198,14 +198,14 @@ pub async fn op_crypto_sign_key(
 
   let signature = match algorithm {
     Algorithm::RsassaPkcs1v15 => {
-      let private_key = RsaPrivateKey::from_pkcs1_der(&*args.key.data)?;
+      let private_key = RsaPrivateKey::from_pkcs1_der(&args.key.data)?;
       let (padding, hashed) = match args
         .hash
         .ok_or_else(|| type_error("Missing argument hash".to_string()))?
       {
         CryptoHash::Sha1 => {
           let mut hasher = Sha1::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA1),
@@ -215,7 +215,7 @@ pub async fn op_crypto_sign_key(
         }
         CryptoHash::Sha256 => {
           let mut hasher = Sha256::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA2_256),
@@ -225,7 +225,7 @@ pub async fn op_crypto_sign_key(
         }
         CryptoHash::Sha384 => {
           let mut hasher = Sha384::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA2_384),
@@ -235,7 +235,7 @@ pub async fn op_crypto_sign_key(
         }
         CryptoHash::Sha512 => {
           let mut hasher = Sha512::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA2_512),
@@ -248,7 +248,7 @@ pub async fn op_crypto_sign_key(
       private_key.sign(padding, &hashed)?
     }
     Algorithm::RsaPss => {
-      let private_key = RsaPrivateKey::from_pkcs1_der(&*args.key.data)?;
+      let private_key = RsaPrivateKey::from_pkcs1_der(&args.key.data)?;
 
       let salt_len = args
         .salt_length
@@ -262,7 +262,7 @@ pub async fn op_crypto_sign_key(
       {
         CryptoHash::Sha1 => {
           let mut hasher = Sha1::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha1, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -270,7 +270,7 @@ pub async fn op_crypto_sign_key(
         }
         CryptoHash::Sha256 => {
           let mut hasher = Sha256::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha256, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -278,7 +278,7 @@ pub async fn op_crypto_sign_key(
         }
         CryptoHash::Sha384 => {
           let mut hasher = Sha384::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha384, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -286,7 +286,7 @@ pub async fn op_crypto_sign_key(
         }
         CryptoHash::Sha512 => {
           let mut hasher = Sha512::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha512, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -301,7 +301,7 @@ pub async fn op_crypto_sign_key(
       let curve: &EcdsaSigningAlgorithm =
         args.named_curve.ok_or_else(not_supported)?.try_into()?;
 
-      let key_pair = EcdsaKeyPair::from_pkcs8(curve, &*args.key.data)?;
+      let key_pair = EcdsaKeyPair::from_pkcs8(curve, &args.key.data)?;
       // We only support P256-SHA256 & P384-SHA384. These are recommended signature pairs.
       // https://briansmith.org/rustdoc/ring/signature/index.html#statics
       if let Some(hash) = args.hash {
@@ -320,7 +320,7 @@ pub async fn op_crypto_sign_key(
     Algorithm::Hmac => {
       let hash: HmacAlgorithm = args.hash.ok_or_else(not_supported)?.into();
 
-      let key = HmacKey::new(hash, &*args.key.data);
+      let key = HmacKey::new(hash, &args.key.data);
 
       let signature = ring::hmac::sign(&key, data);
       signature.as_ref().to_vec()
@@ -359,7 +359,7 @@ pub async fn op_crypto_verify_key(
       {
         CryptoHash::Sha1 => {
           let mut hasher = Sha1::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA1),
@@ -369,7 +369,7 @@ pub async fn op_crypto_verify_key(
         }
         CryptoHash::Sha256 => {
           let mut hasher = Sha256::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA2_256),
@@ -379,7 +379,7 @@ pub async fn op_crypto_verify_key(
         }
         CryptoHash::Sha384 => {
           let mut hasher = Sha384::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA2_384),
@@ -389,7 +389,7 @@ pub async fn op_crypto_verify_key(
         }
         CryptoHash::Sha512 => {
           let mut hasher = Sha512::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::PKCS1v15Sign {
               hash: Some(rsa::hash::Hash::SHA2_512),
@@ -399,9 +399,7 @@ pub async fn op_crypto_verify_key(
         }
       };
 
-      public_key
+      public_key.verify(padding, &hashed, &args.signature).is_ok()
-        .verify(padding, &hashed, &*args.signature)
-        .is_ok()
     }
     Algorithm::RsaPss => {
       let salt_len = args
@@ -417,7 +415,7 @@ pub async fn op_crypto_verify_key(
       {
         CryptoHash::Sha1 => {
           let mut hasher = Sha1::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha1, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -425,7 +423,7 @@ pub async fn op_crypto_verify_key(
         }
         CryptoHash::Sha256 => {
           let mut hasher = Sha256::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha256, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -433,7 +431,7 @@ pub async fn op_crypto_verify_key(
         }
         CryptoHash::Sha384 => {
           let mut hasher = Sha384::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha384, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -441,7 +439,7 @@ pub async fn op_crypto_verify_key(
         }
         CryptoHash::Sha512 => {
           let mut hasher = Sha512::new();
-          hasher.update(&data);
+          hasher.update(data);
           (
             PaddingScheme::new_pss_with_salt::<Sha512, _>(rng, salt_len),
             hasher.finalize()[..].to_vec(),
@@ -449,14 +447,12 @@ pub async fn op_crypto_verify_key(
         }
       };
 
-      public_key
+      public_key.verify(padding, &hashed, &args.signature).is_ok()
-        .verify(padding, &hashed, &*args.signature)
-        .is_ok()
     }
     Algorithm::Hmac => {
       let hash: HmacAlgorithm = args.hash.ok_or_else(not_supported)?.into();
-      let key = HmacKey::new(hash, &*args.key.data);
+      let key = HmacKey::new(hash, &args.key.data);
-      ring::hmac::verify(&key, data, &*args.signature).is_ok()
+      ring::hmac::verify(&key, data, &args.signature).is_ok()
     }
     Algorithm::Ecdsa => {
       let signing_alg: &EcdsaSigningAlgorithm =
@@ -468,7 +464,7 @@ pub async fn op_crypto_verify_key(
 
       let public_key_bytes = match args.key.r#type {
         KeyType::Private => {
-          private_key = EcdsaKeyPair::from_pkcs8(signing_alg, &*args.key.data)?;
+          private_key = EcdsaKeyPair::from_pkcs8(signing_alg, &args.key.data)?;
 
           private_key.public_key().as_ref()
         }
@@ -479,7 +475,7 @@ pub async fn op_crypto_verify_key(
       let public_key =
         ring::signature::UnparsedPublicKey::new(verify_alg, public_key_bytes);
 
-      public_key.verify(data, &*args.signature).is_ok()
+      public_key.verify(data, &args.signature).is_ok()
     }
     _ => return Err(type_error("Unsupported algorithm".to_string())),
   };
@@ -659,9 +655,9 @@ pub async fn op_crypto_derive_bits(
 fn read_rsa_public_key(key_data: KeyData) -> Result<RsaPublicKey, AnyError> {
   let public_key = match key_data.r#type {
     KeyType::Private => {
-      RsaPrivateKey::from_pkcs1_der(&*key_data.data)?.to_public_key()
+      RsaPrivateKey::from_pkcs1_der(&key_data.data)?.to_public_key()
     }
-    KeyType::Public => RsaPublicKey::from_pkcs1_der(&*key_data.data)?,
+    KeyType::Public => RsaPublicKey::from_pkcs1_der(&key_data.data)?,
     KeyType::Secret => unreachable!("unexpected KeyType::Secret"),
   };
   Ok(public_key)

ext/crypto/shared.rs

@@ -89,7 +89,7 @@ impl RawKeyData {
     match self {
       RawKeyData::Public(data) => {
         // public_key is a serialized EncodedPoint
-        p256::EncodedPoint::from_bytes(&data)
+        p256::EncodedPoint::from_bytes(data)
           .map_err(|_| type_error("expected valid public EC key"))
       }
       RawKeyData::Private(data) => {
@@ -106,7 +106,7 @@ impl RawKeyData {
     match self {
       RawKeyData::Public(data) => {
         // public_key is a serialized EncodedPoint
-        p384::EncodedPoint::from_bytes(&data)
+        p384::EncodedPoint::from_bytes(data)
           .map_err(|_| type_error("expected valid public EC key"))
       }
       RawKeyData::Private(data) => {

ext/net/ops_unix.rs

@@ -198,7 +198,7 @@ where
   let permissions = state.borrow_mut::<NP>();
   permissions.check_read(address_path, "Deno.listen()")?;
   permissions.check_write(address_path, "Deno.listen()")?;
-  let listener = UnixListener::bind(&address_path)?;
+  let listener = UnixListener::bind(address_path)?;
   let local_addr = listener.local_addr()?;
   let pathname = local_addr.as_pathname().map(pathstring).transpose()?;
   let listener_resource = UnixListenerResource {
@@ -220,7 +220,7 @@ where
   let permissions = state.borrow_mut::<NP>();
   permissions.check_read(address_path, "Deno.listenDatagram()")?;
   permissions.check_write(address_path, "Deno.listenDatagram()")?;
-  let socket = UnixDatagram::bind(&address_path)?;
+  let socket = UnixDatagram::bind(address_path)?;
   let local_addr = socket.local_addr()?;
   let pathname = local_addr.as_pathname().map(pathstring).transpose()?;
   let datagram_resource = UnixDatagramResource {

ops/lib.rs

@@ -47,8 +47,6 @@ struct Op {
 
 impl Op {
   fn new(mut item: ItemFn, attrs: Attributes) -> Self {
-    add_scope_lifetime(&mut item);
-
     // Preserve the original function. Change the name to `call`.
     //
     // impl op_foo {
@@ -58,6 +56,8 @@ impl Op {
     let mut orig = item.clone();
     orig.sig.ident = Ident::new("call", Span::call_site());
 
+    add_scope_lifetime(&mut item);
+
     let is_async = item.sig.asyncness.is_some() || is_future(&item.sig.output);
     let type_params = exclude_lifetime_params(&item.sig.generics.params);
     let core = deno::import();

runtime/build.rs

@@ -36,7 +36,7 @@ mod not_docs {
     }
 
     let snapshot = js_runtime.snapshot();
-    let snapshot_slice: &[u8] = &*snapshot;
+    let snapshot_slice: &[u8] = &snapshot;
     println!("Snapshot size: {}", snapshot_slice.len());
 
     let compressed_snapshot_with_size = {
@@ -63,7 +63,7 @@ mod not_docs {
       compressed_snapshot_with_size.len()
     );
 
-    std::fs::write(&snapshot_path, compressed_snapshot_with_size).unwrap();
+    std::fs::write(snapshot_path, compressed_snapshot_with_size).unwrap();
     println!("Snapshot written to: {} ", snapshot_path.display());
   }
 

runtime/errors.rs

@@ -165,7 +165,7 @@ pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
     .or_else(|| e.downcast_ref::<hyper::Error>().map(get_hyper_error_class))
     .or_else(|| {
       e.downcast_ref::<Arc<hyper::Error>>()
-        .map(|e| get_hyper_error_class(&**e))
+        .map(|e| get_hyper_error_class(e))
     })
     .or_else(|| {
       e.downcast_ref::<deno_core::Canceled>().map(|e| {

runtime/fmt_errors.rs

@@ -195,7 +195,7 @@ fn find_recursive_cause(js_error: &JsError) -> Option<ErrorReference> {
     {
       return Some(ErrorReference {
         from: current_error,
-        to: *seen,
+        to: seen,
       });
     } else {
       current_error = cause;

runtime/js.rs

@@ -30,7 +30,7 @@ pub static CLI_SNAPSHOT: Lazy<Box<[u8]>> = Lazy::new(
 
 pub fn deno_isolate_init() -> Snapshot {
   debug!("Deno isolate init with snapshots.");
-  Snapshot::Static(&*CLI_SNAPSHOT)
+  Snapshot::Static(&CLI_SNAPSHOT)
 }
 
 #[cfg(test)]

runtime/ops/fs.rs

@@ -271,7 +271,7 @@ async fn op_write_file_async(
     None => None,
   };
   let (path, open_options) = open_helper(
-    &mut *state.borrow_mut(),
+    &mut state.borrow_mut(),
     &path,
     mode,
     Some(&write_open_options(create, append)),
@@ -646,7 +646,7 @@ fn raw_chmod(path: &Path, _raw_mode: u32) -> Result<(), AnyError> {
   {
     use std::os::unix::fs::PermissionsExt;
     let permissions = PermissionsExt::from_mode(_raw_mode);
-    std::fs::set_permissions(&path, permissions).map_err(err_mapper)?;
+    std::fs::set_permissions(path, permissions).map_err(err_mapper)?;
     Ok(())
   }
   // TODO Implement chmod for Windows (#4357)

runtime/ops/worker_host.rs

@@ -184,7 +184,7 @@ fn op_create_worker(
   state.put::<WorkerId>(worker_id.next().unwrap());
 
   let module_specifier = deno_core::resolve_url(&specifier)?;
-  let worker_name = args_name.unwrap_or_else(|| "".to_string());
+  let worker_name = args_name.unwrap_or_default();
 
   let (handle_sender, handle_receiver) = std::sync::mpsc::sync_channel::<
     Result<SendableWebWorkerHandle, AnyError>,

rust-toolchain.toml

@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.64.0"
+channel = "1.65.0"
 components = ["rustfmt", "clippy"]

serde_v8/de.rs

@@ -434,7 +434,7 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
     V: Visitor<'de>,
   {
     magic::buffer::ZeroCopyBuf::from_v8(self.scope, self.input)
-      .and_then(|zb| visitor.visit_bytes(&*zb))
+      .and_then(|zb| visitor.visit_bytes(&zb))
   }
 
   fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>

test_util/src/lib.rs

@@ -1088,7 +1088,7 @@ async fn download_npm_registry_file(
       .into_bytes()
   };
   std::fs::create_dir_all(file_path.parent().unwrap())?;
-  std::fs::write(&file_path, bytes)?;
+  std::fs::write(file_path, bytes)?;
   Ok(())
 }
 
@@ -1918,7 +1918,7 @@ impl<'a> CheckOutputIntegrationTest<'a> {
       command.env_clear();
     }
     command.envs(self.envs.clone());
-    command.current_dir(&cwd);
+    command.current_dir(cwd);
     command.stdin(Stdio::piped());
     let writer_clone = writer.try_clone().unwrap();
     command.stderr(writer_clone);
@@ -2163,13 +2163,13 @@ pub fn parse_wrk_output(output: &str) -> WrkOutput {
   let mut latency = None;
 
   for line in output.lines() {
-    if requests == None {
+    if requests.is_none() {
       if let Some(cap) = REQUESTS_RX.captures(line) {
         requests =
           Some(str::parse::<u64>(cap.get(1).unwrap().as_str()).unwrap());
       }
     }
-    if latency == None {
+    if latency.is_none() {
       if let Some(cap) = LATENCY_RX.captures(line) {
         let time = cap.get(1).unwrap();
         let unit = cap.get(2).unwrap();