src/tools/rustfmt/src/config/options.rs

   1 use std::collections::{hash_set, HashSet};
   2 use std::fmt;
   3 use std::path::{Path, PathBuf};
   4 use std::str::FromStr;
   5
   6 use itertools::Itertools;
   7 use rustfmt_config_proc_macro::config_type;
   8 use serde::de::{SeqAccess, Visitor};
   9 use serde::ser::SerializeSeq;
  10 use serde::{Deserialize, Deserializer, Serialize, Serializer};
  11
  12 use crate::config::lists::*;
  13 use crate::config::Config;
  14
  15 #[config_type]
  16 pub enum NewlineStyle {
  17     /// Auto-detect based on the raw source input.
  18     Auto,
  19     /// Force CRLF (`\r\n`).
  20     Windows,
  21     /// Force CR (`\n).
  22     Unix,
  23     /// `\r\n` in Windows, `\n` on other platforms.
  24     Native,
  25 }
  26
  27 #[config_type]
  28 /// Where to put the opening brace of items (`fn`, `impl`, etc.).
  29 pub enum BraceStyle {
  30     /// Put the opening brace on the next line.
  31     AlwaysNextLine,
  32     /// Put the opening brace on the same line, if possible.
  33     PreferSameLine,
  34     /// Prefer the same line except where there is a where-clause, in which
  35     /// case force the brace to be put on the next line.
  36     SameLineWhere,
  37 }
  38
  39 #[config_type]
  40 /// Where to put the opening brace of conditional expressions (`if`, `match`, etc.).
  41 pub enum ControlBraceStyle {
  42     /// K&R style, Rust community default
  43     AlwaysSameLine,
  44     /// Stroustrup style
  45     ClosingNextLine,
  46     /// Allman style
  47     AlwaysNextLine,
  48 }
  49
  50 #[config_type]
  51 /// How to indent.
  52 pub enum IndentStyle {
  53     /// First line on the same line as the opening brace, all lines aligned with
  54     /// the first line.
  55     Visual,
  56     /// First line is on a new line and all lines align with **block** indent.
  57     Block,
  58 }
  59
  60 #[config_type]
  61 /// How to place a list-like items.
  62 /// FIXME: Issue-3581: this should be renamed to ItemsLayout when publishing 2.0
  63 pub enum Density {
  64     /// Fit as much on one line as possible.
  65     Compressed,
  66     /// Items are placed horizontally if sufficient space, vertically otherwise.
  67     Tall,
  68     /// Place every item on a separate line.
  69     Vertical,
  70 }
  71
  72 #[config_type]
  73 /// Spacing around type combinators.
  74 pub enum TypeDensity {
  75     /// No spaces around "=" and "+"
  76     Compressed,
  77     /// Spaces around " = " and " + "
  78     Wide,
  79 }
  80
  81 #[config_type]
  82 /// Heuristic settings that can be used to simply
  83 /// the configuration of the granular width configurations
  84 /// like `struct_lit_width`, `array_width`, etc.
  85 pub enum Heuristics {
  86     /// Turn off any heuristics
  87     Off,
  88     /// Turn on max heuristics
  89     Max,
  90     /// Use scaled values based on the value of `max_width`
  91     Default,
  92 }
  93
  94 impl Density {
  95     pub fn to_list_tactic(self, len: usize) -> ListTactic {
  96         match self {
  97             Density::Compressed => ListTactic::Mixed,
  98             Density::Tall => ListTactic::HorizontalVertical,
  99             Density::Vertical if len == 1 => ListTactic::Horizontal,
 100             Density::Vertical => ListTactic::Vertical,
 101         }
 102     }
 103 }
 104
 105 #[config_type]
 106 /// Configuration for import groups, i.e. sets of imports separated by newlines.
 107 pub enum GroupImportsTactic {
 108     /// Keep groups as they are.
 109     Preserve,
 110     /// Discard existing groups, and create new groups for
 111     ///  1. `std` / `core` / `alloc` imports
 112     ///  2. other imports
 113     ///  3. `self` / `crate` / `super` imports
 114     StdExternalCrate,
 115     /// Discard existing groups, and create a single group for everything
 116     One,
 117 }
 118
 119 #[config_type]
 120 /// How to merge imports.
 121 pub enum ImportGranularity {
 122     /// Do not merge imports.
 123     Preserve,
 124     /// Use one `use` statement per crate.
 125     Crate,
 126     /// Use one `use` statement per module.
 127     Module,
 128     /// Use one `use` statement per imported item.
 129     Item,
 130     /// Use one `use` statement including all items.
 131     One,
 132 }
 133
 134 /// Controls how rustfmt should handle case in hexadecimal literals.
 135 #[config_type]
 136 pub enum HexLiteralCase {
 137     /// Leave the literal as-is
 138     Preserve,
 139     /// Ensure all literals use uppercase lettering
 140     Upper,
 141     /// Ensure all literals use lowercase lettering
 142     Lower,
 143 }
 144
 145 #[config_type]
 146 pub enum ReportTactic {
 147     Always,
 148     Unnumbered,
 149     Never,
 150 }
 151
 152 /// What Rustfmt should emit. Mostly corresponds to the `--emit` command line
 153 /// option.
 154 #[config_type]
 155 pub enum EmitMode {
 156     /// Emits to files.
 157     Files,
 158     /// Writes the output to stdout.
 159     Stdout,
 160     /// Displays how much of the input file was processed
 161     Coverage,
 162     /// Unfancy stdout
 163     Checkstyle,
 164     /// Writes the resulting diffs in a JSON format. Returns an empty array
 165     /// `[]` if there were no diffs.
 166     Json,
 167     /// Output the changed lines (for internal value only)
 168     ModifiedLines,
 169     /// Checks if a diff can be generated. If so, rustfmt outputs a diff and
 170     /// quits with exit code 1.
 171     /// This option is designed to be run in CI where a non-zero exit signifies
 172     /// non-standard code formatting. Used for `--check`.
 173     Diff,
 174 }
 175
 176 /// Client-preference for coloured output.
 177 #[config_type]
 178 pub enum Color {
 179     /// Always use color, whether it is a piped or terminal output
 180     Always,
 181     /// Never use color
 182     Never,
 183     /// Automatically use color, if supported by terminal
 184     Auto,
 185 }
 186
 187 #[config_type]
 188 /// rustfmt format style version.
 189 pub enum Version {
 190     /// 1.x.y. When specified, rustfmt will format in the same style as 1.0.0.
 191     One,
 192     /// 2.x.y. When specified, rustfmt will format in the the latest style.
 193     Two,
 194 }
 195
 196 impl Color {
 197     /// Whether we should use a coloured terminal.
 198     pub fn use_colored_tty(self) -> bool {
 199         match self {
 200             Color::Always | Color::Auto => true,
 201             Color::Never => false,
 202         }
 203     }
 204 }
 205
 206 /// How chatty should Rustfmt be?
 207 #[config_type]
 208 pub enum Verbosity {
 209     /// Emit more.
 210     Verbose,
 211     /// Default.
 212     Normal,
 213     /// Emit as little as possible.
 214     Quiet,
 215 }
 216
 217 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
 218 pub struct WidthHeuristics {
 219     // Maximum width of the args of a function call before falling back
 220     // to vertical formatting.
 221     pub(crate) fn_call_width: usize,
 222     // Maximum width of the args of a function-like attributes before falling
 223     // back to vertical formatting.
 224     pub(crate) attr_fn_like_width: usize,
 225     // Maximum width in the body of a struct lit before falling back to
 226     // vertical formatting.
 227     pub(crate) struct_lit_width: usize,
 228     // Maximum width in the body of a struct variant before falling back
 229     // to vertical formatting.
 230     pub(crate) struct_variant_width: usize,
 231     // Maximum width of an array literal before falling back to vertical
 232     // formatting.
 233     pub(crate) array_width: usize,
 234     // Maximum length of a chain to fit on a single line.
 235     pub(crate) chain_width: usize,
 236     // Maximum line length for single line if-else expressions. A value
 237     // of zero means always break if-else expressions.
 238     pub(crate) single_line_if_else_max_width: usize,
 239 }
 240
 241 impl fmt::Display for WidthHeuristics {
 242     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 243         write!(f, "{:?}", self)
 244     }
 245 }
 246
 247 impl WidthHeuristics {
 248     // Using this WidthHeuristics means we ignore heuristics.
 249     pub fn null() -> WidthHeuristics {
 250         WidthHeuristics {
 251             fn_call_width: usize::max_value(),
 252             attr_fn_like_width: usize::max_value(),
 253             struct_lit_width: 0,
 254             struct_variant_width: 0,
 255             array_width: usize::max_value(),
 256             chain_width: usize::max_value(),
 257             single_line_if_else_max_width: 0,
 258         }
 259     }
 260
 261     pub fn set(max_width: usize) -> WidthHeuristics {
 262         WidthHeuristics {
 263             fn_call_width: max_width,
 264             attr_fn_like_width: max_width,
 265             struct_lit_width: max_width,
 266             struct_variant_width: max_width,
 267             array_width: max_width,
 268             chain_width: max_width,
 269             single_line_if_else_max_width: max_width,
 270         }
 271     }
 272
 273     // scale the default WidthHeuristics according to max_width
 274     pub fn scaled(max_width: usize) -> WidthHeuristics {
 275         const DEFAULT_MAX_WIDTH: usize = 100;
 276         let max_width_ratio = if max_width > DEFAULT_MAX_WIDTH {
 277             let ratio = max_width as f32 / DEFAULT_MAX_WIDTH as f32;
 278             // round to the closest 0.1
 279             (ratio * 10.0).round() / 10.0
 280         } else {
 281             1.0
 282         };
 283         WidthHeuristics {
 284             fn_call_width: (60.0 * max_width_ratio).round() as usize,
 285             attr_fn_like_width: (70.0 * max_width_ratio).round() as usize,
 286             struct_lit_width: (18.0 * max_width_ratio).round() as usize,
 287             struct_variant_width: (35.0 * max_width_ratio).round() as usize,
 288             array_width: (60.0 * max_width_ratio).round() as usize,
 289             chain_width: (60.0 * max_width_ratio).round() as usize,
 290             single_line_if_else_max_width: (50.0 * max_width_ratio).round() as usize,
 291         }
 292     }
 293 }
 294
 295 impl ::std::str::FromStr for WidthHeuristics {
 296     type Err = &'static str;
 297
 298     fn from_str(_: &str) -> Result<Self, Self::Err> {
 299         Err("WidthHeuristics is not parsable")
 300     }
 301 }
 302
 303 impl Default for EmitMode {
 304     fn default() -> EmitMode {
 305         EmitMode::Files
 306     }
 307 }
 308
 309 /// A set of directories, files and modules that rustfmt should ignore.
 310 #[derive(Default, Clone, Debug, PartialEq)]
 311 pub struct IgnoreList {
 312     /// A set of path specified in rustfmt.toml.
 313     path_set: HashSet<PathBuf>,
 314     /// A path to rustfmt.toml.
 315     rustfmt_toml_path: PathBuf,
 316 }
 317
 318 impl fmt::Display for IgnoreList {
 319     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 320         write!(
 321             f,
 322             "[{}]",
 323             self.path_set
 324                 .iter()
 325                 .format_with(", ", |path, f| f(&format_args!(
 326                     "{}",
 327                     path.to_string_lossy()
 328                 )))
 329         )
 330     }
 331 }
 332
 333 impl Serialize for IgnoreList {
 334     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 335     where
 336         S: Serializer,
 337     {
 338         let mut seq = serializer.serialize_seq(Some(self.path_set.len()))?;
 339         for e in &self.path_set {
 340             seq.serialize_element(e)?;
 341         }
 342         seq.end()
 343     }
 344 }
 345
 346 impl<'de> Deserialize<'de> for IgnoreList {
 347     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 348     where
 349         D: Deserializer<'de>,
 350     {
 351         struct HashSetVisitor;
 352         impl<'v> Visitor<'v> for HashSetVisitor {
 353             type Value = HashSet<PathBuf>;
 354
 355             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 356                 formatter.write_str("a sequence of path")
 357             }
 358
 359             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 360             where
 361                 A: SeqAccess<'v>,
 362             {
 363                 let mut path_set = HashSet::new();
 364                 while let Some(elem) = seq.next_element()? {
 365                     path_set.insert(elem);
 366                 }
 367                 Ok(path_set)
 368             }
 369         }
 370         Ok(IgnoreList {
 371             path_set: deserializer.deserialize_seq(HashSetVisitor)?,
 372             rustfmt_toml_path: PathBuf::new(),
 373         })
 374     }
 375 }
 376
 377 impl<'a> IntoIterator for &'a IgnoreList {
 378     type Item = &'a PathBuf;
 379     type IntoIter = hash_set::Iter<'a, PathBuf>;
 380
 381     fn into_iter(self) -> Self::IntoIter {
 382         self.path_set.iter()
 383     }
 384 }
 385
 386 impl IgnoreList {
 387     pub fn add_prefix(&mut self, dir: &Path) {
 388         self.rustfmt_toml_path = dir.to_path_buf();
 389     }
 390
 391     pub fn rustfmt_toml_path(&self) -> &Path {
 392         &self.rustfmt_toml_path
 393     }
 394 }
 395
 396 impl FromStr for IgnoreList {
 397     type Err = &'static str;
 398
 399     fn from_str(_: &str) -> Result<Self, Self::Err> {
 400         Err("IgnoreList is not parsable")
 401     }
 402 }
 403
 404 /// Maps client-supplied options to Rustfmt's internals, mostly overriding
 405 /// values in a config with values from the command line.
 406 pub trait CliOptions {
 407     fn apply_to(self, config: &mut Config);
 408     fn config_path(&self) -> Option<&Path>;
 409 }
 410
 411 /// The edition of the syntax and semntics of code (RFC 2052).
 412 #[config_type]
 413 pub enum Edition {
 414     #[value = "2015"]
 415     #[doc_hint = "2015"]
 416     /// Edition 2015.
 417     Edition2015,
 418     #[value = "2018"]
 419     #[doc_hint = "2018"]
 420     /// Edition 2018.
 421     Edition2018,
 422     #[value = "2021"]
 423     #[doc_hint = "2021"]
 424     /// Edition 2021.
 425     Edition2021,
 426     #[value = "2024"]
 427     #[doc_hint = "2024"]
 428     /// Edition 2024.
 429     Edition2024,
 430 }
 431
 432 impl Default for Edition {
 433     fn default() -> Edition {
 434         Edition::Edition2015
 435     }
 436 }
 437
 438 impl From<Edition> for rustc_span::edition::Edition {
 439     fn from(edition: Edition) -> Self {
 440         match edition {
 441             Edition::Edition2015 => Self::Edition2015,
 442             Edition::Edition2018 => Self::Edition2018,
 443             Edition::Edition2021 => Self::Edition2021,
 444             Edition::Edition2024 => Self::Edition2024,
 445         }
 446     }
 447 }
 448
 449 impl PartialOrd for Edition {
 450     fn partial_cmp(&self, other: &Edition) -> Option<std::cmp::Ordering> {
 451         rustc_span::edition::Edition::partial_cmp(&(*self).into(), &(*other).into())
 452     }
 453 }
 454
 455 /// Controls how rustfmt should handle leading pipes on match arms.
 456 #[config_type]
 457 pub enum MatchArmLeadingPipe {
 458     /// Place leading pipes on all match arms
 459     Always,
 460     /// Never emit leading pipes on match arms
 461     Never,
 462     /// Preserve any existing leading pipes
 463     Preserve,
 464 }