src/bootstrap/flags.rs

   1 //! Command-line interface of the rustbuild build system.
   2 //!
   3 //! This module implements the command-line parsing of the build system which
   4 //! has various flags to configure how it's run.
   5
   6 use std::path::PathBuf;
   7
   8 use getopts::Options;
   9
  10 use crate::builder::{Builder, Kind};
  11 use crate::config::{Config, TargetSelection};
  12 use crate::setup::Profile;
  13 use crate::util::t;
  14 use crate::{Build, DocTests};
  15
  16 #[derive(Copy, Clone)]
  17 pub enum Color {
  18     Always,
  19     Never,
  20     Auto,
  21 }
  22
  23 impl Default for Color {
  24     fn default() -> Self {
  25         Self::Auto
  26     }
  27 }
  28
  29 impl std::str::FromStr for Color {
  30     type Err = ();
  31
  32     fn from_str(s: &str) -> Result<Self, Self::Err> {
  33         match s.to_lowercase().as_str() {
  34             "always" => Ok(Self::Always),
  35             "never" => Ok(Self::Never),
  36             "auto" => Ok(Self::Auto),
  37             _ => Err(()),
  38         }
  39     }
  40 }
  41
  42 /// Deserialized version of all flags for this compile.
  43 pub struct Flags {
  44     pub verbose: usize, // number of -v args; each extra -v after the first is passed to Cargo
  45     pub on_fail: Option<String>,
  46     pub stage: Option<u32>,
  47     pub keep_stage: Vec<u32>,
  48     pub keep_stage_std: Vec<u32>,
  49
  50     pub host: Option<Vec<TargetSelection>>,
  51     pub target: Option<Vec<TargetSelection>>,
  52     pub config: Option<PathBuf>,
  53     pub build_dir: Option<PathBuf>,
  54     pub jobs: Option<u32>,
  55     pub cmd: Subcommand,
  56     pub incremental: bool,
  57     pub exclude: Vec<PathBuf>,
  58     pub include_default_paths: bool,
  59     pub rustc_error_format: Option<String>,
  60     pub json_output: bool,
  61     pub dry_run: bool,
  62     pub color: Color,
  63
  64     // This overrides the deny-warnings configuration option,
  65     // which passes -Dwarnings to the compiler invocations.
  66     //
  67     // true => deny, false => warn
  68     pub deny_warnings: Option<bool>,
  69
  70     pub llvm_skip_rebuild: Option<bool>,
  71
  72     pub rust_profile_use: Option<String>,
  73     pub rust_profile_generate: Option<String>,
  74
  75     pub llvm_profile_use: Option<String>,
  76     // LLVM doesn't support a custom location for generating profile
  77     // information.
  78     //
  79     // llvm_out/build/profiles/ is the location this writes to.
  80     pub llvm_profile_generate: bool,
  81 }
  82
  83 #[derive(Debug)]
  84 #[cfg_attr(test, derive(Clone))]
  85 pub enum Subcommand {
  86     Build {
  87         paths: Vec<PathBuf>,
  88     },
  89     Check {
  90         paths: Vec<PathBuf>,
  91     },
  92     Clippy {
  93         fix: bool,
  94         paths: Vec<PathBuf>,
  95         clippy_lint_allow: Vec<String>,
  96         clippy_lint_deny: Vec<String>,
  97         clippy_lint_warn: Vec<String>,
  98         clippy_lint_forbid: Vec<String>,
  99     },
 100     Fix {
 101         paths: Vec<PathBuf>,
 102     },
 103     Format {
 104         paths: Vec<PathBuf>,
 105         check: bool,
 106     },
 107     Doc {
 108         paths: Vec<PathBuf>,
 109         open: bool,
 110     },
 111     Test {
 112         paths: Vec<PathBuf>,
 113         /// Whether to automatically update stderr/stdout files
 114         bless: bool,
 115         force_rerun: bool,
 116         compare_mode: Option<String>,
 117         pass: Option<String>,
 118         run: Option<String>,
 119         test_args: Vec<String>,
 120         rustc_args: Vec<String>,
 121         fail_fast: bool,
 122         doc_tests: DocTests,
 123         rustfix_coverage: bool,
 124     },
 125     Bench {
 126         paths: Vec<PathBuf>,
 127         test_args: Vec<String>,
 128     },
 129     Clean {
 130         all: bool,
 131     },
 132     Dist {
 133         paths: Vec<PathBuf>,
 134     },
 135     Install {
 136         paths: Vec<PathBuf>,
 137     },
 138     Run {
 139         paths: Vec<PathBuf>,
 140     },
 141     Setup {
 142         profile: Profile,
 143     },
 144 }
 145
 146 impl Default for Subcommand {
 147     fn default() -> Subcommand {
 148         Subcommand::Build { paths: vec![PathBuf::from("nowhere")] }
 149     }
 150 }
 151
 152 impl Flags {
 153     pub fn parse(args: &[String]) -> Flags {
 154         let mut subcommand_help = String::from(
 155             "\
 156 Usage: x.py <subcommand> [options] [<paths>...]
 157
 158 Subcommands:
 159     build, b    Compile either the compiler or libraries
 160     check, c    Compile either the compiler or libraries, using cargo check
 161     clippy      Run clippy (uses rustup/cargo-installed clippy binary)
 162     fix         Run cargo fix
 163     fmt         Run rustfmt
 164     test, t     Build and run some test suites
 165     bench       Build and run some benchmarks
 166     doc, d      Build documentation
 167     clean       Clean out build directories
 168     dist        Build distribution artifacts
 169     install     Install distribution artifacts
 170     run, r      Run tools contained in this repository
 171     setup       Create a config.toml (making it easier to use `x.py` itself)
 172
 173 To learn more about a subcommand, run `./x.py <subcommand> -h`",
 174         );
 175
 176         let mut opts = Options::new();
 177         // Options common to all subcommands
 178         opts.optflagmulti("v", "verbose", "use verbose output (-vv for very verbose)");
 179         opts.optflag("i", "incremental", "use incremental compilation");
 180         opts.optopt("", "config", "TOML configuration file for build", "FILE");
 181         opts.optopt(
 182             "",
 183             "build-dir",
 184             "Build directory, overrides `build.build-dir` in `config.toml`",
 185             "DIR",
 186         );
 187         opts.optopt("", "build", "build target of the stage0 compiler", "BUILD");
 188         opts.optmulti("", "host", "host targets to build", "HOST");
 189         opts.optmulti("", "target", "target targets to build", "TARGET");
 190         opts.optmulti("", "exclude", "build paths to exclude", "PATH");
 191         opts.optflag(
 192             "",
 193             "include-default-paths",
 194             "include default paths in addition to the provided ones",
 195         );
 196         opts.optopt("", "on-fail", "command to run on failure", "CMD");
 197         opts.optflag("", "dry-run", "dry run; don't build anything");
 198         opts.optopt(
 199             "",
 200             "stage",
 201             "stage to build (indicates compiler to use/test, e.g., stage 0 uses the \
 202              bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)",
 203             "N",
 204         );
 205         opts.optmulti(
 206             "",
 207             "keep-stage",
 208             "stage(s) to keep without recompiling \
 209             (pass multiple times to keep e.g., both stages 0 and 1)",
 210             "N",
 211         );
 212         opts.optmulti(
 213             "",
 214             "keep-stage-std",
 215             "stage(s) of the standard library to keep without recompiling \
 216             (pass multiple times to keep e.g., both stages 0 and 1)",
 217             "N",
 218         );
 219         opts.optopt("", "src", "path to the root of the rust checkout", "DIR");
 220         let j_msg = format!(
 221             "number of jobs to run in parallel; \
 222              defaults to {} (this host's logical CPU count)",
 223             std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get)
 224         );
 225         opts.optopt("j", "jobs", &j_msg, "JOBS");
 226         opts.optflag("h", "help", "print this help message");
 227         opts.optopt(
 228             "",
 229             "warnings",
 230             "if value is deny, will deny warnings, otherwise use default",
 231             "VALUE",
 232         );
 233         opts.optopt("", "error-format", "rustc error format", "FORMAT");
 234         opts.optflag("", "json-output", "use message-format=json");
 235         opts.optopt("", "color", "whether to use color in cargo and rustc output", "STYLE");
 236         opts.optopt(
 237             "",
 238             "llvm-skip-rebuild",
 239             "whether rebuilding llvm should be skipped \
 240              a VALUE of TRUE indicates that llvm will not be rebuilt \
 241              VALUE overrides the skip-rebuild option in config.toml.",
 242             "VALUE",
 243         );
 244         opts.optopt(
 245             "",
 246             "rust-profile-generate",
 247             "generate PGO profile with rustc build",
 248             "PROFILE",
 249         );
 250         opts.optopt("", "rust-profile-use", "use PGO profile for rustc build", "PROFILE");
 251         opts.optflag("", "llvm-profile-generate", "generate PGO profile with llvm built for rustc");
 252         opts.optopt("", "llvm-profile-use", "use PGO profile for llvm build", "PROFILE");
 253         opts.optmulti("A", "", "allow certain clippy lints", "OPT");
 254         opts.optmulti("D", "", "deny certain clippy lints", "OPT");
 255         opts.optmulti("W", "", "warn about certain clippy lints", "OPT");
 256         opts.optmulti("F", "", "forbid certain clippy lints", "OPT");
 257
 258         // We can't use getopt to parse the options until we have completed specifying which
 259         // options are valid, but under the current implementation, some options are conditional on
 260         // the subcommand. Therefore we must manually identify the subcommand first, so that we can
 261         // complete the definition of the options.  Then we can use the getopt::Matches object from
 262         // there on out.
 263         let subcommand = match args.iter().find_map(|s| Kind::parse(&s)) {
 264             Some(s) => s,
 265             None => {
 266                 // No or an invalid subcommand -- show the general usage and subcommand help
 267                 // An exit code will be 0 when no subcommand is given, and 1 in case of an invalid
 268                 // subcommand.
 269                 println!("{}\n", subcommand_help);
 270                 let exit_code = if args.is_empty() { 0 } else { 1 };
 271                 crate::detail_exit(exit_code);
 272             }
 273         };
 274
 275         // Some subcommands get extra options
 276         match subcommand {
 277             Kind::Test => {
 278                 opts.optflag("", "no-fail-fast", "Run all tests regardless of failure");
 279                 opts.optmulti("", "skip", "skips tests matching SUBSTRING, if supported by test tool. May be passed multiple times", "SUBSTRING");
 280                 opts.optmulti(
 281                     "",
 282                     "test-args",
 283                     "extra arguments to be passed for the test tool being used \
 284                         (e.g. libtest, compiletest or rustdoc)",
 285                     "ARGS",
 286                 );
 287                 opts.optmulti(
 288                     "",
 289                     "rustc-args",
 290                     "extra options to pass the compiler when running tests",
 291                     "ARGS",
 292                 );
 293                 opts.optflag("", "no-doc", "do not run doc tests");
 294                 opts.optflag("", "doc", "only run doc tests");
 295                 opts.optflag("", "bless", "update all stderr/stdout files of failing ui tests");
 296                 opts.optflag("", "force-rerun", "rerun tests even if the inputs are unchanged");
 297                 opts.optopt(
 298                     "",
 299                     "compare-mode",
 300                     "mode describing what file the actual ui output will be compared to",
 301                     "COMPARE MODE",
 302                 );
 303                 opts.optopt(
 304                     "",
 305                     "pass",
 306                     "force {check,build,run}-pass tests to this mode.",
 307                     "check | build | run",
 308                 );
 309                 opts.optopt("", "run", "whether to execute run-* tests", "auto | always | never");
 310                 opts.optflag(
 311                     "",
 312                     "rustfix-coverage",
 313                     "enable this to generate a Rustfix coverage file, which is saved in \
 314                         `/<build_base>/rustfix_missing_coverage.txt`",
 315                 );
 316             }
 317             Kind::Check => {
 318                 opts.optflag("", "all-targets", "Check all targets");
 319             }
 320             Kind::Bench => {
 321                 opts.optmulti("", "test-args", "extra arguments", "ARGS");
 322             }
 323             Kind::Clippy => {
 324                 opts.optflag("", "fix", "automatically apply lint suggestions");
 325             }
 326             Kind::Doc => {
 327                 opts.optflag("", "open", "open the docs in a browser");
 328             }
 329             Kind::Clean => {
 330                 opts.optflag("", "all", "clean all build artifacts");
 331             }
 332             Kind::Format => {
 333                 opts.optflag("", "check", "check formatting instead of applying.");
 334             }
 335             _ => {}
 336         };
 337
 338         // fn usage()
 339         let usage = |exit_code: i32, opts: &Options, verbose: bool, subcommand_help: &str| -> ! {
 340             let config = Config::parse(&["build".to_string()]);
 341             let build = Build::new(config);
 342             let paths = Builder::get_help(&build, subcommand);
 343
 344             println!("{}", opts.usage(subcommand_help));
 345             if let Some(s) = paths {
 346                 if verbose {
 347                     println!("{}", s);
 348                 } else {
 349                     println!(
 350                         "Run `./x.py {} -h -v` to see a list of available paths.",
 351                         subcommand.as_str()
 352                     );
 353                 }
 354             } else if verbose {
 355                 panic!("No paths available for subcommand `{}`", subcommand.as_str());
 356             }
 357             crate::detail_exit(exit_code);
 358         };
 359
 360         // Done specifying what options are possible, so do the getopts parsing
 361         let matches = opts.parse(args).unwrap_or_else(|e| {
 362             // Invalid argument/option format
 363             println!("\n{}\n", e);
 364             usage(1, &opts, false, &subcommand_help);
 365         });
 366
 367         // Extra sanity check to make sure we didn't hit this crazy corner case:
 368         //
 369         //     ./x.py --frobulate clean build
 370         //            ^-- option  ^     ^- actual subcommand
 371         //                        \_ arg to option could be mistaken as subcommand
 372         let mut pass_sanity_check = true;
 373         match matches.free.get(0).and_then(|s| Kind::parse(&s)) {
 374             Some(check_subcommand) => {
 375                 if check_subcommand != subcommand {
 376                     pass_sanity_check = false;
 377                 }
 378             }
 379             None => {
 380                 pass_sanity_check = false;
 381             }
 382         }
 383         if !pass_sanity_check {
 384             eprintln!("{}\n", subcommand_help);
 385             eprintln!(
 386                 "Sorry, I couldn't figure out which subcommand you were trying to specify.\n\
 387                  You may need to move some options to after the subcommand.\n"
 388             );
 389             crate::detail_exit(1);
 390         }
 391         // Extra help text for some commands
 392         match subcommand {
 393             Kind::Build => {
 394                 subcommand_help.push_str(
 395                     "\n
 396 Arguments:
 397     This subcommand accepts a number of paths to directories to the crates
 398     and/or artifacts to compile. For example, for a quick build of a usable
 399     compiler:
 400
 401         ./x.py build --stage 1 library/std
 402
 403     This will build a compiler and standard library from the local source code.
 404     Once this is done, build/$ARCH/stage1 contains a usable compiler.
 405
 406     If no arguments are passed then the default artifacts for that stage are
 407     compiled. For example:
 408
 409         ./x.py build --stage 0
 410         ./x.py build ",
 411                 );
 412             }
 413             Kind::Check => {
 414                 subcommand_help.push_str(
 415                     "\n
 416 Arguments:
 417     This subcommand accepts a number of paths to directories to the crates
 418     and/or artifacts to compile. For example:
 419
 420         ./x.py check library/std
 421
 422     If no arguments are passed then many artifacts are checked.",
 423                 );
 424             }
 425             Kind::Clippy => {
 426                 subcommand_help.push_str(
 427                     "\n
 428 Arguments:
 429     This subcommand accepts a number of paths to directories to the crates
 430     and/or artifacts to run clippy against. For example:
 431
 432         ./x.py clippy library/core
 433         ./x.py clippy library/core library/proc_macro",
 434                 );
 435             }
 436             Kind::Fix => {
 437                 subcommand_help.push_str(
 438                     "\n
 439 Arguments:
 440     This subcommand accepts a number of paths to directories to the crates
 441     and/or artifacts to run `cargo fix` against. For example:
 442
 443         ./x.py fix library/core
 444         ./x.py fix library/core library/proc_macro",
 445                 );
 446             }
 447             Kind::Format => {
 448                 subcommand_help.push_str(
 449                     "\n
 450 Arguments:
 451     This subcommand optionally accepts a `--check` flag which succeeds if formatting is correct and
 452     fails if it is not. For example:
 453
 454         ./x.py fmt
 455         ./x.py fmt --check",
 456                 );
 457             }
 458             Kind::Test => {
 459                 subcommand_help.push_str(
 460                     "\n
 461 Arguments:
 462     This subcommand accepts a number of paths to test directories that
 463     should be compiled and run. For example:
 464
 465         ./x.py test src/test/ui
 466         ./x.py test library/std --test-args hash_map
 467         ./x.py test library/std --stage 0 --no-doc
 468         ./x.py test src/test/ui --bless
 469         ./x.py test src/test/ui --compare-mode chalk
 470
 471     Note that `test src/test/* --stage N` does NOT depend on `build compiler/rustc --stage N`;
 472     just like `build library/std --stage N` it tests the compiler produced by the previous
 473     stage.
 474
 475     Execute tool tests with a tool name argument:
 476
 477         ./x.py test tidy
 478
 479     If no arguments are passed then the complete artifacts for that stage are
 480     compiled and tested.
 481
 482         ./x.py test
 483         ./x.py test --stage 1",
 484                 );
 485             }
 486             Kind::Doc => {
 487                 subcommand_help.push_str(
 488                     "\n
 489 Arguments:
 490     This subcommand accepts a number of paths to directories of documentation
 491     to build. For example:
 492
 493         ./x.py doc src/doc/book
 494         ./x.py doc src/doc/nomicon
 495         ./x.py doc src/doc/book library/std
 496         ./x.py doc library/std --open
 497
 498     If no arguments are passed then everything is documented:
 499
 500         ./x.py doc
 501         ./x.py doc --stage 1",
 502                 );
 503             }
 504             Kind::Run => {
 505                 subcommand_help.push_str(
 506                     "\n
 507 Arguments:
 508     This subcommand accepts a number of paths to tools to build and run. For
 509     example:
 510
 511         ./x.py run src/tools/expand-yaml-anchors
 512
 513     At least a tool needs to be called.",
 514                 );
 515             }
 516             Kind::Setup => {
 517                 subcommand_help.push_str(&format!(
 518                     "\n
 519 x.py setup creates a `config.toml` which changes the defaults for x.py itself.
 520
 521 Arguments:
 522     This subcommand accepts a 'profile' to use for builds. For example:
 523
 524         ./x.py setup library
 525
 526     The profile is optional and you will be prompted interactively if it is not given.
 527     The following profiles are available:
 528
 529 {}",
 530                     Profile::all_for_help("        ").trim_end()
 531                 ));
 532             }
 533             Kind::Bench | Kind::Clean | Kind::Dist | Kind::Install => {}
 534         };
 535         // Get any optional paths which occur after the subcommand
 536         let mut paths = matches.free[1..].iter().map(|p| p.into()).collect::<Vec<PathBuf>>();
 537
 538         let verbose = matches.opt_present("verbose");
 539
 540         // User passed in -h/--help?
 541         if matches.opt_present("help") {
 542             usage(0, &opts, verbose, &subcommand_help);
 543         }
 544
 545         let cmd = match subcommand {
 546             Kind::Build => Subcommand::Build { paths },
 547             Kind::Check => {
 548                 if matches.opt_present("all-targets") {
 549                     println!(
 550                         "Warning: --all-targets is now on by default and does not need to be passed explicitly."
 551                     );
 552                 }
 553                 Subcommand::Check { paths }
 554             }
 555             Kind::Clippy => Subcommand::Clippy {
 556                 paths,
 557                 fix: matches.opt_present("fix"),
 558                 clippy_lint_allow: matches.opt_strs("A"),
 559                 clippy_lint_warn: matches.opt_strs("W"),
 560                 clippy_lint_deny: matches.opt_strs("D"),
 561                 clippy_lint_forbid: matches.opt_strs("F"),
 562             },
 563             Kind::Fix => Subcommand::Fix { paths },
 564             Kind::Test => Subcommand::Test {
 565                 paths,
 566                 bless: matches.opt_present("bless"),
 567                 force_rerun: matches.opt_present("force-rerun"),
 568                 compare_mode: matches.opt_str("compare-mode"),
 569                 pass: matches.opt_str("pass"),
 570                 run: matches.opt_str("run"),
 571                 test_args: matches.opt_strs("test-args"),
 572                 rustc_args: matches.opt_strs("rustc-args"),
 573                 fail_fast: !matches.opt_present("no-fail-fast"),
 574                 rustfix_coverage: matches.opt_present("rustfix-coverage"),
 575                 doc_tests: if matches.opt_present("doc") {
 576                     DocTests::Only
 577                 } else if matches.opt_present("no-doc") {
 578                     DocTests::No
 579                 } else {
 580                     DocTests::Yes
 581                 },
 582             },
 583             Kind::Bench => Subcommand::Bench { paths, test_args: matches.opt_strs("test-args") },
 584             Kind::Doc => Subcommand::Doc { paths, open: matches.opt_present("open") },
 585             Kind::Clean => {
 586                 if !paths.is_empty() {
 587                     println!("\nclean does not take a path argument\n");
 588                     usage(1, &opts, verbose, &subcommand_help);
 589                 }
 590
 591                 Subcommand::Clean { all: matches.opt_present("all") }
 592             }
 593             Kind::Format => Subcommand::Format { check: matches.opt_present("check"), paths },
 594             Kind::Dist => Subcommand::Dist { paths },
 595             Kind::Install => Subcommand::Install { paths },
 596             Kind::Run => {
 597                 if paths.is_empty() {
 598                     println!("\nrun requires at least a path!\n");
 599                     usage(1, &opts, verbose, &subcommand_help);
 600                 }
 601                 Subcommand::Run { paths }
 602             }
 603             Kind::Setup => {
 604                 let profile = if paths.len() > 1 {
 605                     println!("\nat most one profile can be passed to setup\n");
 606                     usage(1, &opts, verbose, &subcommand_help)
 607                 } else if let Some(path) = paths.pop() {
 608                     let profile_string = t!(path.into_os_string().into_string().map_err(
 609                         |path| format!("{} is not a valid UTF8 string", path.to_string_lossy())
 610                     ));
 611
 612                     profile_string.parse().unwrap_or_else(|err| {
 613                         eprintln!("error: {}", err);
 614                         eprintln!("help: the available profiles are:");
 615                         eprint!("{}", Profile::all_for_help("- "));
 616                         crate::detail_exit(1);
 617                     })
 618                 } else {
 619                     t!(crate::setup::interactive_path())
 620                 };
 621                 Subcommand::Setup { profile }
 622             }
 623         };
 624
 625         Flags {
 626             verbose: matches.opt_count("verbose"),
 627             stage: matches.opt_str("stage").map(|j| j.parse().expect("`stage` should be a number")),
 628             dry_run: matches.opt_present("dry-run"),
 629             on_fail: matches.opt_str("on-fail"),
 630             rustc_error_format: matches.opt_str("error-format"),
 631             json_output: matches.opt_present("json-output"),
 632             keep_stage: matches
 633                 .opt_strs("keep-stage")
 634                 .into_iter()
 635                 .map(|j| j.parse().expect("`keep-stage` should be a number"))
 636                 .collect(),
 637             keep_stage_std: matches
 638                 .opt_strs("keep-stage-std")
 639                 .into_iter()
 640                 .map(|j| j.parse().expect("`keep-stage-std` should be a number"))
 641                 .collect(),
 642             host: if matches.opt_present("host") {
 643                 Some(
 644                     split(&matches.opt_strs("host"))
 645                         .into_iter()
 646                         .map(|x| TargetSelection::from_user(&x))
 647                         .collect::<Vec<_>>(),
 648                 )
 649             } else {
 650                 None
 651             },
 652             target: if matches.opt_present("target") {
 653                 Some(
 654                     split(&matches.opt_strs("target"))
 655                         .into_iter()
 656                         .map(|x| TargetSelection::from_user(&x))
 657                         .collect::<Vec<_>>(),
 658                 )
 659             } else {
 660                 None
 661             },
 662             config: matches.opt_str("config").map(PathBuf::from),
 663             build_dir: matches.opt_str("build-dir").map(PathBuf::from),
 664             jobs: matches.opt_str("jobs").map(|j| j.parse().expect("`jobs` should be a number")),
 665             cmd,
 666             incremental: matches.opt_present("incremental"),
 667             exclude: split(&matches.opt_strs("exclude"))
 668                 .into_iter()
 669                 .map(|p| p.into())
 670                 .collect::<Vec<_>>(),
 671             include_default_paths: matches.opt_present("include-default-paths"),
 672             deny_warnings: parse_deny_warnings(&matches),
 673             llvm_skip_rebuild: matches.opt_str("llvm-skip-rebuild").map(|s| s.to_lowercase()).map(
 674                 |s| s.parse::<bool>().expect("`llvm-skip-rebuild` should be either true or false"),
 675             ),
 676             color: matches
 677                 .opt_get_default("color", Color::Auto)
 678                 .expect("`color` should be `always`, `never`, or `auto`"),
 679             rust_profile_use: matches.opt_str("rust-profile-use"),
 680             rust_profile_generate: matches.opt_str("rust-profile-generate"),
 681             llvm_profile_use: matches.opt_str("llvm-profile-use"),
 682             llvm_profile_generate: matches.opt_present("llvm-profile-generate"),
 683         }
 684     }
 685 }
 686
 687 impl Subcommand {
 688     pub fn kind(&self) -> Kind {
 689         match self {
 690             Subcommand::Bench { .. } => Kind::Bench,
 691             Subcommand::Build { .. } => Kind::Build,
 692             Subcommand::Check { .. } => Kind::Check,
 693             Subcommand::Clippy { .. } => Kind::Clippy,
 694             Subcommand::Doc { .. } => Kind::Doc,
 695             Subcommand::Fix { .. } => Kind::Fix,
 696             Subcommand::Format { .. } => Kind::Format,
 697             Subcommand::Test { .. } => Kind::Test,
 698             Subcommand::Clean { .. } => Kind::Clean,
 699             Subcommand::Dist { .. } => Kind::Dist,
 700             Subcommand::Install { .. } => Kind::Install,
 701             Subcommand::Run { .. } => Kind::Run,
 702             Subcommand::Setup { .. } => Kind::Setup,
 703         }
 704     }
 705
 706     pub fn test_args(&self) -> Vec<&str> {
 707         let mut args = vec![];
 708
 709         match *self {
 710             Subcommand::Test { ref test_args, .. } | Subcommand::Bench { ref test_args, .. } => {
 711                 args.extend(test_args.iter().flat_map(|s| s.split_whitespace()))
 712             }
 713             _ => (),
 714         }
 715
 716         args
 717     }
 718
 719     pub fn rustc_args(&self) -> Vec<&str> {
 720         match *self {
 721             Subcommand::Test { ref rustc_args, .. } => {
 722                 rustc_args.iter().flat_map(|s| s.split_whitespace()).collect()
 723             }
 724             _ => Vec::new(),
 725         }
 726     }
 727
 728     pub fn fail_fast(&self) -> bool {
 729         match *self {
 730             Subcommand::Test { fail_fast, .. } => fail_fast,
 731             _ => false,
 732         }
 733     }
 734
 735     pub fn doc_tests(&self) -> DocTests {
 736         match *self {
 737             Subcommand::Test { doc_tests, .. } => doc_tests,
 738             _ => DocTests::Yes,
 739         }
 740     }
 741
 742     pub fn bless(&self) -> bool {
 743         match *self {
 744             Subcommand::Test { bless, .. } => bless,
 745             _ => false,
 746         }
 747     }
 748
 749     pub fn force_rerun(&self) -> bool {
 750         match *self {
 751             Subcommand::Test { force_rerun, .. } => force_rerun,
 752             _ => false,
 753         }
 754     }
 755
 756     pub fn rustfix_coverage(&self) -> bool {
 757         match *self {
 758             Subcommand::Test { rustfix_coverage, .. } => rustfix_coverage,
 759             _ => false,
 760         }
 761     }
 762
 763     pub fn compare_mode(&self) -> Option<&str> {
 764         match *self {
 765             Subcommand::Test { ref compare_mode, .. } => compare_mode.as_ref().map(|s| &s[..]),
 766             _ => None,
 767         }
 768     }
 769
 770     pub fn pass(&self) -> Option<&str> {
 771         match *self {
 772             Subcommand::Test { ref pass, .. } => pass.as_ref().map(|s| &s[..]),
 773             _ => None,
 774         }
 775     }
 776
 777     pub fn run(&self) -> Option<&str> {
 778         match *self {
 779             Subcommand::Test { ref run, .. } => run.as_ref().map(|s| &s[..]),
 780             _ => None,
 781         }
 782     }
 783
 784     pub fn open(&self) -> bool {
 785         match *self {
 786             Subcommand::Doc { open, .. } => open,
 787             _ => false,
 788         }
 789     }
 790 }
 791
 792 fn split(s: &[String]) -> Vec<String> {
 793     s.iter().flat_map(|s| s.split(',')).filter(|s| !s.is_empty()).map(|s| s.to_string()).collect()
 794 }
 795
 796 fn parse_deny_warnings(matches: &getopts::Matches) -> Option<bool> {
 797     match matches.opt_str("warnings").as_deref() {
 798         Some("deny") => Some(true),
 799         Some("warn") => Some(false),
 800         Some(value) => {
 801             eprintln!(r#"invalid value for --warnings: {:?}, expected "warn" or "deny""#, value,);
 802             crate::detail_exit(1);
 803         }
 804         None => None,
 805     }
 806 }