Revert addition of a number of Config params

Author: alexcrichton

src/cargo/core/package.rs

@@ -156,7 +156,7 @@ impl<'cfg> PackageSet<'cfg> {
         Box::new(self.packages.iter().map(|&(ref p, _)| p))
     }
 
-    pub fn get(&self, id: &PackageId, config: &Config) -> CargoResult<&Package> {
+    pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
         let slot = try!(self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
             internal(format!("couldn't find `{}` in package set", id))
         }));
@@ -168,7 +168,7 @@ impl<'cfg> PackageSet<'cfg> {
         let source = try!(sources.get_mut(id.source_id()).chain_error(|| {
             internal(format!("couldn't find source for `{}`", id))
         }));
-        let pkg = try!(source.download(id, config).chain_error(|| {
+        let pkg = try!(source.download(id).chain_error(|| {
             human("unable to get packages from source")
         }));
         assert!(slot.fill(pkg).is_ok());

src/cargo/core/registry.rs

@@ -10,7 +10,7 @@ use sources::config::SourceConfigMap;
 /// See also `core::Source`.
 pub trait Registry {
     /// Attempt to find the packages that match a dependency request.
-    fn query(&mut self, name: &Dependency, config: &Config) -> CargoResult<Vec<Summary>>;
+    fn query(&mut self, name: &Dependency) -> CargoResult<Vec<Summary>>;
 
     /// Returns whether or not this registry will return summaries with
     /// checksums listed.
@@ -22,22 +22,22 @@ pub trait Registry {
 }
 
 impl Registry for Vec<Summary> {
-    fn query(&mut self, dep: &Dependency, _config: &Config) -> CargoResult<Vec<Summary>> {
+    fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
         Ok(self.iter().filter(|summary| dep.matches(*summary))
                .cloned().collect())
     }
 }
 
 impl Registry for Vec<Package> {
-    fn query(&mut self, dep: &Dependency, _config: &Config) -> CargoResult<Vec<Summary>> {
+    fn query(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
         Ok(self.iter().filter(|pkg| dep.matches(pkg.summary()))
                .map(|pkg| pkg.summary().clone()).collect())
     }
 }
 
 impl<'a, T: ?Sized + Registry + 'a> Registry for Box<T> {
-    fn query(&mut self, name: &Dependency, config: &Config) -> CargoResult<Vec<Summary>> {
-        (**self).query(name, config)
+    fn query(&mut self, name: &Dependency) -> CargoResult<Vec<Summary>> {
+        (**self).query(name)
     }
 }
 

src/cargo/core/resolver/mod.rs

@@ -55,7 +55,7 @@ use semver;
 
 use core::{PackageId, Registry, SourceId, Summary, Dependency};
 use core::PackageIdSpec;
-use util::{CargoResult, Graph, human, CargoError, Config};
+use util::{CargoResult, Graph, human, CargoError};
 use util::profile;
 use util::ChainError;
 use util::graph::{Nodes, Edges};
@@ -265,8 +265,7 @@ struct Context<'a> {
 /// Builds the list of all packages required to build the first argument.
 pub fn resolve(summaries: &[(Summary, Method)],
                replacements: &[(PackageIdSpec, Dependency)],
-               registry: &mut Registry,
-               config: &Config) -> CargoResult<Resolve> {
+               registry: &mut Registry) -> CargoResult<Resolve> {
     let cx = Context {
         resolve_graph: Graph::new(),
         resolve_features: HashMap::new(),
@@ -275,7 +274,7 @@ pub fn resolve(summaries: &[(Summary, Method)],
         replacements: replacements,
     };
     let _p = profile::start(format!("resolving"));
-    let cx = try!(activate_deps_loop(cx, registry, summaries, config));
+    let cx = try!(activate_deps_loop(cx, registry, summaries));
 
     let mut resolve = Resolve {
         graph: cx.resolve_graph,
@@ -306,8 +305,7 @@ fn activate(cx: &mut Context,
             registry: &mut Registry,
             parent: Option<&Rc<Summary>>,
             candidate: Candidate,
-            method: &Method,
-            config: &Config)
+            method: &Method)
             -> CargoResult<Option<DepsFrame>> {
     if let Some(parent) = parent {
         cx.resolve_graph.link(parent.package_id().clone(),
@@ -335,7 +333,7 @@ fn activate(cx: &mut Context,
         }
     };
 
-    let deps = try!(cx.build_deps(registry, &candidate, method, config));
+    let deps = try!(cx.build_deps(registry, &candidate, method));
 
     Ok(Some(DepsFrame {
         parent: candidate,
@@ -437,8 +435,7 @@ struct BacktrackFrame<'a> {
 /// dependency graph, cx.resolve is returned.
 fn activate_deps_loop<'a>(mut cx: Context<'a>,
                           registry: &mut Registry,
-                          summaries: &[(Summary, Method)],
-                          config: &Config)
+                          summaries: &[(Summary, Method)])
                           -> CargoResult<Context<'a>> {
     // Note that a `BinaryHeap` is used for the remaining dependencies that need
     // activation. This heap is sorted such that the "largest value" is the most
@@ -454,7 +451,7 @@ fn activate_deps_loop<'a>(mut cx: Context<'a>,
         let summary = Rc::new(summary.clone());
         let candidate = Candidate { summary: summary, replace: None };
         remaining_deps.extend(try!(activate(&mut cx, registry, None, candidate,
-                                            method, config)));
+                                            method)));
     }
 
     // Main resolution loop, this is the workhorse of the resolution algorithm.
@@ -548,8 +545,7 @@ fn activate_deps_loop<'a>(mut cx: Context<'a>,
                     None => return Err(activation_error(&cx, registry, &parent,
                                                         &dep,
                                                         &cx.prev_active(&dep),
-                                                        &candidates,
-                                                        config)),
+                                                        &candidates)),
                     Some(candidate) => candidate,
                 }
             }
@@ -563,7 +559,7 @@ fn activate_deps_loop<'a>(mut cx: Context<'a>,
         trace!("{}[{}]>{} trying {}", parent.name(), cur, dep.name(),
                candidate.summary.version());
         remaining_deps.extend(try!(activate(&mut cx, registry, Some(&parent),
-                                            candidate, &method, config)));
+                                            candidate, &method)));
     }
 
     Ok(cx)
