[x] add check command

Closes: diem#1568
Approved by: metajack

.cargo/config

@@ -1,3 +1,4 @@
 [alias]
 x = "run --package x --bin x --"
+xcheck = "run --package x --bin x -- check"
 xtest = "run --package x --bin x -- test"

x/src/cargo.rs

@@ -31,6 +31,11 @@ impl Cargo {
  self
  }
 
+ pub fn all_targets(&mut self) -> &mut Self {
+ self.inner.arg("--all-targets");
+ self
+ }
+
  pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self {
  self.inner.current_dir(dir);
  self
@@ -96,9 +101,11 @@ impl Cargo {
 #[derive(Debug, Default)]
 pub struct CargoArgs {
  pub all_features: bool,
+ pub all_targets: bool,
 }
 
 pub enum CargoCommand<'a> {
+ Check,
  Test(&'a [OsString]),
 }
 
@@ -157,12 +164,14 @@ impl<'a> CargoCommand<'a> {
 
  pub fn as_str(&self) -> &'static str {
  match self {
+ CargoCommand::Check => "check",
  CargoCommand::Test(_) => "test",
  }
  }
 
  fn pass_through_args(&self) -> &[OsString] {
  match self {
+ CargoCommand::Check => &[],
  CargoCommand::Test(args) => args,
  }
  }
@@ -171,5 +180,8 @@ impl<'a> CargoCommand<'a> {
  if args.all_features {
  cargo.all_features();
  }
+ if args.all_targets {
+ cargo.all_targets();
+ }
  }
 }

x/src/check.rs

@@ -0,0 +1,86 @@
+use crate::{
+ cargo::{CargoArgs, CargoCommand},
+ config::Config,
+ utils, Result,
+};
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+pub struct Args {
+ #[structopt(long, short, number_of_values = 1)]
+ /// Run check on the provided packages
+ package: Vec<String>,
+ #[structopt(long)]
+ /// Run check on all packages in the workspace
+ workspace: bool,
+ #[structopt(long)]
+ /// Run check on all targets of a package (lib, bin, test, example)
+ all_targets: bool,
+}
+
+pub fn run(args: Args, config: Config) -> Result<()> {
+ let cmd = CargoCommand::Check;
+ // If we've been asked to build all targets then we need to enable all_features so that
+ // building the testing targets works
+ let base_args = CargoArgs {
+ all_features: args.all_targets,
+ all_targets: args.all_targets,
+ };
+
+ if !args.package.is_empty() {
+ let run_together = args.package.iter().filter(|p| !config.is_exception(p));
+ let run_separate = args.package.iter().filter_map(|p| {
+ config.package_exceptions().get(p).map(|e| {
+ (
+ p,
+ CargoArgs {
+ all_features: if args.all_targets {
+ e.all_features
+ } else {
+ false
+ },
+ ..base_args
+ },
+ )
+ })
+ });
+ cmd.run_on_packages_together(run_together, &base_args)?;
+ cmd.run_on_packages_separate(run_separate)?;
+ } else if utils::project_is_root()? || args.workspace {
+ cmd.run_with_exclusions(
+ config.package_exceptions().iter().map(|(p, _)| p),
+ &base_args,
+ )?;
+ cmd.run_on_packages_separate(config.package_exceptions().iter().map(|(name, pkg)| {
+ (
+ name,
+ CargoArgs {
+ all_features: if args.all_targets {
+ pkg.all_features
+ } else {
+ false
+ },
+ ..base_args
+ },
+ )
+ }))?;
+ } else {
+ let package = utils::get_local_package()?;
+ let cargo_args = if args.all_targets {
+ let all_features = config
+ .package_exceptions()
+ .get(&package)
+ .map(|pkg| pkg.all_features)
+ .unwrap_or(true);
+ CargoArgs {
+ all_features,
+ ..base_args
+ }
+ } else {
+ base_args
+ };
+
+ cmd.run_on_local_package(&cargo_args)?;
+ }
+ Ok(())
+}

x/src/main.rs

@@ -1,6 +1,7 @@
 use structopt::StructOpt;
 
 mod cargo;
+mod check;
 mod config;
 mod test;
 mod utils;
@@ -15,6 +16,9 @@ struct Args {
 
 #[derive(Debug, StructOpt)]
 enum Command {
+ #[structopt(name = "check")]
+ /// Run `cargo check`
+ Check(check::Args),
  #[structopt(name = "test")]
  /// Run tests
  Test(test::Args),
@@ -26,5 +30,6 @@ fn main() -> Result<()> {
 
  match args.cmd {
  Command::Test(args) => test::run(args, config),
+ Command::Check(args) => check::run(args, config),
  }
 }

x/src/test.rs

@@ -24,11 +24,17 @@ pub fn run(mut args: Args, config: Config) -> Result<()> {
  args.args.extend(args.testname.clone());
 
  let cmd = CargoCommand::Test(&args.args);
+ // When testing, by deafult we want to turn on all features to ensure that the fuzzing features
+ // are flipped on
+ let base_args = CargoArgs {
+ all_features: true,
+ ..CargoArgs::default()
+ };
 
  if args.unit {
  cmd.run_with_exclusions(
  config.package_exceptions().iter().map(|(p, _)| p),
- &CargoArgs { all_features: true },
+ &base_args,
  )?;
  cmd.run_on_packages_separate(
  config
@@ -40,6 +46,7 @@ pub fn run(mut args: Args, config: Config) -> Result<()> {
  name,
  CargoArgs {
  all_features: pkg.all_features,
+ ..base_args
  },
  )
  }),
@@ -53,25 +60,27 @@ pub fn run(mut args: Args, config: Config) -> Result<()> {
  p,
  CargoArgs {
  all_features: e.all_features,
+ ..base_args
  },
  )
  })
  });
- cmd.run_on_packages_together(run_together, &CargoArgs { all_features: true })?;
+ cmd.run_on_packages_together(run_together, &base_args)?;
  cmd.run_on_packages_separate(run_separate)?;
  Ok(())
  } else if utils::project_is_root()? {
  // TODO Maybe only run a subest of tests if we're not inside
  // a package but not at the project root (e.g. language)
  cmd.run_with_exclusions(
  config.package_exceptions().iter().map(|(p, _)| p),
- &CargoArgs { all_features: true },
+ &base_args,
  )?;
  cmd.run_on_packages_separate(config.package_exceptions().iter().map(|(name, pkg)| {
  (
  name,
  CargoArgs {
  all_features: pkg.all_features,
+ ..base_args
  },
  )
  }))?;
@@ -84,7 +93,10 @@ pub fn run(mut args: Args, config: Config) -> Result<()> {
  .map(|pkg| pkg.all_features)
  .unwrap_or(true);
 
- cmd.run_on_local_package(&CargoArgs { all_features })?;
+ cmd.run_on_local_package(&CargoArgs {
+ all_features,
+ ..base_args
+ })?;
  Ok(())
  }
 }