src/librustc/session/config.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Contains infrastructure for configuring the compiler, including parsing
  12 //! command line options.
  13
  14 pub use self::EntryFnType::*;
  15 pub use self::CrateType::*;
  16 pub use self::Passes::*;
  17 pub use self::DebugInfoLevel::*;
  18
  19 use session::{early_error, early_warn, Session};
  20 use session::search_paths::SearchPaths;
  21
  22 use rustc_back::target::Target;
  23 use lint;
  24 use middle::cstore;
  25
  26 use syntax::ast::{self, IntTy, UintTy};
  27 use syntax::attr;
  28 use syntax::attr::AttrMetaMethods;
  29 use syntax::errors::{ColorConfig, Handler};
  30 use syntax::parse;
  31 use syntax::parse::lexer::Reader;
  32 use syntax::parse::token::InternedString;
  33 use syntax::feature_gate::UnstableFeatures;
  34
  35 use getopts;
  36 use std::collections::HashMap;
  37 use std::env;
  38 use std::fmt;
  39 use std::path::PathBuf;
  40
  41 pub struct Config {
  42     pub target: Target,
  43     pub int_type: IntTy,
  44     pub uint_type: UintTy,
  45 }
  46
  47 #[derive(Clone, Copy, PartialEq)]
  48 pub enum OptLevel {
  49     No, // -O0
  50     Less, // -O1
  51     Default, // -O2
  52     Aggressive // -O3
  53 }
  54
  55 #[derive(Clone, Copy, PartialEq)]
  56 pub enum DebugInfoLevel {
  57     NoDebugInfo,
  58     LimitedDebugInfo,
  59     FullDebugInfo,
  60 }
  61
  62 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
  63 pub enum OutputType {
  64     Bitcode,
  65     Assembly,
  66     LlvmAssembly,
  67     Object,
  68     Exe,
  69     DepInfo,
  70 }
  71
  72 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
  73 pub enum ErrorOutputType {
  74     HumanReadable(ColorConfig),
  75     Json,
  76 }
  77
  78 impl Default for ErrorOutputType {
  79     fn default() -> ErrorOutputType {
  80         ErrorOutputType::HumanReadable(ColorConfig::Auto)
  81     }
  82 }
  83
  84 impl OutputType {
  85     fn is_compatible_with_codegen_units_and_single_output_file(&self) -> bool {
  86         match *self {
  87             OutputType::Exe |
  88             OutputType::DepInfo => true,
  89             OutputType::Bitcode |
  90             OutputType::Assembly |
  91             OutputType::LlvmAssembly |
  92             OutputType::Object => false,
  93         }
  94     }
  95
  96     fn shorthand(&self) -> &'static str {
  97         match *self {
  98             OutputType::Bitcode => "llvm-bc",
  99             OutputType::Assembly => "asm",
 100             OutputType::LlvmAssembly => "llvm-ir",
 101             OutputType::Object => "obj",
 102             OutputType::Exe => "link",
 103             OutputType::DepInfo => "dep-info",
 104         }
 105     }
 106 }
 107
 108 #[derive(Clone)]
 109 pub struct Options {
 110     // The crate config requested for the session, which may be combined
 111     // with additional crate configurations during the compile process
 112     pub crate_types: Vec<CrateType>,
 113
 114     pub gc: bool,
 115     pub optimize: OptLevel,
 116     pub debug_assertions: bool,
 117     pub debuginfo: DebugInfoLevel,
 118     pub lint_opts: Vec<(String, lint::Level)>,
 119     pub lint_cap: Option<lint::Level>,
 120     pub describe_lints: bool,
 121     pub output_types: HashMap<OutputType, Option<PathBuf>>,
 122     // This was mutable for rustpkg, which updates search paths based on the
 123     // parsed code. It remains mutable in case its replacements wants to use
 124     // this.
 125     pub search_paths: SearchPaths,
 126     pub libs: Vec<(String, cstore::NativeLibraryKind)>,
 127     pub maybe_sysroot: Option<PathBuf>,
 128     pub target_triple: String,
 129     // User-specified cfg meta items. The compiler itself will add additional
 130     // items to the crate config, and during parsing the entire crate config
 131     // will be added to the crate AST node.  This should not be used for
 132     // anything except building the full crate config prior to parsing.
 133     pub cfg: ast::CrateConfig,
 134     pub test: bool,
 135     pub parse_only: bool,
 136     pub no_trans: bool,
 137     pub error_format: ErrorOutputType,
 138     pub treat_err_as_bug: bool,
 139     pub continue_parse_after_error: bool,
 140     pub mir_opt_level: usize,
 141
 142     /// if Some, enable incremental compilation, using the given
 143     /// directory to store intermediate results
 144     pub incremental: Option<PathBuf>,
 145
 146     pub no_analysis: bool,
 147     pub debugging_opts: DebuggingOptions,
 148     pub prints: Vec<PrintRequest>,
 149     pub cg: CodegenOptions,
 150     pub externs: HashMap<String, Vec<String>>,
 151     pub crate_name: Option<String>,
 152     /// An optional name to use as the crate for std during std injection,
 153     /// written `extern crate std = "name"`. Default to "std". Used by
 154     /// out-of-tree drivers.
 155     pub alt_std_name: Option<String>,
 156     /// Indicates how the compiler should treat unstable features
 157     pub unstable_features: UnstableFeatures
 158 }
 159
 160 #[derive(Clone, PartialEq, Eq)]
 161 pub enum PrintRequest {
 162     FileNames,
 163     Sysroot,
 164     CrateName,
 165     Cfg,
 166     TargetList,
 167 }
 168
 169 pub enum Input {
 170     /// Load source from file
 171     File(PathBuf),
 172     Str {
 173         /// String that is shown in place of a filename
 174         name: String,
 175         /// Anonymous source string
 176         input: String,
 177     },
 178 }
 179
 180 impl Input {
 181     pub fn filestem(&self) -> String {
 182         match *self {
 183             Input::File(ref ifile) => ifile.file_stem().unwrap()
 184                                            .to_str().unwrap().to_string(),
 185             Input::Str { .. } => "rust_out".to_string(),
 186         }
 187     }
 188 }
 189
 190 #[derive(Clone)]
 191 pub struct OutputFilenames {
 192     pub out_directory: PathBuf,
 193     pub out_filestem: String,
 194     pub single_output_file: Option<PathBuf>,
 195     pub extra: String,
 196     pub outputs: HashMap<OutputType, Option<PathBuf>>,
 197 }
 198
 199 impl OutputFilenames {
 200     pub fn path(&self, flavor: OutputType) -> PathBuf {
 201         self.outputs.get(&flavor).and_then(|p| p.to_owned())
 202             .or_else(|| self.single_output_file.clone())
 203             .unwrap_or_else(|| self.temp_path(flavor))
 204     }
 205
 206     pub fn temp_path(&self, flavor: OutputType) -> PathBuf {
 207         let base = self.out_directory.join(&self.filestem());
 208         match flavor {
 209             OutputType::Bitcode => base.with_extension("bc"),
 210             OutputType::Assembly => base.with_extension("s"),
 211             OutputType::LlvmAssembly => base.with_extension("ll"),
 212             OutputType::Object => base.with_extension("o"),
 213             OutputType::DepInfo => base.with_extension("d"),
 214             OutputType::Exe => base,
 215         }
 216     }
 217
 218     pub fn with_extension(&self, extension: &str) -> PathBuf {
 219         self.out_directory.join(&self.filestem()).with_extension(extension)
 220     }
 221
 222     pub fn filestem(&self) -> String {
 223         format!("{}{}", self.out_filestem, self.extra)
 224     }
 225 }
 226
 227 pub fn host_triple() -> &'static str {
 228     // Get the host triple out of the build environment. This ensures that our
 229     // idea of the host triple is the same as for the set of libraries we've
 230     // actually built.  We can't just take LLVM's host triple because they
 231     // normalize all ix86 architectures to i386.
 232     //
 233     // Instead of grabbing the host triple (for the current host), we grab (at
 234     // compile time) the target triple that this rustc is built with and
 235     // calling that (at runtime) the host triple.
 236     (option_env!("CFG_COMPILER_HOST_TRIPLE")).
 237         expect("CFG_COMPILER_HOST_TRIPLE")
 238 }
 239
 240 /// Some reasonable defaults
 241 pub fn basic_options() -> Options {
 242     Options {
 243         crate_types: Vec::new(),
 244         gc: false,
 245         optimize: OptLevel::No,
 246         debuginfo: NoDebugInfo,
 247         lint_opts: Vec::new(),
 248         lint_cap: None,
 249         describe_lints: false,
 250         output_types: HashMap::new(),
 251         search_paths: SearchPaths::new(),
 252         maybe_sysroot: None,
 253         target_triple: host_triple().to_string(),
 254         cfg: Vec::new(),
 255         test: false,
 256         parse_only: false,
 257         no_trans: false,
 258         treat_err_as_bug: false,
 259         continue_parse_after_error: false,
 260         mir_opt_level: 1,
 261         incremental: None,
 262         no_analysis: false,
 263         debugging_opts: basic_debugging_options(),
 264         prints: Vec::new(),
 265         cg: basic_codegen_options(),
 266         error_format: ErrorOutputType::default(),
 267         externs: HashMap::new(),
 268         crate_name: None,
 269         alt_std_name: None,
 270         libs: Vec::new(),
 271         unstable_features: UnstableFeatures::Disallow,
 272         debug_assertions: true,
 273     }
 274 }
 275
 276 impl Options {
 277     /// True if there is a reason to build the dep graph.
 278     pub fn build_dep_graph(&self) -> bool {
 279         self.incremental.is_some() ||
 280             self.debugging_opts.dump_dep_graph ||
 281             self.debugging_opts.query_dep_graph
 282     }
 283 }
 284
 285 // The type of entry function, so
 286 // users can have their own entry
 287 // functions that don't start a
 288 // scheduler
 289 #[derive(Copy, Clone, PartialEq)]
 290 pub enum EntryFnType {
 291     EntryMain,
 292     EntryStart,
 293     EntryNone,
 294 }
 295
 296 #[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug)]
 297 pub enum CrateType {
 298     CrateTypeExecutable,
 299     CrateTypeDylib,
 300     CrateTypeRlib,
 301     CrateTypeStaticlib,
 302 }
 303
 304 #[derive(Clone)]
 305 pub enum Passes {
 306     SomePasses(Vec<String>),
 307     AllPasses,
 308 }
 309
 310 impl Passes {
 311     pub fn is_empty(&self) -> bool {
 312         match *self {
 313             SomePasses(ref v) => v.is_empty(),
 314             AllPasses => false,
 315         }
 316     }
 317 }
 318
 319 /// Declare a macro that will define all CodegenOptions/DebuggingOptions fields and parsers all
 320 /// at once. The goal of this macro is to define an interface that can be
 321 /// programmatically used by the option parser in order to initialize the struct
 322 /// without hardcoding field names all over the place.
 323 ///
 324 /// The goal is to invoke this macro once with the correct fields, and then this
 325 /// macro generates all necessary code. The main gotcha of this macro is the
 326 /// cgsetters module which is a bunch of generated code to parse an option into
 327 /// its respective field in the struct. There are a few hand-written parsers for
 328 /// parsing specific types of values in this module.
 329 macro_rules! options {
 330     ($struct_name:ident, $setter_name:ident, $defaultfn:ident,
 331      $buildfn:ident, $prefix:expr, $outputname:expr,
 332      $stat:ident, $mod_desc:ident, $mod_set:ident,
 333      $($opt:ident : $t:ty = ($init:expr, $parse:ident, $desc:expr)),* ,) =>
 334 (
 335     #[derive(Clone)]
 336     pub struct $struct_name { $(pub $opt: $t),* }
 337
 338     pub fn $defaultfn() -> $struct_name {
 339         $struct_name { $($opt: $init),* }
 340     }
 341
 342     pub fn $buildfn(matches: &getopts::Matches, error_format: ErrorOutputType) -> $struct_name
 343     {
 344         let mut op = $defaultfn();
 345         for option in matches.opt_strs($prefix) {
 346             let mut iter = option.splitn(2, '=');
 347             let key = iter.next().unwrap();
 348             let value = iter.next();
 349             let option_to_lookup = key.replace("-", "_");
 350             let mut found = false;
 351             for &(candidate, setter, opt_type_desc, _) in $stat {
 352                 if option_to_lookup != candidate { continue }
 353                 if !setter(&mut op, value) {
 354                     match (value, opt_type_desc) {
 355                         (Some(..), None) => {
 356                             early_error(error_format, &format!("{} option `{}` takes no \
 357                                                               value", $outputname, key))
 358                         }
 359                         (None, Some(type_desc)) => {
 360                             early_error(error_format, &format!("{0} option `{1}` requires \
 361                                                               {2} ({3} {1}=<value>)",
 362                                                              $outputname, key,
 363                                                              type_desc, $prefix))
 364                         }
 365                         (Some(value), Some(type_desc)) => {
 366                             early_error(error_format, &format!("incorrect value `{}` for {} \
 367                                                               option `{}` - {} was expected",
 368                                                              value, $outputname,
 369                                                              key, type_desc))
 370                         }
 371                         (None, None) => bug!()
 372                     }
 373                 }
 374                 found = true;
 375                 break;
 376             }
 377             if !found {
 378                 early_error(error_format, &format!("unknown {} option: `{}`",
 379                                                  $outputname, key));
 380             }
 381         }
 382         return op;
 383     }
 384
 385     pub type $setter_name = fn(&mut $struct_name, v: Option<&str>) -> bool;
 386     pub const $stat: &'static [(&'static str, $setter_name,
 387                                      Option<&'static str>, &'static str)] =
 388         &[ $( (stringify!($opt), $mod_set::$opt, $mod_desc::$parse, $desc) ),* ];
 389
 390     #[allow(non_upper_case_globals, dead_code)]
 391     mod $mod_desc {
 392         pub const parse_bool: Option<&'static str> = None;
 393         pub const parse_opt_bool: Option<&'static str> =
 394             Some("one of: `y`, `yes`, `on`, `n`, `no`, or `off`");
 395         pub const parse_string: Option<&'static str> = Some("a string");
 396         pub const parse_opt_string: Option<&'static str> = Some("a string");
 397         pub const parse_list: Option<&'static str> = Some("a space-separated list of strings");
 398         pub const parse_opt_list: Option<&'static str> = Some("a space-separated list of strings");
 399         pub const parse_uint: Option<&'static str> = Some("a number");
 400         pub const parse_passes: Option<&'static str> =
 401             Some("a space-separated list of passes, or `all`");
 402         pub const parse_opt_uint: Option<&'static str> =
 403             Some("a number");
 404     }
 405
 406     #[allow(dead_code)]
 407     mod $mod_set {
 408         use super::{$struct_name, Passes, SomePasses, AllPasses};
 409
 410         $(
 411             pub fn $opt(cg: &mut $struct_name, v: Option<&str>) -> bool {
 412                 $parse(&mut cg.$opt, v)
 413             }
 414         )*
 415
 416         fn parse_bool(slot: &mut bool, v: Option<&str>) -> bool {
 417             match v {
 418                 Some(..) => false,
 419                 None => { *slot = true; true }
 420             }
 421         }
 422
 423         fn parse_opt_bool(slot: &mut Option<bool>, v: Option<&str>) -> bool {
 424             match v {
 425                 Some(s) => {
 426                     match s {
 427                         "n" | "no" | "off" => {
 428                             *slot = Some(false);
 429                         }
 430                         "y" | "yes" | "on" => {
 431                             *slot = Some(true);
 432                         }
 433                         _ => { return false; }
 434                     }
 435
 436                     true
 437                 },
 438                 None => { *slot = Some(true); true }
 439             }
 440         }
 441
 442         fn parse_opt_string(slot: &mut Option<String>, v: Option<&str>) -> bool {
 443             match v {
 444                 Some(s) => { *slot = Some(s.to_string()); true },
 445                 None => false,
 446             }
 447         }
 448
 449         fn parse_string(slot: &mut String, v: Option<&str>) -> bool {
 450             match v {
 451                 Some(s) => { *slot = s.to_string(); true },
 452                 None => false,
 453             }
 454         }
 455
 456         fn parse_list(slot: &mut Vec<String>, v: Option<&str>)
 457                       -> bool {
 458             match v {
 459                 Some(s) => {
 460                     for s in s.split_whitespace() {
 461                         slot.push(s.to_string());
 462                     }
 463                     true
 464                 },
 465                 None => false,
 466             }
 467         }
 468
 469         fn parse_opt_list(slot: &mut Option<Vec<String>>, v: Option<&str>)
 470                       -> bool {
 471             match v {
 472                 Some(s) => {
 473                     let v = s.split_whitespace().map(|s| s.to_string()).collect();
 474                     *slot = Some(v);
 475                     true
 476                 },
 477                 None => false,
 478             }
 479         }
 480
 481         fn parse_uint(slot: &mut usize, v: Option<&str>) -> bool {
 482             match v.and_then(|s| s.parse().ok()) {
 483                 Some(i) => { *slot = i; true },
 484                 None => false
 485             }
 486         }
 487
 488         fn parse_opt_uint(slot: &mut Option<usize>, v: Option<&str>) -> bool {
 489             match v {
 490                 Some(s) => { *slot = s.parse().ok(); slot.is_some() }
 491                 None => { *slot = None; true }
 492             }
 493         }
 494
 495         fn parse_passes(slot: &mut Passes, v: Option<&str>) -> bool {
 496             match v {
 497                 Some("all") => {
 498                     *slot = AllPasses;
 499                     true
 500                 }
 501                 v => {
 502                     let mut passes = vec!();
 503                     if parse_list(&mut passes, v) {
 504                         *slot = SomePasses(passes);
 505                         true
 506                     } else {
 507                         false
 508                     }
 509                 }
 510             }
 511         }
 512     }
 513 ) }
 514
 515 options! {CodegenOptions, CodegenSetter, basic_codegen_options,
 516          build_codegen_options, "C", "codegen",
 517          CG_OPTIONS, cg_type_desc, cgsetters,
 518     ar: Option<String> = (None, parse_opt_string,
 519         "tool to assemble archives with"),
 520     linker: Option<String> = (None, parse_opt_string,
 521         "system linker to link outputs with"),
 522     link_args: Option<Vec<String>> = (None, parse_opt_list,
 523         "extra arguments to pass to the linker (space separated)"),
 524     link_dead_code: bool = (false, parse_bool,
 525         "don't let linker strip dead code (turning it on can be used for code coverage)"),
 526     lto: bool = (false, parse_bool,
 527         "perform LLVM link-time optimizations"),
 528     target_cpu: Option<String> = (None, parse_opt_string,
 529         "select target processor (llc -mcpu=help for details)"),
 530     target_feature: String = ("".to_string(), parse_string,
 531         "target specific attributes (llc -mattr=help for details)"),
 532     passes: Vec<String> = (Vec::new(), parse_list,
 533         "a list of extra LLVM passes to run (space separated)"),
 534     llvm_args: Vec<String> = (Vec::new(), parse_list,
 535         "a list of arguments to pass to llvm (space separated)"),
 536     save_temps: bool = (false, parse_bool,
 537         "save all temporary output files during compilation"),
 538     rpath: bool = (false, parse_bool,
 539         "set rpath values in libs/exes"),
 540     no_prepopulate_passes: bool = (false, parse_bool,
 541         "don't pre-populate the pass manager with a list of passes"),
 542     no_vectorize_loops: bool = (false, parse_bool,
 543         "don't run the loop vectorization optimization passes"),
 544     no_vectorize_slp: bool = (false, parse_bool,
 545         "don't run LLVM's SLP vectorization pass"),
 546     soft_float: bool = (false, parse_bool,
 547         "generate software floating point library calls"),
 548     prefer_dynamic: bool = (false, parse_bool,
 549         "prefer dynamic linking to static linking"),
 550     no_integrated_as: bool = (false, parse_bool,
 551         "use an external assembler rather than LLVM's integrated one"),
 552     no_redzone: Option<bool> = (None, parse_opt_bool,
 553         "disable the use of the redzone"),
 554     relocation_model: Option<String> = (None, parse_opt_string,
 555          "choose the relocation model to use (llc -relocation-model for details)"),
 556     code_model: Option<String> = (None, parse_opt_string,
 557          "choose the code model to use (llc -code-model for details)"),
 558     metadata: Vec<String> = (Vec::new(), parse_list,
 559          "metadata to mangle symbol names with"),
 560     extra_filename: String = ("".to_string(), parse_string,
 561          "extra data to put in each output filename"),
 562     codegen_units: usize = (1, parse_uint,
 563         "divide crate into N units to optimize in parallel"),
 564     remark: Passes = (SomePasses(Vec::new()), parse_passes,
 565         "print remarks for these optimization passes (space separated, or \"all\")"),
 566     no_stack_check: bool = (false, parse_bool,
 567         "disable checks for stack exhaustion (a memory-safety hazard!)"),
 568     debuginfo: Option<usize> = (None, parse_opt_uint,
 569         "debug info emission level, 0 = no debug info, 1 = line tables only, \
 570          2 = full debug info with variable and type information"),
 571     opt_level: Option<usize> = (None, parse_opt_uint,
 572         "optimize with possible levels 0-3"),
 573     debug_assertions: Option<bool> = (None, parse_opt_bool,
 574         "explicitly enable the cfg(debug_assertions) directive"),
 575     inline_threshold: Option<usize> = (None, parse_opt_uint,
 576         "set the inlining threshold for"),
 577 }
 578
 579
 580 options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
 581          build_debugging_options, "Z", "debugging",
 582          DB_OPTIONS, db_type_desc, dbsetters,
 583     verbose: bool = (false, parse_bool,
 584         "in general, enable more debug printouts"),
 585     time_passes: bool = (false, parse_bool,
 586         "measure time of each rustc pass"),
 587     count_llvm_insns: bool = (false, parse_bool,
 588         "count where LLVM instrs originate"),
 589     time_llvm_passes: bool = (false, parse_bool,
 590         "measure time of each LLVM pass"),
 591     input_stats: bool = (false, parse_bool,
 592         "gather statistics about the input"),
 593     trans_stats: bool = (false, parse_bool,
 594         "gather trans statistics"),
 595     asm_comments: bool = (false, parse_bool,
 596         "generate comments into the assembly (may change behavior)"),
 597     no_verify: bool = (false, parse_bool,
 598         "skip LLVM verification"),
 599     borrowck_stats: bool = (false, parse_bool,
 600         "gather borrowck statistics"),
 601     no_landing_pads: bool = (false, parse_bool,
 602         "omit landing pads for unwinding"),
 603     debug_llvm: bool = (false, parse_bool,
 604         "enable debug output from LLVM"),
 605     count_type_sizes: bool = (false, parse_bool,
 606         "count the sizes of aggregate types"),
 607     meta_stats: bool = (false, parse_bool,
 608         "gather metadata statistics"),
 609     print_link_args: bool = (false, parse_bool,
 610         "print the arguments passed to the linker"),
 611     gc: bool = (false, parse_bool,
 612         "garbage collect shared data (experimental)"),
 613     print_llvm_passes: bool = (false, parse_bool,
 614         "prints the llvm optimization passes being run"),
 615     ast_json: bool = (false, parse_bool,
 616         "print the AST as JSON and halt"),
 617     ast_json_noexpand: bool = (false, parse_bool,
 618         "print the pre-expansion AST as JSON and halt"),
 619     ls: bool = (false, parse_bool,
 620         "list the symbols defined by a library crate"),
 621     save_analysis: bool = (false, parse_bool,
 622         "write syntax and type analysis information in addition to normal output"),
 623     print_move_fragments: bool = (false, parse_bool,
 624         "print out move-fragment data for every fn"),
 625     flowgraph_print_loans: bool = (false, parse_bool,
 626         "include loan analysis data in --unpretty flowgraph output"),
 627     flowgraph_print_moves: bool = (false, parse_bool,
 628         "include move analysis data in --unpretty flowgraph output"),
 629     flowgraph_print_assigns: bool = (false, parse_bool,
 630         "include assignment analysis data in --unpretty flowgraph output"),
 631     flowgraph_print_all: bool = (false, parse_bool,
 632         "include all dataflow analysis data in --unpretty flowgraph output"),
 633     print_region_graph: bool = (false, parse_bool,
 634          "prints region inference graph. \
 635           Use with RUST_REGION_GRAPH=help for more info"),
 636     parse_only: bool = (false, parse_bool,
 637           "parse only; do not compile, assemble, or link"),
 638     no_trans: bool = (false, parse_bool,
 639           "run all passes except translation; no output"),
 640     treat_err_as_bug: bool = (false, parse_bool,
 641           "treat all errors that occur as bugs"),
 642     continue_parse_after_error: bool = (false, parse_bool,
 643           "attempt to recover from parse errors (experimental)"),
 644     incremental: Option<String> = (None, parse_opt_string,
 645           "enable incremental compilation (experimental)"),
 646     dump_dep_graph: bool = (false, parse_bool,
 647           "dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv)"),
 648     query_dep_graph: bool = (false, parse_bool,
 649           "enable queries of the dependency graph for regression testing"),
 650     no_analysis: bool = (false, parse_bool,
 651           "parse and expand the source, but run no analysis"),
 652     extra_plugins: Vec<String> = (Vec::new(), parse_list,
 653         "load extra plugins"),
 654     unstable_options: bool = (false, parse_bool,
 655           "adds unstable command line options to rustc interface"),
 656     print_enum_sizes: bool = (false, parse_bool,
 657           "print the size of enums and their variants"),
 658     force_overflow_checks: Option<bool> = (None, parse_opt_bool,
 659           "force overflow checks on or off"),
 660     force_dropflag_checks: Option<bool> = (None, parse_opt_bool,
 661           "force drop flag checks on or off"),
 662     trace_macros: bool = (false, parse_bool,
 663           "for every macro invocation, print its name and arguments"),
 664     enable_nonzeroing_move_hints: bool = (false, parse_bool,
 665           "force nonzeroing move optimization on"),
 666     keep_mtwt_tables: bool = (false, parse_bool,
 667           "don't clear the resolution tables after analysis"),
 668     keep_ast: bool = (false, parse_bool,
 669           "keep the AST after lowering it to HIR"),
 670     show_span: Option<String> = (None, parse_opt_string,
 671           "show spans for compiler debugging (expr|pat|ty)"),
 672     print_trans_items: Option<String> = (None, parse_opt_string,
 673           "print the result of the translation item collection pass"),
 674     mir_opt_level: Option<usize> = (None, parse_opt_uint,
 675           "set the MIR optimization level (0-3)"),
 676     dump_mir: Option<String> = (None, parse_opt_string,
 677           "dump MIR state at various points in translation"),
 678     orbit: bool = (false, parse_bool,
 679           "get MIR where it belongs - everywhere; most importantly, in orbit"),
 680 }
 681
 682 pub fn default_lib_output() -> CrateType {
 683     CrateTypeRlib
 684 }
 685
 686 pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
 687     use syntax::parse::token::intern_and_get_ident as intern;
 688
 689     let end = &sess.target.target.target_endian;
 690     let arch = &sess.target.target.arch;
 691     let wordsz = &sess.target.target.target_pointer_width;
 692     let os = &sess.target.target.target_os;
 693     let env = &sess.target.target.target_env;
 694     let vendor = &sess.target.target.target_vendor;
 695
 696     let fam = if let Some(ref fam) = sess.target.target.options.target_family {
 697         intern(fam)
 698     } else if sess.target.target.options.is_like_windows {
 699         InternedString::new("windows")
 700     } else {
 701         InternedString::new("unix")
 702     };
 703
 704     let mk = attr::mk_name_value_item_str;
 705     let mut ret = vec![ // Target bindings.
 706         mk(InternedString::new("target_os"), intern(os)),
 707         mk(InternedString::new("target_family"), fam.clone()),
 708         mk(InternedString::new("target_arch"), intern(arch)),
 709         mk(InternedString::new("target_endian"), intern(end)),
 710         mk(InternedString::new("target_pointer_width"), intern(wordsz)),
 711         mk(InternedString::new("target_env"), intern(env)),
 712         mk(InternedString::new("target_vendor"), intern(vendor)),
 713     ];
 714     match &fam[..] {
 715         "windows" | "unix" => ret.push(attr::mk_word_item(fam)),
 716         _ => (),
 717     }
 718     if sess.target.target.options.has_elf_tls {
 719         ret.push(attr::mk_word_item(InternedString::new("target_thread_local")));
 720     }
 721     if sess.opts.debug_assertions {
 722         ret.push(attr::mk_word_item(InternedString::new("debug_assertions")));
 723     }
 724     return ret;
 725 }
 726
 727 pub fn append_configuration(cfg: &mut ast::CrateConfig,
 728                             name: InternedString) {
 729     if !cfg.iter().any(|mi| mi.name() == name) {
 730         cfg.push(attr::mk_word_item(name))
 731     }
 732 }
 733
 734 pub fn build_configuration(sess: &Session) -> ast::CrateConfig {
 735     // Combine the configuration requested by the session (command line) with
 736     // some default and generated configuration items
 737     let default_cfg = default_configuration(sess);
 738     let mut user_cfg = sess.opts.cfg.clone();
 739     // If the user wants a test runner, then add the test cfg
 740     if sess.opts.test {
 741         append_configuration(&mut user_cfg, InternedString::new("test"))
 742     }
 743     let mut v = user_cfg.into_iter().collect::<Vec<_>>();
 744     v.extend_from_slice(&default_cfg[..]);
 745     v
 746 }
 747
 748 pub fn build_target_config(opts: &Options, sp: &Handler) -> Config {
 749     let target = match Target::search(&opts.target_triple) {
 750         Ok(t) => t,
 751         Err(e) => {
 752             panic!(sp.fatal(&format!("Error loading target specification: {}", e)));
 753         }
 754     };
 755
 756     let (int_type, uint_type) = match &target.target_pointer_width[..] {
 757         "32" => (ast::IntTy::I32, ast::UintTy::U32),
 758         "64" => (ast::IntTy::I64, ast::UintTy::U64),
 759         w    => panic!(sp.fatal(&format!("target specification was invalid: \
 760                                           unrecognized target-pointer-width {}", w))),
 761     };
 762
 763     Config {
 764         target: target,
 765         int_type: int_type,
 766         uint_type: uint_type,
 767     }
 768 }
 769
 770 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 771 pub enum OptionStability {
 772     Stable,
 773
 774     // FIXME: historically there were some options which were either `-Z` or
 775     //        required the `-Z unstable-options` flag, which were all intended
 776     //        to be unstable. Unfortunately we didn't actually gate usage of
 777     //        these options on the stable compiler, so we still allow them there
 778     //        today. There are some warnings printed out about this in the
 779     //        driver.
 780     UnstableButNotReally,
 781
 782     Unstable,
 783 }
 784
 785 #[derive(Clone, PartialEq, Eq)]
 786 pub struct RustcOptGroup {
 787     pub opt_group: getopts::OptGroup,
 788     pub stability: OptionStability,
 789 }
 790
 791 impl RustcOptGroup {
 792     pub fn is_stable(&self) -> bool {
 793         self.stability == OptionStability::Stable
 794     }
 795
 796     pub fn stable(g: getopts::OptGroup) -> RustcOptGroup {
 797         RustcOptGroup { opt_group: g, stability: OptionStability::Stable }
 798     }
 799
 800     #[allow(dead_code)] // currently we have no "truly unstable" options
 801     pub fn unstable(g: getopts::OptGroup) -> RustcOptGroup {
 802         RustcOptGroup { opt_group: g, stability: OptionStability::Unstable }
 803     }
 804
 805     fn unstable_bnr(g: getopts::OptGroup) -> RustcOptGroup {
 806         RustcOptGroup {
 807             opt_group: g,
 808             stability: OptionStability::UnstableButNotReally,
 809         }
 810     }
 811 }
 812
 813 // The `opt` local module holds wrappers around the `getopts` API that
 814 // adds extra rustc-specific metadata to each option; such metadata
 815 // is exposed by .  The public
 816 // functions below ending with `_u` are the functions that return
 817 // *unstable* options, i.e. options that are only enabled when the
 818 // user also passes the `-Z unstable-options` debugging flag.
 819 mod opt {
 820     // The `fn opt_u` etc below are written so that we can use them
 821     // in the future; do not warn about them not being used right now.
 822     #![allow(dead_code)]
 823
 824     use getopts;
 825     use super::RustcOptGroup;
 826
 827     pub type R = RustcOptGroup;
 828     pub type S<'a> = &'a str;
 829
 830     fn stable(g: getopts::OptGroup) -> R { RustcOptGroup::stable(g) }
 831     fn unstable(g: getopts::OptGroup) -> R { RustcOptGroup::unstable(g) }
 832     fn unstable_bnr(g: getopts::OptGroup) -> R { RustcOptGroup::unstable_bnr(g) }
 833
 834     pub fn opt_s(a: S, b: S, c: S, d: S) -> R {
 835         stable(getopts::optopt(a, b, c, d))
 836     }
 837     pub fn multi_s(a: S, b: S, c: S, d: S) -> R {
 838         stable(getopts::optmulti(a, b, c, d))
 839     }
 840     pub fn flag_s(a: S, b: S, c: S) -> R {
 841         stable(getopts::optflag(a, b, c))
 842     }
 843     pub fn flagopt_s(a: S, b: S, c: S, d: S) -> R {
 844         stable(getopts::optflagopt(a, b, c, d))
 845     }
 846     pub fn flagmulti_s(a: S, b: S, c: S) -> R {
 847         stable(getopts::optflagmulti(a, b, c))
 848     }
 849
 850     pub fn opt(a: S, b: S, c: S, d: S) -> R {
 851         unstable(getopts::optopt(a, b, c, d))
 852     }
 853     pub fn multi(a: S, b: S, c: S, d: S) -> R {
 854         unstable(getopts::optmulti(a, b, c, d))
 855     }
 856     pub fn flag(a: S, b: S, c: S) -> R {
 857         unstable(getopts::optflag(a, b, c))
 858     }
 859     pub fn flagopt(a: S, b: S, c: S, d: S) -> R {
 860         unstable(getopts::optflagopt(a, b, c, d))
 861     }
 862     pub fn flagmulti(a: S, b: S, c: S) -> R {
 863         unstable(getopts::optflagmulti(a, b, c))
 864     }
 865
 866     // Do not use these functions for any new options added to the compiler, all
 867     // new options should use the `*_u` variants above to be truly unstable.
 868     pub fn opt_ubnr(a: S, b: S, c: S, d: S) -> R {
 869         unstable_bnr(getopts::optopt(a, b, c, d))
 870     }
 871     pub fn multi_ubnr(a: S, b: S, c: S, d: S) -> R {
 872         unstable_bnr(getopts::optmulti(a, b, c, d))
 873     }
 874     pub fn flag_ubnr(a: S, b: S, c: S) -> R {
 875         unstable_bnr(getopts::optflag(a, b, c))
 876     }
 877     pub fn flagopt_ubnr(a: S, b: S, c: S, d: S) -> R {
 878         unstable_bnr(getopts::optflagopt(a, b, c, d))
 879     }
 880     pub fn flagmulti_ubnr(a: S, b: S, c: S) -> R {
 881         unstable_bnr(getopts::optflagmulti(a, b, c))
 882     }
 883 }
 884
 885 /// Returns the "short" subset of the rustc command line options,
 886 /// including metadata for each option, such as whether the option is
 887 /// part of the stable long-term interface for rustc.
 888 pub fn rustc_short_optgroups() -> Vec<RustcOptGroup> {
 889     vec![
 890         opt::flag_s("h", "help", "Display this message"),
 891         opt::multi_s("", "cfg", "Configure the compilation environment", "SPEC"),
 892         opt::multi_s("L", "",   "Add a directory to the library search path",
 893                    "[KIND=]PATH"),
 894         opt::multi_s("l", "",   "Link the generated crate(s) to the specified native
 895                              library NAME. The optional KIND can be one of,
 896                              static, dylib, or framework. If omitted, dylib is
 897                              assumed.", "[KIND=]NAME"),
 898         opt::multi_s("", "crate-type", "Comma separated list of types of crates
 899                                     for the compiler to emit",
 900                    "[bin|lib|rlib|dylib|staticlib]"),
 901         opt::opt_s("", "crate-name", "Specify the name of the crate being built",
 902                "NAME"),
 903         opt::multi_s("", "emit", "Comma separated list of types of output for \
 904                               the compiler to emit",
 905                  "[asm|llvm-bc|llvm-ir|obj|link|dep-info]"),
 906         opt::multi_s("", "print", "Comma separated list of compiler information to \
 907                                print on stdout",
 908                  "[crate-name|file-names|sysroot|cfg|target-list]"),
 909         opt::flagmulti_s("g",  "",  "Equivalent to -C debuginfo=2"),
 910         opt::flagmulti_s("O", "", "Equivalent to -C opt-level=2"),
 911         opt::opt_s("o", "", "Write output to <filename>", "FILENAME"),
 912         opt::opt_s("",  "out-dir", "Write output to compiler-chosen filename \
 913                                 in <dir>", "DIR"),
 914         opt::opt_s("", "explain", "Provide a detailed explanation of an error \
 915                                message", "OPT"),
 916         opt::flag_s("", "test", "Build a test harness"),
 917         opt::opt_s("", "target", "Target triple for which the code is compiled", "TARGET"),
 918         opt::multi_s("W", "warn", "Set lint warnings", "OPT"),
 919         opt::multi_s("A", "allow", "Set lint allowed", "OPT"),
 920         opt::multi_s("D", "deny", "Set lint denied", "OPT"),
 921         opt::multi_s("F", "forbid", "Set lint forbidden", "OPT"),
 922         opt::multi_s("", "cap-lints", "Set the most restrictive lint level. \
 923                                      More restrictive lints are capped at this \
 924                                      level", "LEVEL"),
 925         opt::multi_s("C", "codegen", "Set a codegen option", "OPT[=VALUE]"),
 926         opt::flag_s("V", "version", "Print version info and exit"),
 927         opt::flag_s("v", "verbose", "Use verbose output"),
 928     ]
 929 }
 930
 931 /// Returns all rustc command line options, including metadata for
 932 /// each option, such as whether the option is part of the stable
 933 /// long-term interface for rustc.
 934 pub fn rustc_optgroups() -> Vec<RustcOptGroup> {
 935     let mut opts = rustc_short_optgroups();
 936     opts.extend_from_slice(&[
 937         opt::multi_s("", "extern", "Specify where an external rust library is located",
 938                      "NAME=PATH"),
 939         opt::opt_s("", "sysroot", "Override the system root", "PATH"),
 940         opt::multi_ubnr("Z", "", "Set internal debugging options", "FLAG"),
 941         opt::opt_ubnr("", "error-format",
 942                       "How errors and other messages are produced",
 943                       "human|json"),
 944         opt::opt_s("", "color", "Configure coloring of output:
 945                                  auto   = colorize, if output goes to a tty (default);
 946                                  always = always colorize output;
 947                                  never  = never colorize output", "auto|always|never"),
 948
 949         opt::flagopt_ubnr("", "pretty",
 950                           "Pretty-print the input instead of compiling;
 951                            valid types are: `normal` (un-annotated source),
 952                            `expanded` (crates expanded), or
 953                            `expanded,identified` (fully parenthesized, AST nodes with IDs).",
 954                           "TYPE"),
 955         opt::flagopt_ubnr("", "unpretty",
 956                           "Present the input source, unstable (and less-pretty) variants;
 957                            valid types are any of the types for `--pretty`, as well as:
 958                            `flowgraph=<nodeid>` (graphviz formatted flowgraph for node),
 959                            `everybody_loops` (all function bodies replaced with `loop {}`),
 960                            `hir` (the HIR), `hir,identified`, or
 961                            `hir,typed` (HIR with types for each node).",
 962                           "TYPE"),
 963
 964         // new options here should **not** use the `_ubnr` functions, all new
 965         // unstable options should use the short variants to indicate that they
 966         // are truly unstable. All `_ubnr` flags are just that way because they
 967         // were so historically.
 968         //
 969         // You may also wish to keep this comment at the bottom of this list to
 970         // ensure that others see it.
 971     ]);
 972     opts
 973 }
 974
 975 // Convert strings provided as --cfg [cfgspec] into a crate_cfg
 976 pub fn parse_cfgspecs(cfgspecs: Vec<String> ) -> ast::CrateConfig {
 977     cfgspecs.into_iter().map(|s| {
 978         let sess = parse::ParseSess::new();
 979         let mut parser = parse::new_parser_from_source_str(&sess,
 980                                                            Vec::new(),
 981                                                            "cfgspec".to_string(),
 982                                                            s.to_string());
 983         let meta_item = panictry!(parser.parse_meta_item());
 984
 985         if !parser.reader.is_eof() {
 986             early_error(ErrorOutputType::default(), &format!("invalid --cfg argument: {}",
 987                                                              s))
 988         }
 989
 990         meta_item
 991     }).collect::<ast::CrateConfig>()
 992 }
 993
 994 pub fn build_session_options(matches: &getopts::Matches) -> Options {
 995     let color = match matches.opt_str("color").as_ref().map(|s| &s[..]) {
 996         Some("auto")   => ColorConfig::Auto,
 997         Some("always") => ColorConfig::Always,
 998         Some("never")  => ColorConfig::Never,
 999
1000         None => ColorConfig::Auto,
1001
1002         Some(arg) => {
1003             early_error(ErrorOutputType::default(), &format!("argument for --color must be auto, \
1004                                                               always or never (instead was `{}`)",
1005                                                             arg))
1006         }
1007     };
1008
1009     // We need the opts_present check because the driver will send us Matches
1010     // with only stable options if no unstable options are used. Since error-format
1011     // is unstable, it will not be present. We have to use opts_present not
1012     // opt_present because the latter will panic.
1013     let error_format = if matches.opts_present(&["error-format".to_owned()]) {
1014         match matches.opt_str("error-format").as_ref().map(|s| &s[..]) {
1015             Some("human")   => ErrorOutputType::HumanReadable(color),
1016             Some("json") => ErrorOutputType::Json,
1017
1018             None => ErrorOutputType::HumanReadable(color),
1019
1020             Some(arg) => {
1021                 early_error(ErrorOutputType::HumanReadable(color),
1022                             &format!("argument for --error-format must be human or json (instead \
1023                                       was `{}`)",
1024                                      arg))
1025             }
1026         }
1027     } else {
1028         ErrorOutputType::HumanReadable(color)
1029     };
1030
1031     let unparsed_crate_types = matches.opt_strs("crate-type");
1032     let crate_types = parse_crate_types_from_list(unparsed_crate_types)
1033         .unwrap_or_else(|e| early_error(error_format, &e[..]));
1034
1035     let mut lint_opts = vec!();
1036     let mut describe_lints = false;
1037
1038     for &level in &[lint::Allow, lint::Warn, lint::Deny, lint::Forbid] {
1039         for lint_name in matches.opt_strs(level.as_str()) {
1040             if lint_name == "help" {
1041                 describe_lints = true;
1042             } else {
1043                 lint_opts.push((lint_name.replace("-", "_"), level));
1044             }
1045         }
1046     }
1047
1048     let lint_cap = matches.opt_str("cap-lints").map(|cap| {
1049         lint::Level::from_str(&cap).unwrap_or_else(|| {
1050             early_error(error_format, &format!("unknown lint level: `{}`", cap))
1051         })
1052     });
1053
1054     let debugging_opts = build_debugging_options(matches, error_format);
1055
1056     let parse_only = debugging_opts.parse_only;
1057     let no_trans = debugging_opts.no_trans;
1058     let treat_err_as_bug = debugging_opts.treat_err_as_bug;
1059     let continue_parse_after_error = debugging_opts.continue_parse_after_error;
1060     let mir_opt_level = debugging_opts.mir_opt_level.unwrap_or(1);
1061     let no_analysis = debugging_opts.no_analysis;
1062
1063     let mut output_types = HashMap::new();
1064     if !debugging_opts.parse_only && !no_trans {
1065         for list in matches.opt_strs("emit") {
1066             for output_type in list.split(',') {
1067                 let mut parts = output_type.splitn(2, '=');
1068                 let output_type = match parts.next().unwrap() {
1069                     "asm" => OutputType::Assembly,
1070                     "llvm-ir" => OutputType::LlvmAssembly,
1071                     "llvm-bc" => OutputType::Bitcode,
1072                     "obj" => OutputType::Object,
1073                     "link" => OutputType::Exe,
1074                     "dep-info" => OutputType::DepInfo,
1075                     part => {
1076                         early_error(error_format, &format!("unknown emission type: `{}`",
1077                                                     part))
1078                     }
1079                 };
1080                 let path = parts.next().map(PathBuf::from);
1081                 output_types.insert(output_type, path);
1082             }
1083         }
1084     };
1085     if output_types.is_empty() {
1086         output_types.insert(OutputType::Exe, None);
1087     }
1088
1089     let mut cg = build_codegen_options(matches, error_format);
1090
1091     // Issue #30063: if user requests llvm-related output to one
1092     // particular path, disable codegen-units.
1093     if matches.opt_present("o") && cg.codegen_units != 1 {
1094         let incompatible: Vec<_> = output_types.iter()
1095             .map(|ot_path| ot_path.0)
1096             .filter(|ot| {
1097                 !ot.is_compatible_with_codegen_units_and_single_output_file()
1098             }).collect();
1099         if !incompatible.is_empty() {
1100             for ot in &incompatible {
1101                 early_warn(error_format, &format!("--emit={} with -o incompatible with \
1102                                                  -C codegen-units=N for N > 1",
1103                                                 ot.shorthand()));
1104             }
1105             early_warn(error_format, "resetting to default -C codegen-units=1");
1106             cg.codegen_units = 1;
1107         }
1108     }
1109
1110     if cg.codegen_units < 1 {
1111         early_error(error_format, "Value for codegen units must be a positive nonzero integer");
1112     }
1113
1114     let cg = cg;
1115
1116     let sysroot_opt = matches.opt_str("sysroot").map(|m| PathBuf::from(&m));
1117     let target = matches.opt_str("target").unwrap_or(
1118         host_triple().to_string());
1119     let opt_level = {
1120         if matches.opt_present("O") {
1121             if cg.opt_level.is_some() {
1122                 early_error(error_format, "-O and -C opt-level both provided");
1123             }
1124             OptLevel::Default
1125         } else {
1126             match cg.opt_level {
1127                 None => OptLevel::No,
1128                 Some(0) => OptLevel::No,
1129                 Some(1) => OptLevel::Less,
1130                 Some(2) => OptLevel::Default,
1131                 Some(3) => OptLevel::Aggressive,
1132                 Some(arg) => {
1133                     early_error(error_format, &format!("optimization level needs to be \
1134                                                       between 0-3 (instead was `{}`)",
1135                                                      arg));
1136                 }
1137             }
1138         }
1139     };
1140     let debug_assertions = cg.debug_assertions.unwrap_or(opt_level == OptLevel::No);
1141     let gc = debugging_opts.gc;
1142     let debuginfo = if matches.opt_present("g") {
1143         if cg.debuginfo.is_some() {
1144             early_error(error_format, "-g and -C debuginfo both provided");
1145         }
1146         FullDebugInfo
1147     } else {
1148         match cg.debuginfo {
1149             None | Some(0) => NoDebugInfo,
1150             Some(1) => LimitedDebugInfo,
1151             Some(2) => FullDebugInfo,
1152             Some(arg) => {
1153                 early_error(error_format, &format!("debug info level needs to be between \
1154                                                   0-2 (instead was `{}`)",
1155                                                  arg));
1156             }
1157         }
1158     };
1159
1160     let mut search_paths = SearchPaths::new();
1161     for s in &matches.opt_strs("L") {
1162         search_paths.add_path(&s[..], error_format);
1163     }
1164
1165     let libs = matches.opt_strs("l").into_iter().map(|s| {
1166         let mut parts = s.splitn(2, '=');
1167         let kind = parts.next().unwrap();
1168         let (name, kind) = match (parts.next(), kind) {
1169             (None, name) |
1170             (Some(name), "dylib") => (name, cstore::NativeUnknown),
1171             (Some(name), "framework") => (name, cstore::NativeFramework),
1172             (Some(name), "static") => (name, cstore::NativeStatic),
1173             (_, s) => {
1174                 early_error(error_format, &format!("unknown library kind `{}`, expected \
1175                                                   one of dylib, framework, or static",
1176                                                  s));
1177             }
1178         };
1179         (name.to_string(), kind)
1180     }).collect();
1181
1182     let cfg = parse_cfgspecs(matches.opt_strs("cfg"));
1183     let test = matches.opt_present("test");
1184
1185     let prints = matches.opt_strs("print").into_iter().map(|s| {
1186         match &*s {
1187             "crate-name" => PrintRequest::CrateName,
1188             "file-names" => PrintRequest::FileNames,
1189             "sysroot" => PrintRequest::Sysroot,
1190             "cfg" => PrintRequest::Cfg,
1191             "target-list" => PrintRequest::TargetList,
1192             req => {
1193                 early_error(error_format, &format!("unknown print request `{}`", req))
1194             }
1195         }
1196     }).collect::<Vec<_>>();
1197
1198     if !cg.remark.is_empty() && debuginfo == NoDebugInfo {
1199         early_warn(error_format, "-C remark will not show source locations without \
1200                                 --debuginfo");
1201     }
1202
1203     let mut externs = HashMap::new();
1204     for arg in &matches.opt_strs("extern") {
1205         let mut parts = arg.splitn(2, '=');
1206         let name = match parts.next() {
1207             Some(s) => s,
1208             None => early_error(error_format, "--extern value must not be empty"),
1209         };
1210         let location = match parts.next() {
1211             Some(s) => s,
1212             None => early_error(error_format, "--extern value must be of the format `foo=bar`"),
1213         };
1214
1215         externs.entry(name.to_string()).or_insert(vec![]).push(location.to_string());
1216     }
1217
1218     let crate_name = matches.opt_str("crate-name");
1219
1220     let incremental = debugging_opts.incremental.as_ref().map(|m| PathBuf::from(m));
1221
1222     Options {
1223         crate_types: crate_types,
1224         gc: gc,
1225         optimize: opt_level,
1226         debuginfo: debuginfo,
1227         lint_opts: lint_opts,
1228         lint_cap: lint_cap,
1229         describe_lints: describe_lints,
1230         output_types: output_types,
1231         search_paths: search_paths,
1232         maybe_sysroot: sysroot_opt,
1233         target_triple: target,
1234         cfg: cfg,
1235         test: test,
1236         parse_only: parse_only,
1237         no_trans: no_trans,
1238         treat_err_as_bug: treat_err_as_bug,
1239         continue_parse_after_error: continue_parse_after_error,
1240         mir_opt_level: mir_opt_level,
1241         incremental: incremental,
1242         no_analysis: no_analysis,
1243         debugging_opts: debugging_opts,
1244         prints: prints,
1245         cg: cg,
1246         error_format: error_format,
1247         externs: externs,
1248         crate_name: crate_name,
1249         alt_std_name: None,
1250         libs: libs,
1251         unstable_features: get_unstable_features_setting(),
1252         debug_assertions: debug_assertions,
1253     }
1254 }
1255
1256 pub fn get_unstable_features_setting() -> UnstableFeatures {
1257     // Whether this is a feature-staged build, i.e. on the beta or stable channel
1258     let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some();
1259     // The secret key needed to get through the rustc build itself by
1260     // subverting the unstable features lints
1261     let bootstrap_secret_key = option_env!("CFG_BOOTSTRAP_KEY");
1262     // The matching key to the above, only known by the build system
1263     let bootstrap_provided_key = env::var("RUSTC_BOOTSTRAP_KEY").ok();
1264     match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) {
1265         (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat,
1266         (true, _, _) => UnstableFeatures::Disallow,
1267         (false, _, _) => UnstableFeatures::Allow
1268     }
1269 }
1270
1271 pub fn parse_crate_types_from_list(list_list: Vec<String>) -> Result<Vec<CrateType>, String> {
1272     let mut crate_types: Vec<CrateType> = Vec::new();
1273     for unparsed_crate_type in &list_list {
1274         for part in unparsed_crate_type.split(',') {
1275             let new_part = match part {
1276                 "lib"       => default_lib_output(),
1277                 "rlib"      => CrateTypeRlib,
1278                 "staticlib" => CrateTypeStaticlib,
1279                 "dylib"     => CrateTypeDylib,
1280                 "bin"       => CrateTypeExecutable,
1281                 _ => {
1282                     return Err(format!("unknown crate type: `{}`",
1283                                        part));
1284                 }
1285             };
1286             if !crate_types.contains(&new_part) {
1287                 crate_types.push(new_part)
1288             }
1289         }
1290     }
1291
1292     return Ok(crate_types);
1293 }
1294
1295 pub mod nightly_options {
1296     use getopts;
1297     use syntax::feature_gate::UnstableFeatures;
1298     use super::{ErrorOutputType, OptionStability, RustcOptGroup, get_unstable_features_setting};
1299     use session::{early_error, early_warn};
1300
1301     pub fn is_unstable_enabled(matches: &getopts::Matches) -> bool {
1302         is_nightly_build() && matches.opt_strs("Z").iter().any(|x| *x == "unstable-options")
1303     }
1304
1305     fn is_nightly_build() -> bool {
1306         match get_unstable_features_setting() {
1307             UnstableFeatures::Allow | UnstableFeatures::Cheat => true,
1308             _ => false,
1309         }
1310     }
1311
1312     pub fn check_nightly_options(matches: &getopts::Matches, flags: &[RustcOptGroup]) {
1313         let has_z_unstable_option = matches.opt_strs("Z").iter().any(|x| *x == "unstable-options");
1314         let really_allows_unstable_options = match get_unstable_features_setting() {
1315             UnstableFeatures::Disallow => false,
1316             _ => true,
1317         };
1318
1319         for opt in flags.iter() {
1320             if opt.stability == OptionStability::Stable {
1321                 continue
1322             }
1323             let opt_name = if opt.opt_group.long_name.is_empty() {
1324                 &opt.opt_group.short_name
1325             } else {
1326                 &opt.opt_group.long_name
1327             };
1328             if !matches.opt_present(opt_name) {
1329                 continue
1330             }
1331             if opt_name != "Z" && !has_z_unstable_option {
1332                 early_error(ErrorOutputType::default(),
1333                             &format!("the `-Z unstable-options` flag must also be passed to enable \
1334                                       the flag `{}`",
1335                                      opt_name));
1336             }
1337             if really_allows_unstable_options {
1338                 continue
1339             }
1340             match opt.stability {
1341                 OptionStability::Unstable => {
1342                     let msg = format!("the option `{}` is only accepted on the \
1343                                        nightly compiler", opt_name);
1344                     early_error(ErrorOutputType::default(), &msg);
1345                 }
1346                 OptionStability::UnstableButNotReally => {
1347                     let msg = format!("the option `{}` is is unstable and should \
1348                                        only be used on the nightly compiler, but \
1349                                        it is currently accepted for backwards \
1350                                        compatibility; this will soon change, \
1351                                        see issue #31847 for more details",
1352                                       opt_name);
1353                     early_warn(ErrorOutputType::default(), &msg);
1354                 }
1355                 OptionStability::Stable => {}
1356             }
1357         }
1358     }
1359 }
1360
1361 impl fmt::Display for CrateType {
1362     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1363         match *self {
1364             CrateTypeExecutable => "bin".fmt(f),
1365             CrateTypeDylib => "dylib".fmt(f),
1366             CrateTypeRlib => "rlib".fmt(f),
1367             CrateTypeStaticlib => "staticlib".fmt(f)
1368         }
1369     }
1370 }
1371
1372 #[cfg(test)]
1373 mod tests {
1374     use middle::cstore::DummyCrateStore;
1375     use session::config::{build_configuration, build_session_options};
1376     use session::build_session;
1377
1378     use std::rc::Rc;
1379     use getopts::{getopts, OptGroup};
1380     use syntax::attr;
1381     use syntax::attr::AttrMetaMethods;
1382     use syntax::diagnostics;
1383
1384     fn optgroups() -> Vec<OptGroup> {
1385         super::rustc_optgroups().into_iter()
1386                                 .map(|a| a.opt_group)
1387                                 .collect()
1388     }
1389
1390     // When the user supplies --test we should implicitly supply --cfg test
1391     #[test]
1392     fn test_switch_implies_cfg_test() {
1393         let matches =
1394             &match getopts(&["--test".to_string()], &optgroups()) {
1395               Ok(m) => m,
1396               Err(f) => panic!("test_switch_implies_cfg_test: {}", f)
1397             };
1398         let registry = diagnostics::registry::Registry::new(&[]);
1399         let sessopts = build_session_options(matches);
1400         let sess = build_session(sessopts, None, registry, Rc::new(DummyCrateStore));
1401         let cfg = build_configuration(&sess);
1402         assert!((attr::contains_name(&cfg[..], "test")));
1403     }
1404
1405     // When the user supplies --test and --cfg test, don't implicitly add
1406     // another --cfg test
1407     #[test]
1408     fn test_switch_implies_cfg_test_unless_cfg_test() {
1409         let matches =
1410             &match getopts(&["--test".to_string(), "--cfg=test".to_string()],
1411                            &optgroups()) {
1412               Ok(m) => m,
1413               Err(f) => {
1414                 panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f)
1415               }
1416             };
1417         let registry = diagnostics::registry::Registry::new(&[]);
1418         let sessopts = build_session_options(matches);
1419         let sess = build_session(sessopts, None, registry,
1420                                  Rc::new(DummyCrateStore));
1421         let cfg = build_configuration(&sess);
1422         let mut test_items = cfg.iter().filter(|m| m.name() == "test");
1423         assert!(test_items.next().is_some());
1424         assert!(test_items.next().is_none());
1425     }
1426
1427     #[test]
1428     fn test_can_print_warnings() {
1429         {
1430             let matches = getopts(&[
1431                 "-Awarnings".to_string()
1432             ], &optgroups()).unwrap();
1433             let registry = diagnostics::registry::Registry::new(&[]);
1434             let sessopts = build_session_options(&matches);
1435             let sess = build_session(sessopts, None, registry,
1436                                      Rc::new(DummyCrateStore));
1437             assert!(!sess.diagnostic().can_emit_warnings);
1438         }
1439
1440         {
1441             let matches = getopts(&[
1442                 "-Awarnings".to_string(),
1443                 "-Dwarnings".to_string()
1444             ], &optgroups()).unwrap();
1445             let registry = diagnostics::registry::Registry::new(&[]);
1446             let sessopts = build_session_options(&matches);
1447             let sess = build_session(sessopts, None, registry,
1448                                      Rc::new(DummyCrateStore));
1449             assert!(sess.diagnostic().can_emit_warnings);
1450         }
1451
1452         {
1453             let matches = getopts(&[
1454                 "-Adead_code".to_string()
1455             ], &optgroups()).unwrap();
1456             let registry = diagnostics::registry::Registry::new(&[]);
1457             let sessopts = build_session_options(&matches);
1458             let sess = build_session(sessopts, None, registry,
1459                                      Rc::new(DummyCrateStore));
1460             assert!(sess.diagnostic().can_emit_warnings);
1461         }
1462     }
1463 }