refactor: remove usages of `map_or` / `map_or_else` (#18212)

These methods are confusing because the arguments are backwards. I feel
like they should have never been added to `Option<T>` and that clippy
should suggest rewriting to
`map(...).unwrap_or(...)`/`map(...).unwrap_or_else(|| ...)`

https://github.com/rust-lang/rfcs/issues/1025

16 files changed, 119 insertions, 102 deletions

diff --git a/cli/bench/http.rs b/cli/bench/http.rs
index 06a177386..065d6f657 100644
--- a/cli/bench/http.rs
+++ b/cli/bench/http.rs
@@ -174,7 +174,7 @@ fn run(
 
   println!("{output}");
   assert!(
-    server.try_wait()?.map_or(true, |s| s.success()),
+    server.try_wait()?.map(|s| s.success()).unwrap_or(true),
     "server ended with error"
   );
 
diff --git a/cli/cache/mod.rs b/cli/cache/mod.rs
index a962538b7..ddb419e54 100644
--- a/cli/cache/mod.rs
+++ b/cli/cache/mod.rs
@@ -129,25 +129,23 @@ impl Loader for FetchCacher {
       file_fetcher
         .fetch(&specifier, permissions)
         .await
-        .map_or_else(
-          |err| {
-            if let Some(err) = err.downcast_ref::<std::io::Error>() {
-              if err.kind() == std::io::ErrorKind::NotFound {
-                return Ok(None);
-              }
-            } else if get_error_class_name(&err) == "NotFound" {
+        .map(|file| {
+          Ok(Some(LoadResponse::Module {
+            specifier: file.specifier,
+            maybe_headers: file.maybe_headers,
+            content: file.source,
+          }))
+        })
+        .unwrap_or_else(|err| {
+          if let Some(err) = err.downcast_ref::<std::io::Error>() {
+            if err.kind() == std::io::ErrorKind::NotFound {
               return Ok(None);
             }
-            Err(err)
-          },
-          |file| {
-            Ok(Some(LoadResponse::Module {
-              specifier: file.specifier,
-              maybe_headers: file.maybe_headers,
-              content: file.source,
-            }))
-          },
-        )
+          } else if get_error_class_name(&err) == "NotFound" {
+            return Ok(None);
+          }
+          Err(err)
+        })
     }
     .boxed()
   }
diff --git a/cli/http_util.rs b/cli/http_util.rs
index 9476d6a5f..b01732ca9 100644
--- a/cli/http_util.rs
+++ b/cli/http_util.rs
@@ -202,7 +202,8 @@ impl CacheSemantics {
         && self
           .cache_control
           .max_stale
-          .map_or(true, |val| val > self.age() - self.max_age());
+          .map(|val| val > self.age() - self.max_age())
+          .unwrap_or(true);
       if !allows_stale {
         return false;
       }
diff --git a/cli/lsp/capabilities.rs b/cli/lsp/capabilities.rs
index 029c5c9a9..e56aa6b87 100644
--- a/cli/lsp/capabilities.rs
+++ b/cli/lsp/capabilities.rs
@@ -19,7 +19,7 @@ fn code_action_capabilities(
     .as_ref()
     .and_then(|it| it.code_action.as_ref())
     .and_then(|it| it.code_action_literal_support.as_ref())
-    .map_or(CodeActionProviderCapability::Simple(true), |_| {
+    .map(|_| {
       let mut code_action_kinds =
         vec![CodeActionKind::QUICKFIX, CodeActionKind::REFACTOR];
       code_action_kinds.extend(
@@ -34,6 +34,7 @@ fn code_action_capabilities(
         work_done_progress_options: Default::default(),
       })
     })
+    .unwrap_or(CodeActionProviderCapability::Simple(true))
 }
 
 pub fn server_capabilities(
diff --git a/cli/lsp/documents.rs b/cli/lsp/documents.rs
index 9426378d5..9299c662c 100644
--- a/cli/lsp/documents.rs
+++ b/cli/lsp/documents.rs
@@ -490,7 +490,8 @@ impl Document {
   pub fn script_version(&self) -> String {
     self
       .maybe_lsp_version()
-      .map_or_else(|| self.fs_version().to_string(), |v| v.to_string())
+      .map(|v| v.to_string())
+      .unwrap_or_else(|| self.fs_version().to_string())
   }
 
   pub fn is_diagnosable(&self) -> bool {
@@ -901,15 +902,13 @@ impl Documents {
         let mut file_system_docs = self.file_system_docs.lock();
         file_system_docs.docs.remove(specifier)
       })
-      .map_or_else(
-        || {
-          Err(custom_error(
-            "NotFound",
-            format!("The specifier \"{specifier}\" was not found."),
-          ))
-        },
-        Ok,
-      )?;
+      .map(Ok)
+      .unwrap_or_else(|| {
+        Err(custom_error(
+          "NotFound",
+          format!("The specifier \"{specifier}\" was not found."),
+        ))
+      })?;
     self.dirty = true;
     let doc = doc.with_change(version, changes, self.get_resolver())?;
     self.open_docs.insert(doc.specifier().clone(), doc.clone());
diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs
index fc87001af..8a779d283 100644
--- a/cli/lsp/language_server.rs
+++ b/cli/lsp/language_server.rs
@@ -509,14 +509,14 @@ impl Inner {
     &self,
     specifier: &ModuleSpecifier,
   ) -> LspResult<AssetOrDocument> {
-    self.get_maybe_asset_or_document(specifier).map_or_else(
-      || {
+    self
+      .get_maybe_asset_or_document(specifier)
+      .map(Ok)
+      .unwrap_or_else(|| {
         Err(LspError::invalid_params(format!(
           "Unable to find asset or document for: {specifier}"
         )))
-      },
-      Ok,
-    )
+      })
   }
 
   /// Searches assets and documents for the provided specifier.
@@ -1677,16 +1677,12 @@ impl Inner {
     // Refactor
     let start = line_index.offset_tsc(params.range.start)?;
     let length = line_index.offset_tsc(params.range.end)? - start;
-    let only =
-      params
-        .context
-        .only
-        .as_ref()
-        .map_or(String::default(), |values| {
-          values
-            .first()
-            .map_or(String::default(), |v| v.as_str().to_owned())
-        });
+    let only = params
+      .context
+      .only
+      .as_ref()
+      .and_then(|values| values.first().map(|v| v.as_str().to_owned()))
+      .unwrap_or_default();
     let req = tsc::RequestMethod::GetApplicableRefactors((
       specifier.clone(),
       tsc::TextSpan { start, length },
diff --git a/cli/lsp/path_to_regex.rs b/cli/lsp/path_to_regex.rs
index 1d766e024..dcad6b039 100644
--- a/cli/lsp/path_to_regex.rs
+++ b/cli/lsp/path_to_regex.rs
@@ -452,14 +452,11 @@ pub fn parse(
         path = String::new();
       }
 
-      let name = name.map_or_else(
-        || {
-          let default = StringOrNumber::Number(key);
-          key += 1;
-          default
-        },
-        StringOrNumber::String,
-      );
+      let name = name.map(StringOrNumber::String).unwrap_or_else(|| {
+        let default = StringOrNumber::Number(key);
+        key += 1;
+        default
+      });
       let prefix = if prefix.is_empty() {
         None
       } else {
@@ -498,8 +495,10 @@ pub fn parse(
 
       must_consume(&TokenType::Close, &mut tokens)?;
 
-      let name = maybe_name.clone().map_or_else(
-        || {
+      let name = maybe_name
+        .clone()
+        .map(StringOrNumber::String)
+        .unwrap_or_else(|| {
           if maybe_pattern.is_some() {
             let default = StringOrNumber::Number(key);
             key += 1;
@@ -507,9 +506,7 @@ pub fn parse(
           } else {
             StringOrNumber::String("".to_string())
           }
-        },
-        StringOrNumber::String,
-      );
+        });
       let pattern = if maybe_name.is_some() && maybe_pattern.is_none() {
         default_pattern.clone()
       } else {
@@ -570,11 +567,13 @@ pub fn tokens_to_regex(
         let prefix = key
           .prefix
           .clone()
-          .map_or_else(|| "".to_string(), |s| escape_string(&s));
+          .map(|s| escape_string(&s))
+          .unwrap_or_default();
         let suffix = key
           .suffix
           .clone()
-          .map_or_else(|| "".to_string(), |s| escape_string(&s));
+          .map(|s| escape_string(&s))
+          .unwrap_or_default();
 
         if !key.pattern.is_empty() {
           if !prefix.is_empty() || !suffix.is_empty() {
diff --git a/cli/lsp/registries.rs b/cli/lsp/registries.rs
index fb60c7626..c1fa815e9 100644
--- a/cli/lsp/registries.rs
+++ b/cli/lsp/registries.rs
@@ -295,18 +295,20 @@ fn validate_config(config: &RegistryConfigurationJson) -> Result<(), AnyError> {
   }
   for registry in &config.registries {
     let (_, keys) = string_to_regex(&registry.schema, None)?;
-    let key_names: Vec<String> = keys.map_or_else(Vec::new, |keys| {
-      keys
-        .iter()
-        .filter_map(|k| {
-          if let StringOrNumber::String(s) = &k.name {
-            Some(s.clone())
-          } else {
-            None
-          }
-        })
-        .collect()
-    });
+    let key_names: Vec<String> = keys
+      .map(|keys| {
+        keys
+          .iter()
+          .filter_map(|k| {
+            if let StringOrNumber::String(s) = &k.name {
+              Some(s.clone())
+            } else {
+              None
+            }
+          })
+          .collect()
+      })
+      .unwrap_or_default();
 
     for key_name in &key_names {
       if !registry
@@ -664,18 +666,20 @@ impl ModuleRegistry {
               })
               .ok()?;
             let mut i = tokens.len();
-            let last_key_name =
-              StringOrNumber::String(tokens.iter().last().map_or_else(
-                || "".to_string(),
-                |t| {
+            let last_key_name = StringOrNumber::String(
+              tokens
+                .iter()
+                .last()
+                .map(|t| {
                   if let Token::Key(key) = t {
                     if let StringOrNumber::String(s) = &key.name {
                       return s.clone();
                     }
                   }
                   "".to_string()
-                },
-              ));
+                })
+                .unwrap_or_default(),
+            );
             loop {
               let matcher = Matcher::new(&tokens[..i], None)
                 .map_err(|e| {
diff --git a/cli/lsp/tsc.rs b/cli/lsp/tsc.rs
index 79c1817e2..335d91ed7 100644
--- a/cli/lsp/tsc.rs
+++ b/cli/lsp/tsc.rs
@@ -1024,15 +1024,19 @@ impl NavigationTree {
   ) -> bool {
     let mut should_include = self.should_include_entry();
     if !should_include
-      && self.child_items.as_ref().map_or(true, |v| v.is_empty())
+      && self
+        .child_items
+        .as_ref()
+        .map(|v| v.is_empty())
+        .unwrap_or(true)
     {
       return false;
     }
 
     let children = self
       .child_items
-      .as_ref()
-      .map_or(&[] as &[NavigationTree], |v| v.as_slice());
+      .as_deref()
+      .unwrap_or(&[] as &[NavigationTree]);
     for span in self.spans.iter() {
       let range = TextRange::at(span.start.into(), span.length.into());
       let mut symbol_children = Vec::<lsp::DocumentSymbol>::new();
@@ -1514,7 +1518,8 @@ impl RefactorActionInfo {
         .iter()
         .find(|action| action.matches(&self.name));
       maybe_match
-        .map_or(lsp::CodeActionKind::REFACTOR, |action| action.kind.clone())
+        .map(|action| action.kind.clone())
+        .unwrap_or(lsp::CodeActionKind::REFACTOR)
     }
   }
 
diff --git a/cli/standalone.rs b/cli/standalone.rs
index 6f6085e67..07549cc08 100644
--- a/cli/standalone.rs
+++ b/cli/standalone.rs
@@ -148,13 +148,14 @@ impl ModuleLoader for EmbeddedModuleLoader {
       }
     };
 
-    self.maybe_import_map_resolver.as_ref().map_or_else(
-      || {
+    self
+      .maybe_import_map_resolver
+      .as_ref()
+      .map(|r| r.resolve(specifier, &referrer))
+      .unwrap_or_else(|| {
         deno_core::resolve_import(specifier, referrer.as_str())
           .map_err(|err| err.into())
-      },
-      |r| r.resolve(specifier, &referrer),
-    )
+      })
   }
 
   fn load(
@@ -268,7 +269,10 @@ pub async fn run(
       cpu_count: std::thread::available_parallelism()
         .map(|p| p.get())
         .unwrap_or(1),
-      debug_flag: metadata.log_level.map_or(false, |l| l == Level::Debug),
+      debug_flag: metadata
+        .log_level
+        .map(|l| l == Level::Debug)
+        .unwrap_or(false),
       enable_testing_features: false,
       locale: deno_core::v8::icu::get_language_tag(),
       location: metadata.location,
diff --git a/cli/tools/coverage/merge.rs b/cli/tools/coverage/merge.rs
index 29d26da3c..21ef29de9 100644
--- a/cli/tools/coverage/merge.rs
+++ b/cli/tools/coverage/merge.rs
@@ -356,7 +356,11 @@ fn merge_range_tree_children<'a>(
     let mut matching_trees: Vec<&'a mut RangeTree<'a>> = Vec::new();
     for (_parent_index, children) in child_forests.iter_mut().enumerate() {
       let next_tree: Option<&'a mut RangeTree<'a>> = {
-        if children.peek().map_or(false, |tree| tree.start == *event) {
+        if children
+          .peek()
+          .map(|tree| tree.start == *event)
+          .unwrap_or(false)
+        {
           children.next()
         } else {
           None
diff --git a/cli/tools/coverage/mod.rs b/cli/tools/coverage/mod.rs
index 05ad853f8..eaa087171 100644
--- a/cli/tools/coverage/mod.rs
+++ b/cli/tools/coverage/mod.rs
@@ -562,7 +562,10 @@ fn collect_coverages(
 ) -> Result<Vec<ScriptCoverage>, AnyError> {
   let mut coverages: Vec<ScriptCoverage> = Vec::new();
   let file_paths = FileCollector::new(|file_path| {
-    file_path.extension().map_or(false, |ext| ext == "json")
+    file_path
+      .extension()
+      .map(|ext| ext == "json")
+      .unwrap_or(false)
   })
   .ignore_git_folder()
   .ignore_node_modules()
diff --git a/cli/tools/repl/editor.rs b/cli/tools/repl/editor.rs
index c9f019305..bf38573f4 100644
--- a/cli/tools/repl/editor.rs
+++ b/cli/tools/repl/editor.rs
@@ -167,12 +167,11 @@ fn is_word_boundary(c: char) -> bool {
 }
 
 fn get_expr_from_line_at_pos(line: &str, cursor_pos: usize) -> &str {
-  let start = line[..cursor_pos]
-    .rfind(is_word_boundary)
-    .map_or_else(|| 0, |i| i);
+  let start = line[..cursor_pos].rfind(is_word_boundary).unwrap_or(0);
   let end = line[cursor_pos..]
     .rfind(is_word_boundary)
-    .map_or_else(|| cursor_pos, |i| cursor_pos + i);
+    .map(|i| cursor_pos + i)
+    .unwrap_or(cursor_pos);
 
   let word = &line[start..end];
   let word = word.strip_prefix(is_word_boundary).unwrap_or(word);
diff --git a/cli/util/fs.rs b/cli/util/fs.rs
index 4ac57eac0..8167fd2e5 100644
--- a/cli/util/fs.rs
+++ b/cli/util/fs.rs
@@ -732,7 +732,8 @@ mod tests {
       path
         .file_name()
         .and_then(|f| f.to_str())
-        .map_or(false, |f| !f.starts_with('.'))
+        .map(|f| !f.starts_with('.'))
+        .unwrap_or(false)
     })
     .add_ignore_paths(&[ignore_dir_path]);
 
@@ -847,7 +848,8 @@ mod tests {
       path
         .file_name()
         .and_then(|f| f.to_str())
-        .map_or(false, |f| !f.starts_with('.'))
+        .map(|f| !f.starts_with('.'))
+        .unwrap_or(false)
     };
 
     let result = collect_specifiers(
diff --git a/cli/version.rs b/cli/version.rs
index c4696620e..88dc9ffc7 100644
--- a/cli/version.rs
+++ b/cli/version.rs
@@ -4,10 +4,10 @@ pub const GIT_COMMIT_HASH: &str = env!("GIT_COMMIT_HASH");
 pub const TYPESCRIPT: &str = env!("TS_VERSION");
 
 pub fn deno() -> String {
-  let semver = env!("CARGO_PKG_VERSION");
-  option_env!("DENO_CANARY").map_or(semver.to_string(), |_| {
-    format!("{}+{}", semver, &GIT_COMMIT_HASH[..7])
-  })
+  let version = env!("CARGO_PKG_VERSION");
+  option_env!("DENO_CANARY")
+    .map(|_| format!("{}+{}", version, &GIT_COMMIT_HASH[..7]))
+    .unwrap_or_else(|| version.to_string())
 }
 
 pub fn is_canary() -> bool {
diff --git a/cli/worker.rs b/cli/worker.rs
index 3643a4316..b9e1fab8e 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -510,7 +510,8 @@ async fn create_main_worker_internal(
       debug_flag: ps
         .options
         .log_level()
-        .map_or(false, |l| l == log::Level::Debug),
+        .map(|l| l == log::Level::Debug)
+        .unwrap_or(false),
       enable_testing_features: ps.options.enable_testing_features(),
       locale: deno_core::v8::icu::get_language_tag(),
       location: ps.options.location_flag().clone(),
@@ -677,7 +678,8 @@ fn create_web_worker_callback(
         debug_flag: ps
           .options
           .log_level()
-          .map_or(false, |l| l == log::Level::Debug),
+          .map(|l| l == log::Level::Debug)
+          .unwrap_or(false),
         enable_testing_features: ps.options.enable_testing_features(),
         locale: deno_core::v8::icu::get_language_tag(),
         location: Some(args.main_module.clone()),