Drop unused specs argument

src/bin/command_prelude.rs

@@ -297,6 +297,17 @@ pub trait ArgMatchesExt {
                 if specs.len() > 1 && self._is_present("features") {
                     bail!("cannot specify features for more than one package")
                 }
+                if specs.is_empty() {
+                    if ws.is_virtual() {
+                        bail!(
+                            "manifest path `{}` contains no package: The manifest is virtual, \
+                             and the workspace has no members.",
+                             ws.root().display()
+                        )
+                    }
+                    bail!("no packages to compile")
+                }
+
                 RequestedPackages {
                     specs,
                     features: self._values_of("features"),

src/cargo/ops/cargo_compile.rs

@@ -179,44 +179,6 @@ impl Packages {
             (true, _, _) => Packages::OptOut(exclude),
         })
     }
-
-    pub fn into_package_id_specs(&self, ws: &Workspace) -> CargoResult<Vec<PackageIdSpec>> {
-        let specs = match *self {
-            Packages::All => ws.members()
-                .map(Package::package_id)
-                .map(PackageIdSpec::from_package_id)
-                .collect(),
-            Packages::OptOut(ref opt_out) => ws.members()
-                .map(Package::package_id)
-                .map(PackageIdSpec::from_package_id)
-                .filter(|p| opt_out.iter().position(|x| *x == p.name()).is_none())
-                .collect(),
-            Packages::Packages(ref packages) if packages.is_empty() => ws.current_opt()
-                .map(Package::package_id)
-                .map(PackageIdSpec::from_package_id)
-                .into_iter()
-                .collect(),
-            Packages::Packages(ref packages) => packages
-                .iter()
-                .map(|p| PackageIdSpec::parse(p))
-                .collect::<CargoResult<Vec<_>>>()?,
-            Packages::Default => ws.default_members()
-                .map(Package::package_id)
-                .map(PackageIdSpec::from_package_id)
-                .collect(),
-        };
-        if specs.is_empty() {
-            if ws.is_virtual() {
-                bail!(
-                    "manifest path `{}` contains no package: The manifest is virtual, \
-                     and the workspace has no members.",
-                    ws.root().display()
-                )
-            }
-            bail!("no packages to compile")
-        }
-        Ok(specs)
-    }
 }
 
 #[derive(Debug)]
@@ -280,7 +242,7 @@ pub fn compile_ws<'a>(
         config,
         jobs,
         ref target,
-        ref spec,
+        spec: _,
         ref features,
         all_features,
         no_default_features,
@@ -320,18 +282,17 @@ pub fn compile_ws<'a>(
 
     let profiles = ws.profiles();
 
-    let specs = spec.into_package_id_specs(ws)?;
     let features = Method::split_features(features);
     let method = Method::Required {
         dev_deps: ws.require_optional_deps() || filter.need_dev_deps(mode),
         features: &features,
         all_features,
         uses_default_features: !no_default_features,
     };
-    let resolve = ops::resolve_ws_with_method(ws, source, method, &specs, requested)?;
+    let resolve = ops::resolve_ws_with_method(ws, source, method, requested)?;
     let (packages, resolve_with_overrides) = resolve;
 
