src/config.rs

   1 // Copyright 2015 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 extern crate toml;
  12
  13 use std::{env, fs};
  14 use std::cell::Cell;
  15 use std::default::Default;
  16 use std::fs::File;
  17 use std::io::{Error, ErrorKind, Read};
  18 use std::path::{Path, PathBuf};
  19
  20 use file_lines::FileLines;
  21 use lists::{ListTactic, SeparatorPlace, SeparatorTactic};
  22 use Summary;
  23
  24
  25 macro_rules! is_nightly_channel {
  26     () => {
  27     env::var("CFG_RELEASE_CHANNEL")
  28         .map(|c| c == "nightly")
  29         .unwrap_or(false)
  30     }
  31 }
  32
  33 macro_rules! configuration_option_enum{
  34     ($e:ident: $( $x:ident ),+ $(,)*) => {
  35         #[derive(Copy, Clone, Eq, PartialEq, Debug)]
  36         pub enum $e {
  37             $( $x ),+
  38         }
  39
  40         impl_enum_serialize_and_deserialize!($e, $( $x ),+);
  41     }
  42 }
  43
  44 configuration_option_enum! { NewlineStyle:
  45     Windows, // \r\n
  46     Unix, // \n
  47     Native, // \r\n in Windows, \n on other platforms
  48 }
  49
  50 configuration_option_enum! { BraceStyle:
  51     AlwaysNextLine,
  52     PreferSameLine,
  53     // Prefer same line except where there is a where clause, in which case force
  54     // the brace to the next line.
  55     SameLineWhere,
  56 }
  57
  58 configuration_option_enum! { ControlBraceStyle:
  59     // K&R style, Rust community default
  60     AlwaysSameLine,
  61     // Stroustrup style
  62     ClosingNextLine,
  63     // Allman style
  64     AlwaysNextLine,
  65 }
  66
  67 configuration_option_enum! { IndentStyle:
  68     // First line on the same line as the opening brace, all lines aligned with
  69     // the first line.
  70     Visual,
  71     // First line is on a new line and all lines align with block indent.
  72     Block,
  73 }
  74
  75 configuration_option_enum! { Density:
  76     // Fit as much on one line as possible.
  77     Compressed,
  78     // Use more lines.
  79     Tall,
  80     // Try to compress if the body is empty.
  81     CompressedIfEmpty,
  82     // Place every item on a separate line.
  83     Vertical,
  84 }
  85
  86 configuration_option_enum! { TypeDensity:
  87     // No spaces around "=" and "+"
  88     Compressed,
  89     // Spaces around " = " and " + "
  90     Wide,
  91 }
  92
  93
  94 impl Density {
  95     pub fn to_list_tactic(self) -> ListTactic {
  96         match self {
  97             Density::Compressed => ListTactic::Mixed,
  98             Density::Tall | Density::CompressedIfEmpty => ListTactic::HorizontalVertical,
  99             Density::Vertical => ListTactic::Vertical,
 100         }
 101     }
 102 }
 103
 104 configuration_option_enum! { ReportTactic:
 105     Always,
 106     Unnumbered,
 107     Never,
 108 }
 109
 110 configuration_option_enum! { WriteMode:
 111     // Backs the original file up and overwrites the original.
 112     Replace,
 113     // Overwrites original file without backup.
 114     Overwrite,
 115     // Writes the output to stdout.
 116     Display,
 117     // Writes the diff to stdout.
 118     Diff,
 119     // Displays how much of the input file was processed
 120     Coverage,
 121     // Unfancy stdout
 122     Plain,
 123     // Outputs a checkstyle XML file.
 124     Checkstyle,
 125 }
 126
 127 configuration_option_enum! { Color:
 128     // Always use color, whether it is a piped or terminal output
 129     Always,
 130     // Never use color
 131     Never,
 132     // Automatically use color, if supported by terminal
 133     Auto,
 134 }
 135
 136 #[derive(Deserialize, Serialize, Clone, Debug)]
 137 pub struct WidthHeuristics {
 138     // Maximum width of the args of a function call before falling back
 139     // to vertical formatting.
 140     pub fn_call_width: usize,
 141     // Maximum width in the body of a struct lit before falling back to
 142     // vertical formatting.
 143     pub struct_lit_width: usize,
 144     // Maximum width in the body of a struct variant before falling back
 145     // to vertical formatting.
 146     pub struct_variant_width: usize,
 147     // Maximum width of an array literal before falling back to vertical
 148     // formatting.
 149     pub array_width: usize,
 150     // Maximum length of a chain to fit on a single line.
 151     pub chain_width: usize,
 152     // Maximum line length for single line if-else expressions. A value
 153     // of zero means always break if-else expressions.
 154     pub single_line_if_else_max_width: usize,
 155 }
 156
 157 impl WidthHeuristics {
 158     // Using this WidthHeuristics means we ignore heuristics.
 159     fn null() -> WidthHeuristics {
 160         WidthHeuristics {
 161             fn_call_width: usize::max_value(),
 162             struct_lit_width: 0,
 163             struct_variant_width: 0,
 164             array_width: usize::max_value(),
 165             chain_width: usize::max_value(),
 166             single_line_if_else_max_width: 0,
 167         }
 168     }
 169 }
 170
 171 impl Default for WidthHeuristics {
 172     fn default() -> WidthHeuristics {
 173         WidthHeuristics {
 174             fn_call_width: 60,
 175             struct_lit_width: 18,
 176             struct_variant_width: 35,
 177             array_width: 60,
 178             chain_width: 60,
 179             single_line_if_else_max_width: 50,
 180         }
 181     }
 182 }
 183
 184 impl ::std::str::FromStr for WidthHeuristics {
 185     type Err = &'static str;
 186
 187     fn from_str(_: &str) -> Result<Self, Self::Err> {
 188         Err("WidthHeuristics is not parsable")
 189     }
 190 }
 191
 192 impl ::config::ConfigType for WidthHeuristics {
 193     fn doc_hint() -> String {
 194         String::new()
 195     }
 196 }
 197
 198 /// Trait for types that can be used in `Config`.
 199 pub trait ConfigType: Sized {
 200     /// Returns hint text for use in `Config::print_docs()`. For enum types, this is a
 201     /// pipe-separated list of variants; for other types it returns "<type>".
 202     fn doc_hint() -> String;
 203 }
 204
 205 impl ConfigType for bool {
 206     fn doc_hint() -> String {
 207         String::from("<boolean>")
 208     }
 209 }
 210
 211 impl ConfigType for usize {
 212     fn doc_hint() -> String {
 213         String::from("<unsigned integer>")
 214     }
 215 }
 216
 217 impl ConfigType for isize {
 218     fn doc_hint() -> String {
 219         String::from("<signed integer>")
 220     }
 221 }
 222
 223 impl ConfigType for String {
 224     fn doc_hint() -> String {
 225         String::from("<string>")
 226     }
 227 }
 228
 229 impl ConfigType for FileLines {
 230     fn doc_hint() -> String {
 231         String::from("<json>")
 232     }
 233 }
 234
 235 pub struct ConfigHelpItem {
 236     option_name: &'static str,
 237     doc_string: &'static str,
 238     variant_names: String,
 239     default: &'static str,
 240 }
 241
 242 impl ConfigHelpItem {
 243     pub fn option_name(&self) -> &'static str {
 244         self.option_name
 245     }
 246
 247     pub fn doc_string(&self) -> &'static str {
 248         self.doc_string
 249     }
 250
 251     pub fn variant_names(&self) -> &String {
 252         &self.variant_names
 253     }
 254
 255     pub fn default(&self) -> &'static str {
 256         self.default
 257     }
 258 }
 259
 260 macro_rules! create_config {
 261     ($($i:ident: $ty:ty, $def:expr, $stb:expr, $( $dstring:expr ),+ );+ $(;)*) => (
 262         #[derive(Clone)]
 263         pub struct Config {
 264             // For each config item, we store a bool indicating whether it has
 265             // been accessed and the value, and a bool whether the option was
 266             // manually initialised, or taken from the default,
 267             $($i: (Cell<bool>, bool, $ty, bool)),+
 268         }
 269
 270         // Just like the Config struct but with each property wrapped
 271         // as Option<T>. This is used to parse a rustfmt.toml that doesn't
 272         // specify all properties of `Config`.
 273         // We first parse into `PartialConfig`, then create a default `Config`
 274         // and overwrite the properties with corresponding values from `PartialConfig`.
 275         #[derive(Deserialize, Serialize, Clone)]
 276         pub struct PartialConfig {
 277             $(pub $i: Option<$ty>),+
 278         }
 279
 280         impl PartialConfig {
 281             pub fn to_toml(&self) -> Result<String, String> {
 282                 // Non-user-facing options can't be specified in TOML
 283                 let mut cloned = self.clone();
 284                 cloned.file_lines = None;
 285                 cloned.verbose = None;
 286                 cloned.width_heuristics = None;
 287
 288                 toml::to_string(&cloned)
 289                     .map_err(|e| format!("Could not output config: {}", e.to_string()))
 290             }
 291         }
 292
 293         // Macro hygiene won't allow us to make `set_$i()` methods on Config
 294         // for each item, so this struct is used to give the API to set values:
 295         // `config.get().option(false)`. It's pretty ugly. Consider replacing
 296         // with `config.set_option(false)` if we ever get a stable/usable
 297         // `concat_idents!()`.
 298         pub struct ConfigSetter<'a>(&'a mut Config);
 299
 300         impl<'a> ConfigSetter<'a> {
 301             $(
 302             pub fn $i(&mut self, value: $ty) {
 303                 (self.0).$i.2 = value;
 304                 if stringify!($i) == "use_small_heuristics" {
 305                     self.0.set_heuristics();
 306                 }
 307             }
 308             )+
 309         }
 310
 311         // Query each option, returns true if the user set the option, false if
 312         // a default was used.
 313         pub struct ConfigWasSet<'a>(&'a Config);
 314
 315         impl<'a> ConfigWasSet<'a> {
 316             $(
 317             pub fn $i(&self) -> bool {
 318                 (self.0).$i.1
 319             }
 320             )+
 321         }
 322
 323         impl Config {
 324             pub fn version_meets_requirement(&self, error_summary: &mut Summary) -> bool {
 325                 if self.was_set().required_version() {
 326                     let version = env!("CARGO_PKG_VERSION");
 327                     let required_version = self.required_version();
 328                     if version != required_version {
 329                         println!(
 330                             "Error: rustfmt version ({}) doesn't match the required version ({})",
 331                             version,
 332                             required_version,
 333                         );
 334                         error_summary.add_formatting_error();
 335                         return false;
 336                     }
 337                 }
 338
 339                 true
 340             }
 341
 342             $(
 343             pub fn $i(&self) -> $ty {
 344                 self.$i.0.set(true);
 345                 self.$i.2.clone()
 346             }
 347             )+
 348
 349             pub fn set<'a>(&'a mut self) -> ConfigSetter<'a> {
 350                 ConfigSetter(self)
 351             }
 352
 353             pub fn was_set<'a>(&'a self) -> ConfigWasSet<'a> {
 354                 ConfigWasSet(self)
 355             }
 356
 357             fn fill_from_parsed_config(mut self, parsed: PartialConfig) -> Config {
 358             $(
 359                 if let Some(val) = parsed.$i {
 360                     if self.$i.3 {
 361                         self.$i.1 = true;
 362                         self.$i.2 = val;
 363                     } else {
 364                         if is_nightly_channel!() {
 365                             self.$i.1 = true;
 366                             self.$i.2 = val;
 367                         } else {
 368                             println!("Warning: can't set some features as unstable \
 369                                     features are only available in nightly channel.");
 370                         }
 371                     }
 372                 }
 373             )+
 374                 self.set_heuristics();
 375                 self
 376             }
 377
 378             pub fn from_toml(toml: &str) -> Result<Config, String> {
 379                 let parsed: toml::Value =
 380                     toml.parse().map_err(|e| format!("Could not parse TOML: {}", e))?;
 381                 let mut err: String = String::new();
 382                 {
 383                     let table = parsed
 384                         .as_table()
 385                         .ok_or(String::from("Parsed config was not table"))?;
 386                     for key in table.keys() {
 387                         match &**key {
 388                             $(
 389                                 stringify!($i) => (),
 390                             )+
 391                                 _ => {
 392                                     let msg =
 393                                         &format!("Warning: Unknown configuration option `{}`\n",
 394                                                  key);
 395                                     err.push_str(msg)
 396                                 }
 397                         }
 398                     }
 399                 }
 400                 match parsed.try_into() {
 401                     Ok(parsed_config) =>
 402                         Ok(Config::default().fill_from_parsed_config(parsed_config)),
 403                     Err(e) => {
 404                         err.push_str("Error: Decoding config file failed:\n");
 405                         err.push_str(format!("{}\n", e).as_str());
 406                         err.push_str("Please check your config file.\n");
 407                         Err(err)
 408                     }
 409                 }
 410             }
 411
 412             pub fn used_options(&self) -> PartialConfig {
 413                 PartialConfig {
 414                     $(
 415                         $i: if self.$i.0.get() {
 416                                 Some(self.$i.2.clone())
 417                             } else {
 418                                 None
 419                             },
 420                     )+
 421                 }
 422             }
 423
 424             pub fn all_options(&self) -> PartialConfig {
 425                 PartialConfig {
 426                     $(
 427                         $i: Some(self.$i.2.clone()),
 428                     )+
 429                 }
 430             }
 431
 432             pub fn override_value(&mut self, key: &str, val: &str)
 433             {
 434                 match key {
 435                     $(
 436                         stringify!($i) => {
 437                             self.$i.2 = val.parse::<$ty>()
 438                                 .expect(&format!("Failed to parse override for {} (\"{}\") as a {}",
 439                                                  stringify!($i),
 440                                                  val,
 441                                                  stringify!($ty)));
 442                         }
 443                     )+
 444                     _ => panic!("Unknown config key in override: {}", key)
 445                 }
 446
 447                 if key == "use_small_heuristics" {
 448                     self.set_heuristics();
 449                 }
 450             }
 451
 452             /// Construct a `Config` from the toml file specified at `file_path`.
 453             ///
 454             /// This method only looks at the provided path, for a method that
 455             /// searches parents for a `rustfmt.toml` see `from_resolved_toml_path`.
 456             ///
 457             /// Return a `Config` if the config could be read and parsed from
 458             /// the file, Error otherwise.
 459             pub fn from_toml_path(file_path: &Path) -> Result<Config, Error> {
 460                 let mut file = File::open(&file_path)?;
 461                 let mut toml = String::new();
 462                 file.read_to_string(&mut toml)?;
 463                 Config::from_toml(&toml).map_err(|err| Error::new(ErrorKind::InvalidData, err))
 464             }
 465
 466             /// Resolve the config for input in `dir`.
 467             ///
 468             /// Searches for `rustfmt.toml` beginning with `dir`, and
 469             /// recursively checking parents of `dir` if no config file is found.
 470             /// If no config file exists in `dir` or in any parent, a
 471             /// default `Config` will be returned (and the returned path will be empty).
 472             ///
 473             /// Returns the `Config` to use, and the path of the project file if there was
 474             /// one.
 475             pub fn from_resolved_toml_path(dir: &Path) -> Result<(Config, Option<PathBuf>), Error> {
 476
 477                 /// Try to find a project file in the given directory and its parents.
 478                 /// Returns the path of a the nearest project file if one exists,
 479                 /// or `None` if no project file was found.
 480                 fn resolve_project_file(dir: &Path) -> Result<Option<PathBuf>, Error> {
 481                     let mut current = if dir.is_relative() {
 482                         env::current_dir()?.join(dir)
 483                     } else {
 484                         dir.to_path_buf()
 485                     };
 486
 487                     current = fs::canonicalize(current)?;
 488
 489                     loop {
 490                         match get_toml_path(&current) {
 491                             Ok(Some(path)) => return Ok(Some(path)),
 492                             Err(e) => return Err(e),
 493                             _ => ()
 494                         }
 495
 496                         // If the current directory has no parent, we're done searching.
 497                         if !current.pop() {
 498                             return Ok(None);
 499                         }
 500                     }
 501                 }
 502
 503                 match resolve_project_file(dir)? {
 504                     None => Ok((Config::default(), None)),
 505                     Some(path) => Config::from_toml_path(&path).map(|config| (config, Some(path))),
 506                 }
 507             }
 508
 509
 510             pub fn print_docs() {
 511                 use std::cmp;
 512                 let max = 0;
 513                 $( let max = cmp::max(max, stringify!($i).len()+1); )+
 514                 let mut space_str = String::with_capacity(max);
 515                 for _ in 0..max {
 516                     space_str.push(' ');
 517                 }
 518                 println!("Configuration Options:");
 519                 $(
 520                     let name_raw = stringify!($i);
 521                     let mut name_out = String::with_capacity(max);
 522                     for _ in name_raw.len()..max-1 {
 523                         name_out.push(' ')
 524                     }
 525                     name_out.push_str(name_raw);
 526                     name_out.push(' ');
 527                     println!("{}{} Default: {:?}",
 528                              name_out,
 529                              <$ty>::doc_hint(),
 530                              $def);
 531                     $(
 532                         println!("{}{}", space_str, $dstring);
 533                     )+
 534                     println!();
 535                 )+
 536             }
 537
 538             fn set_heuristics(&mut self) {
 539                 if self.use_small_heuristics.2 {
 540                     self.set().width_heuristics(WidthHeuristics::default());
 541                 } else {
 542                     self.set().width_heuristics(WidthHeuristics::null());
 543                 }
 544             }
 545         }
 546
 547         // Template for the default configuration
 548         impl Default for Config {
 549             fn default() -> Config {
 550                 Config {
 551                     $(
 552                         $i: (Cell::new(false), false, $def, $stb),
 553                     )+
 554                 }
 555             }
 556         }
 557     )
 558 }
 559
 560 /// Check for the presence of known config file names (`rustfmt.toml, `.rustfmt.toml`) in `dir`
 561 ///
 562 /// Return the path if a config file exists, empty if no file exists, and Error for IO errors
 563 pub fn get_toml_path(dir: &Path) -> Result<Option<PathBuf>, Error> {
 564     const CONFIG_FILE_NAMES: [&str; 2] = [".rustfmt.toml", "rustfmt.toml"];
 565     for config_file_name in &CONFIG_FILE_NAMES {
 566         let config_file = dir.join(config_file_name);
 567         match fs::metadata(&config_file) {
 568             // Only return if it's a file to handle the unlikely situation of a directory named
 569             // `rustfmt.toml`.
 570             Ok(ref md) if md.is_file() => return Ok(Some(config_file)),
 571             // Return the error if it's something other than `NotFound`; otherwise we didn't
 572             // find the project file yet, and continue searching.
 573             Err(e) => if e.kind() != ErrorKind::NotFound {
 574                 return Err(e);
 575             },
 576             _ => {}
 577         }
 578     }
 579     Ok(None)
 580 }
 581
 582
 583
 584 create_config! {
 585     // Fundamental stuff
 586     max_width: usize, 100, true, "Maximum width of each line";
 587     hard_tabs: bool, false, true, "Use tab characters for indentation, spaces for alignment";
 588     tab_spaces: usize, 4, true, "Number of spaces per tab";
 589     newline_style: NewlineStyle, NewlineStyle::Unix, true, "Unix or Windows line endings";
 590     indent_style: IndentStyle, IndentStyle::Block, false, "How do we indent expressions or items.";
 591     use_small_heuristics: bool, true, false, "Whether to use different formatting for items and\
 592         expressions if they satisfy a heuristic notion of 'small'.";
 593
 594     // strings and comments
 595     format_strings: bool, false, false, "Format string literals where necessary";
 596     wrap_comments: bool, false, true, "Break comments to fit on the line";
 597     comment_width: usize, 80, false,
 598         "Maximum length of comments. No effect unless wrap_comments = true";
 599     normalize_comments: bool, false, true, "Convert /* */ comments to // comments where possible";
 600
 601     // Single line expressions and items.
 602     struct_lit_single_line: bool, true, false,
 603         "Put small struct literals on a single line";
 604     impl_empty_single_line: bool, true, false, "Put empty-body implementations on a single line";
 605     fn_empty_single_line: bool, true, false, "Put empty-body functions on a single line";
 606     fn_single_line: bool, false, false, "Put single-expression functions on a single line";
 607     where_single_line: bool, false, false, "To force single line where layout";
 608
 609     // Imports
 610     imports_indent: IndentStyle, IndentStyle::Visual, false, "Indent of imports";
 611     imports_layout: ListTactic, ListTactic::Mixed, false, "Item layout inside a import block";
 612
 613     // Ordering
 614     reorder_extern_crates: bool, true, false, "Reorder extern crate statements alphabetically";
 615     reorder_extern_crates_in_group: bool, true, false, "Reorder extern crate statements in group";
 616     reorder_imports: bool, false, false, "Reorder import statements alphabetically";
 617     reorder_imports_in_group: bool, false, false, "Reorder import statements in group";
 618     reorder_imported_names: bool, true, false,
 619         "Reorder lists of names in import statements alphabetically";
 620
 621     // Spaces around punctuation
 622     binop_separator: SeparatorPlace, SeparatorPlace::Front, false,
 623         "Where to put a binary operator when a binary expression goes multiline.";
 624     type_punctuation_density: TypeDensity, TypeDensity::Wide, false,
 625         "Determines if '+' or '=' are wrapped in spaces in the punctuation of types";
 626     space_before_colon: bool, false, false, "Leave a space before the colon";
 627     space_after_colon: bool, true, false, "Leave a space after the colon";
 628     spaces_around_ranges: bool, false, false, "Put spaces around the  .. and ... range operators";
 629     spaces_within_parens_and_brackets: bool, false, false,
 630         "Put spaces within non-empty parentheses or brackets";
 631
 632     // Misc.
 633     combine_control_expr: bool, true, false, "Combine control expressions with function calls.";
 634     struct_field_align_threshold: usize, 0, false, "Align struct fields if their diffs fits within \
 635                                              threshold.";
 636     remove_blank_lines_at_start_or_end_of_block: bool, true, false,
 637         "Remove blank lines at start or end of a block";
 638     same_line_attributes: bool, true, false,
 639         "Try to put attributes on the same line as fields and variants.";
 640     match_arm_blocks: bool, true, false, "Wrap the body of arms in blocks when it does not fit on \
 641         the same line with the pattern of arms";
 642     force_multiline_blocks: bool, false, false,
 643         "Force multiline closure bodies and match arms to be wrapped in a block";
 644     fn_args_density: Density, Density::Tall, false, "Argument density in functions";
 645     brace_style: BraceStyle, BraceStyle::SameLineWhere, false, "Brace style for items";
 646     control_brace_style: ControlBraceStyle, ControlBraceStyle::AlwaysSameLine, false,
 647         "Brace style for control flow constructs";
 648     trailing_comma: SeparatorTactic, SeparatorTactic::Vertical, false,
 649         "How to handle trailing commas for lists";
 650     trailing_semicolon: bool, true, false,
 651         "Add trailing semicolon after break, continue and return";
 652     match_block_trailing_comma: bool, false, false,
 653         "Put a trailing comma after a block based match arm (non-block arms are not affected)";
 654
 655     // Options that can change the source code beyond whitespace/blocks (somewhat linty things)
 656     merge_derives: bool, true, true, "Merge multiple `#[derive(...)]` into a single one";
 657     use_try_shorthand: bool, false, false, "Replace uses of the try! macro by the ? shorthand";
 658     condense_wildcard_suffixes: bool, false, false, "Replace strings of _ wildcards by a single .. \
 659                                               in tuple patterns";
 660     force_explicit_abi: bool, true, true, "Always print the abi for extern items";
 661
 662     // Control options (changes the operation of rustfmt, rather than the formatting)
 663     write_mode: WriteMode, WriteMode::Overwrite, false,
 664         "What Write Mode to use when none is supplied: \
 665          Replace, Overwrite, Display, Plain, Diff, Coverage";
 666     color: Color, Color::Auto, false,
 667         "What Color option to use when none is supplied: Always, Never, Auto";
 668     required_version: String, env!("CARGO_PKG_VERSION").to_owned(), false,
 669         "Require a specific version of rustfmt.";
 670     unstable_features: bool, false, true,
 671             "Enables unstable features. Only available on nightly channel";
 672     disable_all_formatting: bool, false, false, "Don't reformat anything";
 673     skip_children: bool, false, false, "Don't reformat out of line modules";
 674     error_on_line_overflow: bool, true, false, "Error if unable to get all lines within max_width";
 675     error_on_line_overflow_comments: bool, true, false,
 676         "Error if unable to get comments within max_width";
 677     report_todo: ReportTactic, ReportTactic::Never, false,
 678         "Report all, none or unnumbered occurrences of TODO in source file comments";
 679     report_fixme: ReportTactic, ReportTactic::Never, false,
 680         "Report all, none or unnumbered occurrences of FIXME in source file comments";
 681
 682     // Not user-facing.
 683     verbose: bool, false, false, "Use verbose output";
 684     file_lines: FileLines, FileLines::all(), false,
 685         "Lines to format; this is not supported in rustfmt.toml, and can only be specified \
 686          via the --file-lines option";
 687     width_heuristics: WidthHeuristics, WidthHeuristics::default(), false,
 688         "'small' heuristic values";
 689 }
 690
 691 #[cfg(test)]
 692 mod test {
 693     use super::Config;
 694
 695     #[test]
 696     fn test_config_set() {
 697         let mut config = Config::default();
 698         config.set().verbose(false);
 699         assert_eq!(config.verbose(), false);
 700         config.set().verbose(true);
 701         assert_eq!(config.verbose(), true);
 702     }
 703
 704     #[test]
 705     fn test_config_used_to_toml() {
 706         let config = Config::default();
 707
 708         let merge_derives = config.merge_derives();
 709         let skip_children = config.skip_children();
 710
 711         let used_options = config.used_options();
 712         let toml = used_options.to_toml().unwrap();
 713         assert_eq!(
 714             toml,
 715             format!(
 716                 "merge_derives = {}\nskip_children = {}\n",
 717                 merge_derives,
 718                 skip_children,
 719             )
 720         );
 721     }
 722
 723     #[test]
 724     fn test_was_set() {
 725         let config = Config::from_toml("hard_tabs = true").unwrap();
 726
 727         assert_eq!(config.was_set().hard_tabs(), true);
 728         assert_eq!(config.was_set().verbose(), false);
 729     }
 730
 731     // FIXME(#2183) these tests cannot be run in parallel because they use env vars
 732     // #[test]
 733     // fn test_as_not_nightly_channel() {
 734     //     let mut config = Config::default();
 735     //     assert_eq!(config.was_set().unstable_features(), false);
 736     //     config.set().unstable_features(true);
 737     //     assert_eq!(config.was_set().unstable_features(), false);
 738     // }
 739
 740     // #[test]
 741     // fn test_as_nightly_channel() {
 742     //     let v = ::std::env::var("CFG_RELEASE_CHANNEL").unwrap_or(String::from(""));
 743     //     ::std::env::set_var("CFG_RELEASE_CHANNEL", "nightly");
 744     //     let mut config = Config::default();
 745     //     config.set().unstable_features(true);
 746     //     assert_eq!(config.was_set().unstable_features(), false);
 747     //     config.set().unstable_features(true);
 748     //     assert_eq!(config.unstable_features(), true);
 749     //     ::std::env::set_var("CFG_RELEASE_CHANNEL", v);
 750     // }
 751
 752     // #[test]
 753     // fn test_unstable_from_toml() {
 754     //     let mut config = Config::from_toml("unstable_features = true").unwrap();
 755     //     assert_eq!(config.was_set().unstable_features(), false);
 756     //     let v = ::std::env::var("CFG_RELEASE_CHANNEL").unwrap_or(String::from(""));
 757     //     ::std::env::set_var("CFG_RELEASE_CHANNEL", "nightly");
 758     //     config = Config::from_toml("unstable_features = true").unwrap();
 759     //     assert_eq!(config.was_set().unstable_features(), true);
 760     //     assert_eq!(config.unstable_features(), true);
 761     //     ::std::env::set_var("CFG_RELEASE_CHANNEL", v);
 762     // }
 763 }