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