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