Allow cargo run in workspaces.

src/bin/cargo/commands/run.rs

@@ -38,14 +38,18 @@ run. If you're passing arguments to both Cargo and the binary, the ones after
 pub fn exec(config: &mut Config, args: &ArgMatches) -> CliResult {
  let ws = args.workspace(config)?;
 
- let mut compile_opts = args.compile_options_for_single_package(config, CompileMode::Build)?;
+ let mut compile_opts = args.compile_options(config, CompileMode::Build)?;
  if !args.is_present("example") && !args.is_present("bin") {
- if let Some(default_run) = compile_opts.get_package(&ws)?
- .and_then(|pkg| pkg.manifest().default_run())
- {
+ let default_runs: Vec<_> = compile_opts
+ .spec
+ .get_packages(&ws)?
+ .iter()
+ .filter_map(|pkg| pkg.manifest().default_run())
+ .collect();
+ if default_runs.len() == 1 {
  compile_opts.filter = CompileFilter::new(
  false,
- vec![default_run.to_owned()],
+ vec![default_runs[0].to_owned()],
  false,
  vec![],
  false,
@@ -56,7 +60,11 @@ pub fn exec(config: &mut Config, args: &ArgMatches) -> CliResult {
  false,
  );
  } else {
+ // ops::run will take care of errors if len pkgs != 1.
  compile_opts.filter = CompileFilter::Default {
+ // Force this to false because the code in ops::run is not
+ // able to pre-check features before compilation starts to
+ // enforce that only 1 binary is built.
  required_features_filterable: false,
  };
  }

src/cargo/ops/cargo_compile.rs

@@ -83,24 +83,6 @@ impl<'a> CompileOptions<'a> {
  export_dir: None,
  })
  }
-
- // Returns the unique specified package, or None
- pub fn get_package<'b>(&self, ws: &'b Workspace) -> CargoResult<Option<&'b Package>> {
- Ok(match self.spec {
- Packages::All | Packages::Default | Packages::OptOut(_) => {
- None
- }
- Packages::Packages(ref xs) => match xs.len() {
- 0 => Some(ws.current()?),
- 1 => Some(ws.members()
- .find(|pkg| *pkg.name() == xs[0])
- .ok_or_else(|| {
- format_err!("package `{}` is not a member of the workspace", xs[0])
- })?),
- _ => None,
- },
- })
- }
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -157,6 +139,27 @@ impl Packages {
  }
  Ok(specs)
  }
+
+ pub fn get_packages<'ws>(&self, ws: &'ws Workspace) -> CargoResult<Vec<&'ws Package>> {
+ let packages: Vec<_> = match self {
+ Packages::Default => ws.default_members().collect(),
+ Packages::All => ws.members().collect(),
+ Packages::OptOut(ref opt_out) => ws
+ .members()
+ .filter(|pkg| !opt_out.iter().any(|name| pkg.name().as_str() == name))
+ .collect(),
+ Packages::Packages(ref pkgs) => pkgs
+ .iter()
+ .map(|name| {
+ ws.members()
+ .find(|pkg| pkg.name().as_str() == name)
+ .ok_or_else(|| {
+ format_err!("package `{}` is not a member of the workspace", name)
+ })
+ }).collect::<CargoResult<Vec<_>>>()?,
+ };
+ Ok(packages)
+ }
 }
 
 #[derive(Debug)]

src/cargo/ops/cargo_run.rs

@@ -1,3 +1,4 @@
+use std::iter;
 use std::path::Path;
 
 use ops;
