fix clippy::unnecessary_wraps.

Make functions that return Options but only ever return Ok() return the wrapped value directly and remove redundant matching

Author: matthiaskrgr

src/cargo/core/compiler/custom_build.rs

@@ -750,7 +750,7 @@ pub fn build_map(cx: &mut Context<'_, '_>) -> CargoResult<()> {
 
         // Load any dependency declarations from a previous run.
         if unit.mode.is_run_custom_build() {
-            parse_previous_explicit_deps(cx, unit)?;
+            parse_previous_explicit_deps(cx, unit);
         }
 
         // We want to invoke the compiler deterministically to be cache-friendly
@@ -787,13 +787,12 @@ pub fn build_map(cx: &mut Context<'_, '_>) -> CargoResult<()> {
         }
     }
 
-    fn parse_previous_explicit_deps(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<()> {
+    fn parse_previous_explicit_deps(cx: &mut Context<'_, '_>, unit: &Unit) {
         let script_run_dir = cx.files().build_script_run_dir(unit);
         let output_file = script_run_dir.join("output");
         let (prev_output, _) = prev_build_output(cx, unit);
         let deps = BuildDeps::new(&output_file, prev_output.as_ref());
         cx.build_explicit_deps.insert(unit.clone(), deps);
-        Ok(())
     }
 }
 

src/cargo/core/compiler/mod.rs

@@ -24,7 +24,7 @@ use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fs::{self, File};
 use std::io::{BufRead, Write};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use anyhow::Error;
@@ -276,7 +276,7 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
                 )?;
                 add_plugin_deps(&mut rustc, &script_outputs, &build_scripts, &root_output)?;
             }
-            add_custom_env(&mut rustc, &script_outputs, current_id, script_metadata)?;
+            add_custom_env(&mut rustc, &script_outputs, current_id, script_metadata);
         }
 
         for output in outputs.iter() {
@@ -396,17 +396,18 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
         build_script_outputs: &BuildScriptOutputs,
         current_id: PackageId,
         metadata: Option<Metadata>,
-    ) -> CargoResult<()> {
+    ) {
         let metadata = match metadata {
             Some(metadata) => metadata,
-            None => return Ok(()),
+            None => {
+                return;
+            }
         };
         if let Some(output) = build_script_outputs.get(current_id, metadata) {
             for &(ref name, ref value) in output.env.iter() {
                 rustc.env(name, value);
             }
         }
-        Ok(())
     }
 }
 
@@ -603,7 +604,7 @@ fn rustdoc(cx: &mut Context<'_, '_>, unit: &Unit) -> CargoResult<Work> {
         rustdoc.arg("--cfg").arg(&format!("feature=\"{}\"", feat));
     }
 