@@ -599,8 +595,7 @@ fn activation_error(cx: &Context,
                     parent: &Summary,
                     dep: &Dependency,
                     prev_active: &[Rc<Summary>],
-                    candidates: &[Candidate],
-                    config: &Config) -> Box<CargoError> {
+                    candidates: &[Candidate]) -> Box<CargoError> {
     if candidates.len() > 0 {
         let mut msg = format!("failed to select a version for `{}` \
                                (required by `{}`):\n\
@@ -653,7 +648,7 @@ fn activation_error(cx: &Context,
     let mut msg = msg;
     let all_req = semver::VersionReq::parse("*").unwrap();
     let new_dep = dep.clone_inner().set_version_req(all_req).into_dependency();
-    let mut candidates = match registry.query(&new_dep, config) {
+    let mut candidates = match registry.query(&new_dep) {
         Ok(candidates) => candidates,
         Err(e) => return e,
     };
@@ -821,8 +816,7 @@ impl<'a> Context<'a> {
     fn build_deps(&mut self,
                   registry: &mut Registry,
                   candidate: &Summary,
-                  method: &Method,
-                  config: &Config) -> CargoResult<Vec<DepInfo>> {
+                  method: &Method) -> CargoResult<Vec<DepInfo>> {
         // First, figure out our set of dependencies based on the requsted set
         // of features. This also calculates what features we're going to enable
         // for our own dependencies.
@@ -831,7 +825,7 @@ impl<'a> Context<'a> {
         // Next, transform all dependencies into a list of possible candidates
         // which can satisfy that dependency.
         let mut deps = try!(deps.into_iter().map(|(dep, features)| {
-            let mut candidates = try!(self.query(registry, &dep, config));
+            let mut candidates = try!(self.query(registry, &dep));
             // When we attempt versions for a package, we'll want to start at
             // the maximum version and work our way down.
             candidates.sort_by(|a, b| {
@@ -857,9 +851,8 @@ impl<'a> Context<'a> {
     /// return.
     fn query(&self,
              registry: &mut Registry,
-             dep: &Dependency,
-             config: &Config) -> CargoResult<Vec<Candidate>> {
-        let summaries = try!(registry.query(dep, config));
+             dep: &Dependency) -> CargoResult<Vec<Candidate>> {
+        let summaries = try!(registry.query(dep));
         summaries.into_iter().map(Rc::new).map(|summary| {
             // get around lack of non-lexical lifetimes
             let summary2 = summary.clone();
@@ -872,7 +865,7 @@ impl<'a> Context<'a> {
                 Some(replacement) => replacement,
             };
 
-            let mut summaries = try!(registry.query(dep, config)).into_iter();
+            let mut summaries = try!(registry.query(dep)).into_iter();
             let s = try!(summaries.next().chain_error(|| {
                 human(format!("no matching package for override `{}` found\n\
                                location searched: {}\n\

src/cargo/core/source.rs

@@ -27,7 +27,7 @@ pub trait Source: Registry {
 
     /// The download method fetches the full package for each name and
     /// version specified.
-    fn download(&mut self, package: &PackageId, config: &Config) -> CargoResult<Package>;
+    fn download(&mut self, package: &PackageId) -> CargoResult<Package>;
 
     /// Generates a unique string which represents the fingerprint of the
     /// current state of the source.
@@ -57,8 +57,8 @@ impl<'a, T: Source + ?Sized + 'a> Source for Box<T> {
         (**self).update()
     }
 
-    fn download(&mut self, id: &PackageId, config: &Config) -> CargoResult<Package> {
-        (**self).download(id, config)
+    fn download(&mut self, id: &PackageId) -> CargoResult<Package> {
+        (**self).download(id)
     }
 
     fn fingerprint(&self, pkg: &Package) -> CargoResult<String> {

src/cargo/ops/cargo_clean.rs

@@ -47,7 +47,7 @@ pub fn clean(ws: &Workspace, opts: &CleanOptions) -> CargoResult<()> {
     for spec in opts.spec {
         // Translate the spec to a Package
         let pkgid = try!(resolve.query(spec));
-        let pkg = try!(packages.get(&pkgid, ws.config()));
+        let pkg = try!(packages.get(&pkgid));
 
         // Generate all relevant `Unit` targets for this package
         for target in pkg.targets() {

src/cargo/ops/cargo_compile.rs

@@ -190,7 +190,7 @@ pub fn compile_ws<'a>(ws: &Workspace<'a>,
     };
 
     let to_builds = try!(pkgids.iter().map(|id| {
-        packages.get(id, config)
+        packages.get(id)
     }).collect::<CargoResult<Vec<_>>>());
 
     let mut general_targets = Vec::new();

src/cargo/ops/cargo_fetch.rs

@@ -9,7 +9,7 @@ pub fn fetch<'a>(ws: &Workspace<'a>) -> CargoResult<(Resolve, PackageSet<'a>)> {
     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()));
+        try!(packages.get(id));
     }
     Ok((resolve, packages))
 }

src/cargo/ops/cargo_install.rs

@@ -260,10 +260,10 @@ fn select_pkg<'a, T>(mut source: T,
     match name {
         Some(name) => {
             let dep = try!(Dependency::parse(name, vers, source_id, config));
-            let deps = try!(source.query(&dep, config));
+            let deps = try!(source.query(&dep));
             match deps.iter().map(|p| p.package_id()).max() {
                 Some(pkgid) => {
-                    let pkg = try!(source.download(pkgid, config));
+                    let pkg = try!(source.download(pkgid));
                     Ok((pkg, Box::new(source)))
                 }
                 None => {

src/cargo/ops/cargo_output_metadata.rs

@@ -52,7 +52,7 @@ fn metadata_full(ws: &Workspace,
     let (packages, resolve) = deps;
 
     let packages = try!(packages.package_ids()
-                                .map(|i| packages.get(i, ws.config()).map(|p| p.clone()))
+                                .map(|i| packages.get(i).map(|p| p.clone()))
                                 .collect());
 
     Ok(ExportInfo {

src/cargo/ops/cargo_rustc/context.rs

@@ -156,7 +156,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
                 }
             }));
         }
-        for dep in try!(self.dep_targets(&unit, self.config)) {
+        for dep in try!(self.dep_targets(&unit)) {
             try!(self.visit_crate_type(&dep, crate_types));
         }
         Ok(())
@@ -251,29 +251,26 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
         for unit in units {
             try!(self.walk_used_in_plugin_map(unit,
                                               unit.target.for_host(),
-                                              &mut visited,
-                                              self.config));
+                                              &mut visited));
         }
         Ok(())
     }
 
     fn walk_used_in_plugin_map(&mut self,
                                unit: &Unit<'a>,
                                is_plugin: bool,
-                               visited: &mut HashSet<(Unit<'a>, bool)>,
-                               config: &Config)
+                               visited: &mut HashSet<(Unit<'a>, bool)>)
                                -> CargoResult<()> {
         if !visited.insert((*unit, is_plugin)) {
             return Ok(())
         }
         if is_plugin {
             self.used_in_plugin.insert(*unit);
         }
-        for unit in try!(self.dep_targets(unit, config)) {
+        for unit in try!(self.dep_targets(unit)) {
             try!(self.walk_used_in_plugin_map(&unit,
                                               is_plugin || unit.target.for_host(),
-                                              visited,
-                                              config));
+                                              visited));
         }
         Ok(())
     }
@@ -446,11 +443,11 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
 
     /// For a package, return all targets which are registered as dependencies
     /// for that package.
-    pub fn dep_targets(&self, unit: &Unit<'a>, config: &Config) -> CargoResult<Vec<Unit<'a>>> {
+    pub fn dep_targets(&self, unit: &Unit<'a>) -> CargoResult<Vec<Unit<'a>>> {
         if unit.profile.run_custom_build {
             return self.dep_run_custom_build(unit)
         } else if unit.profile.doc {
-            return self.doc_deps(unit, config);
+            return self.doc_deps(unit);
         }
 
         let id = unit.pkg.package_id();
@@ -493,7 +490,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
                 true
             })
         }).filter_map(|id| {
-            match self.get_package(id, config) {
+            match self.get_package(id) {
                 Ok(pkg) => {
                     pkg.targets().iter().find(|t| t.is_lib()).map(|t| {
                         Ok(Unit {
@@ -567,7 +564,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
             profile: &self.profiles.dev,
             ..*unit
         };
-        let deps = try!(self.dep_targets(&tmp, self.config));
+        let deps = try!(self.dep_targets(&tmp));
         Ok(deps.iter().filter_map(|unit| {
             if !unit.target.linkable() || unit.pkg.manifest().links().is_none() {
                 return None
@@ -581,7 +578,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
     }
 
     /// Returns the dependencies necessary to document a package
-    fn doc_deps(&self, unit: &Unit<'a>, config: &Config) -> CargoResult<Vec<Unit<'a>>> {
+    fn doc_deps(&self, unit: &Unit<'a>) -> CargoResult<Vec<Unit<'a>>> {
         let deps = self.resolve.deps(unit.pkg.package_id()).filter(|dep| {
             unit.pkg.dependencies().iter().filter(|d| {
                 d.name() == dep.name()
@@ -593,7 +590,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
                 }
             })
         }).map(|dep| {
-            self.get_package(dep, config)
+            self.get_package(dep)
         });
 
         // To document a library, we depend on dependencies actually being
@@ -676,8 +673,8 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
     }
 
     /// Gets a package for the given package id.
-    pub fn get_package(&self, id: &PackageId, config: &Config) -> CargoResult<&'a Package> {
-        self.packages.get(id, config)
+    pub fn get_package(&self, id: &PackageId) -> CargoResult<&'a Package> {
+        self.packages.get(id)
     }
 
     /// Get the user-specified linker for a particular host or target