-    let to_builds = specs
+    let to_builds = requested.specs
         .iter()
         .map(|p| {
             let pkgid = p.query(resolve_with_overrides.iter())?;

src/cargo/ops/cargo_doc.rs

@@ -13,19 +13,17 @@ pub struct DocOptions<'a> {
 }
 
 pub fn doc(ws: &Workspace, options: &DocOptions) -> CargoResult<()> {
-    let specs = options.compile_opts.spec.into_package_id_specs(ws)?;
     let resolve = ops::resolve_ws_precisely(
         ws,
         None,
         &options.compile_opts.features,
         options.compile_opts.all_features,
         options.compile_opts.no_default_features,
-        &specs,
         &options.compile_opts.requested
     )?;
     let (packages, resolve_with_overrides) = resolve;
 
-    let pkgs = specs
+    let pkgs = options.compile_opts.requested.specs
         .iter()
         .map(|p| {
             let pkgid = p.query(resolve_with_overrides.iter())?;

src/cargo/ops/cargo_generate_lockfile.rs

@@ -28,7 +28,6 @@ pub fn generate_lockfile(ws: &Workspace) -> CargoResult<()> {
         Method::Everything,
         None,
         None,
-        &[],
         &requested,
         true,
         true,
@@ -92,7 +91,6 @@ pub fn update_lockfile(ws: &Workspace, opts: &UpdateOptions) -> CargoResult<()>
         Method::Everything,
         Some(&previous_resolve),
         Some(&to_avoid),
-        &[],
         &requested,
         true,
         true,

src/cargo/ops/cargo_output_metadata.rs

@@ -2,9 +2,8 @@ use serde::ser::{self, Serialize};
 
 use core::resolver::Resolve;
 use core::{Package, PackageId, Workspace};
-use ops::{self, Packages};
 use util::CargoResult;
-use ops::RequestedPackages;
+use ops::{self, RequestedPackages};
 
 const VERSION: u32 = 1;
 
@@ -46,15 +45,13 @@ fn metadata_no_deps(ws: &Workspace, _opt: &OutputMetadataOptions) -> CargoResult
 }
 
 fn metadata_full(ws: &Workspace, opt: &OutputMetadataOptions) -> CargoResult<ExportInfo> {
-    let specs = Packages::All.into_package_id_specs(ws)?;
     let requested = RequestedPackages::whole_workspace(ws);
     let deps = ops::resolve_ws_precisely(
         ws,
         None,
         &opt.features,
         opt.all_features,
         opt.no_default_features,
-        &specs,
         &requested,
     )?;
     let (packages, resolve) = deps;

src/cargo/ops/resolve.rs

@@ -1,6 +1,6 @@
 use std::collections::HashSet;
 
-use core::{PackageId, PackageIdSpec, PackageSet, Source, SourceId, Workspace};
+use core::{PackageId, PackageSet, Source, SourceId, Workspace};
 use core::registry::PackageRegistry;
 use core::resolver::{self, Method, Resolve};
 use sources::PathSource;
@@ -29,7 +29,6 @@ pub fn resolve_ws_precisely<'a>(
     features: &[String],
     all_features: bool,
     no_default_features: bool,
-    specs: &[PackageIdSpec],
     requested: &RequestedPackages,
 ) -> CargoResult<(PackageSet<'a>, Resolve)> {
     let features = Method::split_features(features);
@@ -43,14 +42,13 @@ pub fn resolve_ws_precisely<'a>(
             uses_default_features: !no_default_features,
         }
     };
-    resolve_ws_with_method(ws, source, method, specs, requested)
+    resolve_ws_with_method(ws, source, method, requested)
 }
 
 pub fn resolve_ws_with_method<'a>(
     ws: &Workspace<'a>,
     source: Option<Box<Source + 'a>>,
     method: Method,
-    specs: &[PackageIdSpec],
     requested: &RequestedPackages,
 ) -> CargoResult<(PackageSet<'a>, Resolve)> {
     let mut registry = PackageRegistry::new(ws.config())?;
@@ -94,7 +92,6 @@ pub fn resolve_ws_with_method<'a>(
         method,
         resolve.as_ref(),
         None,
-        specs,
         requested,
         add_patches,
         true,
@@ -118,7 +115,6 @@ fn resolve_with_registry<'cfg>(
         Method::Everything,
         prev.as_ref(),
         None,
-        &[],
         &requested,
         true,
         warn,
@@ -145,7 +141,6 @@ pub fn resolve_with_previous<'a, 'cfg>(
     method: Method,
     previous: Option<&'a Resolve>,
     to_avoid: Option<&HashSet<&'a PackageId>>,
-    _specs: &[PackageIdSpec],
     requested: &RequestedPackages,
     register_patches: bool,
     warn: bool,