-    add_error_format_and_color(cx, &mut rustdoc, false)?;
+    add_error_format_and_color(cx, &mut rustdoc, false);
 
     if let Some(args) = cx.bcx.extra_args_for(unit) {
         rustdoc.args(args);
@@ -725,11 +726,7 @@ fn add_cap_lints(bcx: &BuildContext<'_, '_>, unit: &Unit, cmd: &mut ProcessBuild
 /// intercepting messages like rmeta artifacts, etc. rustc includes a
 /// "rendered" field in the JSON message with the message properly formatted,
 /// which Cargo will extract and display to the user.
-fn add_error_format_and_color(
-    cx: &Context<'_, '_>,
-    cmd: &mut ProcessBuilder,
-    pipelined: bool,
-) -> CargoResult<()> {
+fn add_error_format_and_color(cx: &Context<'_, '_>, cmd: &mut ProcessBuilder, pipelined: bool) {
     cmd.arg("--error-format=json");
     let mut json = String::from("--json=diagnostic-rendered-ansi");
     if pipelined {
@@ -764,8 +761,6 @@ fn add_error_format_and_color(
             _ => (),
         }
     }
-
-    Ok(())
 }
 
 fn build_base_args(
@@ -799,7 +794,7 @@ fn build_base_args(
     }
 
     add_path_args(bcx, unit, cmd);
-    add_error_format_and_color(cx, cmd, cx.rmeta_required(unit))?;
+    add_error_format_and_color(cx, cmd, cx.rmeta_required(unit));
 
     if !test {
         for crate_type in crate_types.iter() {

src/cargo/core/profiles.rs

@@ -100,7 +100,7 @@ impl Profiles {
             requested_profile,
         };
 
-        Self::add_root_profiles(&mut profile_makers, &profiles)?;
+        Self::add_root_profiles(&mut profile_makers, &profiles);
 
         // Merge with predefined profiles.
         use std::collections::btree_map::Entry;
@@ -143,7 +143,7 @@ impl Profiles {
     fn add_root_profiles(
         profile_makers: &mut Profiles,
         profiles: &BTreeMap<InternedString, TomlProfile>,
-    ) -> CargoResult<()> {
+    )  {
         profile_makers.by_name.insert(
             InternedString::new("dev"),
             ProfileMaker::new(Profile::default_dev(), profiles.get("dev").cloned()),
@@ -153,7 +153,6 @@ impl Profiles {
             InternedString::new("release"),
             ProfileMaker::new(Profile::default_release(), profiles.get("release").cloned()),
         );
-        Ok(())
     }
 
     /// Returns the built-in profiles (not including dev/release, which are

src/cargo/core/workspace.rs

@@ -437,14 +437,14 @@ impl<'cfg> Workspace<'cfg> {
     /// Returns an error if `manifest_path` isn't actually a valid manifest or
     /// if some other transient error happens.
     fn find_root(&mut self, manifest_path: &Path) -> CargoResult<Option<PathBuf>> {
-        fn read_root_pointer(member_manifest: &Path, root_link: &str) -> CargoResult<PathBuf> {
+        fn read_root_pointer(member_manifest: &Path, root_link: &str) -> PathBuf {
             let path = member_manifest
                 .parent()
                 .unwrap()
                 .join(root_link)
                 .join("Cargo.toml");
             debug!("find_root - pointer {}", path.display());
-            Ok(paths::normalize_path(&path))
+            paths::normalize_path(&path)
         }
 
         {
@@ -456,7 +456,7 @@ impl<'cfg> Workspace<'cfg> {
                 }
                 WorkspaceConfig::Member {
                     root: Some(ref path_to_root),
-                } => return Ok(Some(read_root_pointer(manifest_path, path_to_root)?)),
+                } => return Ok(Some(read_root_pointer(manifest_path, path_to_root))),
                 WorkspaceConfig::Member { root: None } => {}
             }
         }
@@ -481,7 +481,7 @@ impl<'cfg> Workspace<'cfg> {
                         root: Some(ref path_to_root),
                     } => {
                         debug!("find_root - found pointer");
-                        return Ok(Some(read_root_pointer(&ances_manifest_path, path_to_root)?));
+                        return Ok(Some(read_root_pointer(&ances_manifest_path, path_to_root)));
                     }
                     WorkspaceConfig::Member { .. } => {}
                 }
@@ -957,7 +957,7 @@ impl<'cfg> Workspace<'cfg> {
         if self.allows_new_cli_feature_behavior() {
             self.members_with_features_new(specs, requested_features)
         } else {
-            self.members_with_features_old(specs, requested_features)
+            Ok(self.members_with_features_old(specs, requested_features))
         }
     }
 
@@ -1067,7 +1067,7 @@ impl<'cfg> Workspace<'cfg> {
         &self,
         specs: &[PackageIdSpec],
         requested_features: &RequestedFeatures,
-    ) -> CargoResult<Vec<(&Package, RequestedFeatures)>> {
+    ) -> Vec<(&Package, RequestedFeatures)> {
         // Split off any features with the syntax `member-name/feature-name` into a map
         // so that those features can be applied directly to those workspace-members.
         let mut member_specific_features: HashMap<&str, BTreeSet<InternedString>> = HashMap::new();
@@ -1131,7 +1131,7 @@ impl<'cfg> Workspace<'cfg> {
                 }
             }
         });
-        Ok(ms.collect())
+        ms.collect()
     }
 }
 

src/cargo/ops/common_for_install_and_uninstall.rs

@@ -120,7 +120,7 @@ impl InstallTracker {
                 serde_json::from_str(&contents)
                     .chain_err(|| format_err!("invalid JSON found for metadata"))?
             };
-            v2.sync_v1(&v1)?;
+            v2.sync_v1(&v1);
             Ok(v2)
         })()
         .chain_err(|| {
@@ -367,7 +367,7 @@ impl CrateListingV2 {
     /// where v2 is in use, and a v1 update is made, then v2 is used again.
     /// i.e., `cargo +new install foo ; cargo +old install bar ; cargo +new install bar`
     /// For now, v1 is the source of truth, so its values are trusted over v2.
-    fn sync_v1(&mut self, v1: &CrateListingV1) -> CargoResult<()> {
+    fn sync_v1(&mut self, v1: &CrateListingV1) {
         // Make the `bins` entries the same.
         for (pkg_id, bins) in &v1.v1 {
             self.installs
@@ -385,7 +385,6 @@ impl CrateListingV2 {
         for pkg_id in to_remove {
             self.installs.remove(&pkg_id);
         }
-        Ok(())
     }
 
     fn package_for_bin(&self, bin_name: &str) -> Option<PackageId> {

src/cargo/ops/lockfile.rs

@@ -28,12 +28,12 @@ pub fn load_pkg_lockfile(ws: &Workspace<'_>) -> CargoResult<Option<Resolve>> {
 
 /// Generate a toml String of Cargo.lock from a Resolve.
 pub fn resolve_to_string(ws: &Workspace<'_>, resolve: &mut Resolve) -> CargoResult<String> {
-    let (_orig, out, _ws_root) = resolve_to_string_orig(ws, resolve)?;
+    let (_orig, out, _ws_root) = resolve_to_string_orig(ws, resolve);
     Ok(out)
 }
 
 pub fn write_pkg_lockfile(ws: &Workspace<'_>, resolve: &mut Resolve) -> CargoResult<()> {
-    let (orig, mut out, ws_root) = resolve_to_string_orig(ws, resolve)?;
+    let (orig, mut out, ws_root) = resolve_to_string_orig(ws, resolve);
 
     // If the lock file contents haven't changed so don't rewrite it. This is
     // helpful on read-only filesystems.
@@ -87,7 +87,7 @@ pub fn write_pkg_lockfile(ws: &Workspace<'_>, resolve: &mut Resolve) -> CargoRes
 fn resolve_to_string_orig(
     ws: &Workspace<'_>,
     resolve: &mut Resolve,
-) -> CargoResult<(Option<String>, String, Filesystem)> {
+) -> (Option<String>, String, Filesystem) {
     // Load the original lock file if it exists.
     let ws_root = Filesystem::new(ws.root().to_path_buf());
     let orig = ws_root.open_ro("Cargo.lock", ws.config(), "Cargo.lock file");
@@ -97,7 +97,7 @@ fn resolve_to_string_orig(
         Ok(s)
     });
     let out = serialize_resolve(resolve, orig.as_ref().ok().map(|s| &**s));
-    Ok((orig.ok(), out, ws_root))
+    (orig.ok(), out, ws_root)
 }
 
 fn serialize_resolve(resolve: &Resolve, orig: Option<&str>) -> String {