simplify slightly

diff --git a/src/cargo/ops/cargo_clean.rs b/src/cargo/ops/cargo_clean.rs
index 6c50a90dc6b3a68a97deecb6265adb9ed4edaca8..c5a32e1d6349c6832367615bbf6658dc740b1f3d 100644 (file)
--- a/src/cargo/ops/cargo_clean.rs
+++ b/src/cargo/ops/cargo_clean.rs
@@ -29,7 +29,7 @@ pub fn clean(ws: &Workspace, opts: &CleanOptions) -> CargoResult<()> {
     }
 
     let mut registry = try!(PackageRegistry::new(opts.config));
-    let resolve = try!(ops::resolve_ws(&mut registry, ws, opts.config));
+    let resolve = try!(ops::resolve_ws(&mut registry, ws));
     let packages = ops::get_resolved_packages(&resolve, registry);
 
     let profiles = try!(ws.current()).manifest().profiles();

diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs
index c8b50cd93b930b5f965a570233cd0ccb7df3ff8a..44ea51afdd572fb118dcaf68f403c92444f8194c 100644 (file)
--- a/src/cargo/ops/cargo_compile.rs
+++ b/src/cargo/ops/cargo_compile.rs
@@ -118,7 +118,7 @@ pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
 
     // First, resolve the root_package's *listed* dependencies, as well as
     // downloading and updating all remotes and such.
-    let resolve = try!(ops::resolve_ws(&mut registry, ws, ws.config()));
+    let resolve = try!(ops::resolve_ws(&mut registry, ws));
 
     // Second, resolve with precisely what we're doing. Filter out
     // transitive dependencies if necessary, specify features, handle
@@ -143,7 +143,7 @@ pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
     let resolved_with_overrides =
             try!(ops::resolve_with_previous(&mut registry, ws,
                                             method, Some(&resolve), None,
-                                            &specs, ws.config()));
+                                            &specs));
 
     let packages = ops::get_resolved_packages(&resolved_with_overrides,
                                               registry);

diff --git a/src/cargo/ops/cargo_fetch.rs b/src/cargo/ops/cargo_fetch.rs
index 77634b9c83fbe29ffd5aeaf4b11f3a2d18dd41df..43cd5c109a98dd9fd3d5b6953abbdd83d7a679f7 100644 (file)
--- a/src/cargo/ops/cargo_fetch.rs
+++ b/src/cargo/ops/cargo_fetch.rs
@@ -6,7 +6,7 @@ use util::CargoResult;
 /// Executes `cargo fetch`.
 pub fn fetch<'a>(ws: &Workspace<'a>) -> CargoResult<(Resolve, PackageSet<'a>)> {
     let mut registry = try!(PackageRegistry::new(ws.config()));
-    let resolve = try!(ops::resolve_ws(&mut registry, ws, ws.config()));
+    let resolve = try!(ops::resolve_ws(&mut registry, ws));
     let packages = get_resolved_packages(&resolve, registry);
     for id in resolve.iter() {
         try!(packages.get(id, ws.config()));

diff --git a/src/cargo/ops/cargo_generate_lockfile.rs b/src/cargo/ops/cargo_generate_lockfile.rs
index 7758cc63c4d25aa1f4faf7ae8380a2f8b1eae24d..25e2204ba9e12dcc94dfff963b17188a23ea6e55 100644 (file)
--- a/src/cargo/ops/cargo_generate_lockfile.rs
+++ b/src/cargo/ops/cargo_generate_lockfile.rs
@@ -19,7 +19,7 @@ pub fn generate_lockfile(ws: &Workspace) -> CargoResult<()> {
     let mut registry = try!(PackageRegistry::new(ws.config()));
     let resolve = try!(ops::resolve_with_previous(&mut registry, ws,
                                                   Method::Everything,
-                                                  None, None, &[], ws.config()));
+                                                  None, None, &[]));
     try!(ops::write_pkg_lockfile(ws, &resolve));
     Ok(())
 }
@@ -79,8 +79,7 @@ pub fn update_lockfile(ws: &Workspace, opts: &UpdateOptions)
                                                   Method::Everything,
                                                   Some(&previous_resolve),
                                                   Some(&to_avoid),
-                                                  &[],
-                                                  ws.config()));
+                                                  &[]));
 
     // Summarize what is changing for the user.
     let print_change = |status: &str, msg: String| {

diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs
index 5f4c1617accd6045fb0e0c476b2f71b6bd5862f5..6b114dd61ccea05811aa73d8183e690b78acee97 100644 (file)
--- a/src/cargo/ops/resolve.rs
+++ b/src/cargo/ops/resolve.rs
@@ -4,19 +4,19 @@ use core::{PackageId, PackageIdSpec, SourceId, Workspace};
 use core::registry::PackageRegistry;
 use core::resolver::{self, Resolve, Method};
 use ops;
-use util::{CargoResult, Config};
+use util::CargoResult;
 
 /// Resolve all dependencies for the specified `package` using the previous
 /// lockfile as a guide if present.
 ///
 /// This function will also write the result of resolution as a new
 /// lockfile.
-pub fn resolve_ws(registry: &mut PackageRegistry, ws: &Workspace, config: &Config)
+pub fn resolve_ws(registry: &mut PackageRegistry, ws: &Workspace)
                    -> CargoResult<Resolve> {
     let prev = try!(ops::load_pkg_lockfile(ws));
     let resolve = try!(resolve_with_previous(registry, ws,
                                              Method::Everything,
-                                             prev.as_ref(), None, &[], config));
+                                             prev.as_ref(), None, &[]));
 
     // Avoid writing a lockfile if we are `cargo install`ing a non local package.
     if ws.current_opt().map(|pkg| pkg.package_id().source_id().is_path()).unwrap_or(true) {
@@ -39,8 +39,7 @@ pub fn resolve_with_previous<'a>(registry: &mut PackageRegistry,
                                  method: Method,
                                  previous: Option<&'a Resolve>,
                                  to_avoid: Option<&HashSet<&'a PackageId>>,
-                                 specs: &[PackageIdSpec],
-                                 config: &Config)
+                                 specs: &[PackageIdSpec])
                                  -> CargoResult<Resolve> {
     // Here we place an artificial limitation that all non-registry sources
     // cannot be locked at more than one revision. This means that if a git
@@ -128,7 +127,7 @@ pub fn resolve_with_previous<'a>(registry: &mut PackageRegistry,
         None => root_replace.to_vec(),
     };
 
-    let mut resolved = try!(resolver::resolve(&summaries, &replace, registry, config));
+    let mut resolved = try!(resolver::resolve(&summaries, &replace, registry, ws.config()));
     if let Some(previous) = previous {
         try!(resolved.merge_from(previous));
     }