@@ -11,23 +12,20 @@ pub fn run(
 ) -> CargoResult<Option<ProcessError>> {
  let config = ws.config();
 
- let pkg = options.get_package(ws)?
- .unwrap_or_else(|| unreachable!("cargo run supports single package only"));
-
- // We compute the `bins` here *just for diagnosis*. The actual set of packages to be run
- // is determined by the `ops::compile` call below.
- let bins: Vec<_> = pkg.manifest()
- .targets()
- .iter()
- .filter(|a| {
- !a.is_lib() && !a.is_custom_build() && if !options.filter.is_specific() {
- a.is_bin()
- } else {
- options.filter.target_run(a)
- }
- })
- .map(|bin| (bin.name(), bin.kind()))
- .collect();
+ // We compute the `bins` here *just for diagnosis*. The actual set of
+ // packages to be run is determined by the `ops::compile` call below.
+ let packages = options.spec.get_packages(ws)?;
+ let bins: Vec<_> = packages
+ .into_iter()
+ .flat_map(|pkg| {
+ iter::repeat(pkg).zip(pkg.manifest().targets().iter().filter(|target| {
+ !target.is_lib() && !target.is_custom_build() && if !options.filter.is_specific() {
+ target.is_bin()
+ } else {
+ options.filter.target_run(target)
+ }
+ }))
+ }).collect();
 
  if bins.is_empty() {
  if !options.filter.is_specific() {
@@ -38,31 +36,34 @@ pub fn run(
  }
 
  if bins.len() == 1 {
- let &(name, kind) = bins.first().unwrap();
- if let TargetKind::ExampleLib(..) = kind {
+ let target = bins[0].1;
+ if let TargetKind::ExampleLib(..) = target.kind() {
  bail!(
-  "example target `{}` is a library and cannot be executed",
-  name
-  )
+ "example target `{}` is a library and cannot be executed",
+ target.name()
+ )
  }
  }
 
  if bins.len() > 1 {
  if !options.filter.is_specific() {
- let names: Vec<&str> = bins.into_iter().map(|bin| bin.0).collect();
+ let names: Vec<&str> = bins
+ .into_iter()
+ .map(|(_pkg, target)| target.name())
+ .collect();
  if nightly_features_allowed() {
  bail!(
  "`cargo run` could not determine which binary to run. \
- Use the `--bin` option to specify a binary, \
- or (on nightly) the `default-run` manifest key.\n\
- available binaries: {}",
+  Use the `--bin` option to specify a binary, \
+  or (on nightly) the `default-run` manifest key.\n\
+  available binaries: {}",
  names.join(", ")
  )
  } else {
  bail!(
  "`cargo run` requires that a project only have one \
- executable; use the `--bin` option to specify which one \
- to run\navailable binaries: {}",
+  executable; use the `--bin` option to specify which one \
+  to run\navailable binaries: {}",
  names.join(", ")
  )
  }
@@ -84,6 +85,7 @@ pub fn run(
  Some(path) => path.to_path_buf(),
  None => exe.to_path_buf(),
  };
+ let pkg = bins[0].0;
  let mut process = compile.target_process(exe, pkg)?;
  process.args(args).cwd(config.cwd());
 

tests/testsuite/run.rs

@@ -1098,3 +1098,62 @@ fn explicit_bin_with_args() {
 
  assert_that(p.cargo("run --bin foo hello world"), execs());
 }
+
+#[test]
+fn run_workspace() {
+ let p = project()
+ .file(
+ "Cargo.toml",
+ r#"
+ [workspace]
+ members = ["a", "b"]
+ "#,
+ ).file("a/Cargo.toml", &basic_bin_manifest("a"))
+ .file("a/src/main.rs", r#"fn main() {println!("run-a");}"#)
+ .file("b/Cargo.toml", &basic_bin_manifest("b"))
+ .file("b/src/main.rs", r#"fn main() {println!("run-b");}"#)
+ .build();
+
+ assert_that(
+ p.cargo("run"),
+ execs().with_status(101).with_stderr(
+ "\
+[ERROR] `cargo run` requires that a project only have one executable[..]
+available binaries: a, b",
+ ),
+ );
+ assert_that(
+ p.cargo("run --bin a"),
+ execs().with_status(0).with_stdout("run-a"),
+ );
+}
+
+#[test]
+fn default_run_workspace() {
+ let p = project()
+ .file(
+ "Cargo.toml",
+ r#"
+ [workspace]
+ members = ["a", "b"]
+ "#,
+ ).file(
+ "a/Cargo.toml",
+ r#"
+ cargo-features = ["default-run"]
+
+ [project]
+ name = "a"
+ version = "0.0.1"
+ default-run = "a"
+ "#,
+ ).file("a/src/main.rs", r#"fn main() {println!("run-a");}"#)
+ .file("b/Cargo.toml", &basic_bin_manifest("b"))
+ .file("b/src/main.rs", r#"fn main() {println!("run-b");}"#)
+ .build();
+
+ assert_that(
+ p.cargo("run").masquerade_as_nightly_cargo(),
+ execs().with_status(0).with_stdout("run-a"),
+ );
+}