src/tools/clippy/clippy_lints/src/utils/conf.rs

   1 //! Read configurations files.
   2
   3 #![deny(clippy::missing_docs_in_private_items)]
   4
   5 use lazy_static::lazy_static;
   6 use rustc_ast::ast::{LitKind, MetaItemKind, NestedMetaItem};
   7 use rustc_span::source_map;
   8 use source_map::Span;
   9 use std::path::{Path, PathBuf};
  10 use std::sync::Mutex;
  11 use std::{env, fmt, fs, io};
  12
  13 /// Gets the configuration file from arguments.
  14 pub fn file_from_args(args: &[NestedMetaItem]) -> Result<Option<PathBuf>, (&'static str, Span)> {
  15     for arg in args.iter().filter_map(NestedMetaItem::meta_item) {
  16         if arg.check_name(sym!(conf_file)) {
  17             return match arg.kind {
  18                 MetaItemKind::Word | MetaItemKind::List(_) => Err(("`conf_file` must be a named value", arg.span)),
  19                 MetaItemKind::NameValue(ref value) => {
  20                     if let LitKind::Str(ref file, _) = value.kind {
  21                         Ok(Some(file.to_string().into()))
  22                     } else {
  23                         Err(("`conf_file` value must be a string", value.span))
  24                     }
  25                 },
  26             };
  27         }
  28     }
  29
  30     Ok(None)
  31 }
  32
  33 /// Error from reading a configuration file.
  34 #[derive(Debug)]
  35 pub enum Error {
  36     /// An I/O error.
  37     Io(io::Error),
  38     /// Not valid toml or doesn't fit the expected config format
  39     Toml(String),
  40 }
  41
  42 impl fmt::Display for Error {
  43     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  44         match self {
  45             Self::Io(err) => err.fmt(f),
  46             Self::Toml(err) => err.fmt(f),
  47         }
  48     }
  49 }
  50
  51 impl From<io::Error> for Error {
  52     fn from(e: io::Error) -> Self {
  53         Self::Io(e)
  54     }
  55 }
  56
  57 lazy_static! {
  58     static ref ERRORS: Mutex<Vec<Error>> = Mutex::new(Vec::new());
  59 }
  60
  61 macro_rules! define_Conf {
  62     ($(#[$doc:meta] ($config:ident, $config_str:literal: $Ty:ty, $default:expr),)+) => {
  63         mod helpers {
  64             use serde::Deserialize;
  65             /// Type used to store lint configuration.
  66             #[derive(Deserialize)]
  67             #[serde(rename_all = "kebab-case", deny_unknown_fields)]
  68             pub struct Conf {
  69                 $(
  70                     #[$doc]
  71                     #[serde(default = $config_str)]
  72                     #[serde(with = $config_str)]
  73                     pub $config: $Ty,
  74                 )+
  75                 #[allow(dead_code)]
  76                 #[serde(default)]
  77                 third_party: Option<::toml::Value>,
  78             }
  79
  80             $(
  81                 mod $config {
  82                     use serde::Deserialize;
  83                     pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<$Ty, D::Error> {
  84                         use super::super::{ERRORS, Error};
  85                         Ok(
  86                             <$Ty>::deserialize(deserializer).unwrap_or_else(|e| {
  87                                 ERRORS
  88                                     .lock()
  89                                     .expect("no threading here")
  90                                     .push(Error::Toml(e.to_string()));
  91                                 super::$config()
  92                             })
  93                         )
  94                     }
  95                 }
  96
  97                 #[must_use]
  98                 fn $config() -> $Ty {
  99                     let x = $default;
 100                     x
 101                 }
 102             )+
 103         }
 104     };
 105 }
 106
 107 pub use self::helpers::Conf;
 108 define_Conf! {
 109     /// Lint: BLACKLISTED_NAME. The list of blacklisted names to lint about
 110     (blacklisted_names, "blacklisted_names": Vec<String>, ["foo", "bar", "baz", "quux"].iter().map(ToString::to_string).collect()),
 111     /// Lint: COGNITIVE_COMPLEXITY. The maximum cognitive complexity a function can have
 112     (cognitive_complexity_threshold, "cognitive_complexity_threshold": u64, 25),
 113     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY. Use the Cognitive Complexity lint instead.
 114     (cyclomatic_complexity_threshold, "cyclomatic_complexity_threshold": Option<u64>, None),
 115     /// Lint: DOC_MARKDOWN. The list of words this lint should not consider as identifiers needing ticks
 116     (doc_valid_idents, "doc_valid_idents": Vec<String>, [
 117         "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
 118         "DirectX",
 119         "ECMAScript",
 120         "GPLv2", "GPLv3",
 121         "GitHub", "GitLab",
 122         "IPv4", "IPv6",
 123         "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
 124         "NaN", "NaNs",
 125         "OAuth",
 126         "OCaml",
 127         "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap",
 128         "TensorFlow",
 129         "TrueType",
 130         "iOS", "macOS",
 131         "TeX", "LaTeX", "BibTeX", "BibLaTeX",
 132         "MinGW",
 133         "CamelCase",
 134     ].iter().map(ToString::to_string).collect()),
 135     /// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
 136     (too_many_arguments_threshold, "too_many_arguments_threshold": u64, 7),
 137     /// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
 138     (type_complexity_threshold, "type_complexity_threshold": u64, 250),
 139     /// Lint: MANY_SINGLE_CHAR_NAMES. The maximum number of single char bindings a scope may have
 140     (single_char_binding_names_threshold, "single_char_binding_names_threshold": u64, 4),
 141     /// Lint: BOXED_LOCAL. The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
 142     (too_large_for_stack, "too_large_for_stack": u64, 200),
 143     /// Lint: ENUM_VARIANT_NAMES. The minimum number of enum variants for the lints about variant names to trigger
 144     (enum_variant_name_threshold, "enum_variant_name_threshold": u64, 3),
 145     /// Lint: LARGE_ENUM_VARIANT. The maximum size of a enum's variant to avoid box suggestion
 146     (enum_variant_size_threshold, "enum_variant_size_threshold": u64, 200),
 147     /// Lint: VERBOSE_BIT_MASK. The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
 148     (verbose_bit_mask_threshold, "verbose_bit_mask_threshold": u64, 1),
 149     /// Lint: DECIMAL_LITERAL_REPRESENTATION. The lower bound for linting decimal literals
 150     (literal_representation_threshold, "literal_representation_threshold": u64, 16384),
 151     /// Lint: TRIVIALLY_COPY_PASS_BY_REF. The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
 152     (trivial_copy_size_limit, "trivial_copy_size_limit": Option<u64>, None),
 153     /// Lint: TOO_MANY_LINES. The maximum number of lines a function or method can have
 154     (too_many_lines_threshold, "too_many_lines_threshold": u64, 100),
 155     /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS. The maximum allowed size for arrays on the stack
 156     (array_size_threshold, "array_size_threshold": u64, 512_000),
 157     /// Lint: VEC_BOX. The size of the boxed type in bytes, where boxing in a `Vec` is allowed
 158     (vec_box_size_threshold, "vec_box_size_threshold": u64, 4096),
 159     /// Lint: STRUCT_EXCESSIVE_BOOLS. The maximum number of bools a struct can have
 160     (max_struct_bools, "max_struct_bools": u64, 3),
 161     /// Lint: FN_PARAMS_EXCESSIVE_BOOLS. The maximum number of bools function parameters can have
 162     (max_fn_params_bools, "max_fn_params_bools": u64, 3),
 163     /// Lint: WILDCARD_IMPORTS. Whether to allow certain wildcard imports (prelude, super in tests).
 164     (warn_on_all_wildcard_imports, "warn_on_all_wildcard_imports": bool, false),
 165 }
 166
 167 impl Default for Conf {
 168     #[must_use]
 169     fn default() -> Self {
 170         toml::from_str("").expect("we never error on empty config files")
 171     }
 172 }
 173
 174 /// Search for the configuration file.
 175 pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
 176     /// Possible filename to search for.
 177     const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
 178
 179     // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
 180     // If neither of those exist, use ".".
 181     let mut current = env::var_os("CLIPPY_CONF_DIR")
 182         .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
 183         .map_or_else(|| PathBuf::from("."), PathBuf::from);
 184     loop {
 185         for config_file_name in &CONFIG_FILE_NAMES {
 186             let config_file = current.join(config_file_name);
 187             match fs::metadata(&config_file) {
 188                 // Only return if it's a file to handle the unlikely situation of a directory named
 189                 // `clippy.toml`.
 190                 Ok(ref md) if !md.is_dir() => return Ok(Some(config_file)),
 191                 // Return the error if it's something other than `NotFound`; otherwise we didn't
 192                 // find the project file yet, and continue searching.
 193                 Err(e) if e.kind() != io::ErrorKind::NotFound => return Err(e),
 194                 _ => {},
 195             }
 196         }
 197
 198         // If the current directory has no parent, we're done searching.
 199         if !current.pop() {
 200             return Ok(None);
 201         }
 202     }
 203 }
 204
 205 /// Produces a `Conf` filled with the default values and forwards the errors
 206 ///
 207 /// Used internally for convenience
 208 fn default(errors: Vec<Error>) -> (Conf, Vec<Error>) {
 209     (Conf::default(), errors)
 210 }
 211
 212 /// Read the `toml` configuration file.
 213 ///
 214 /// In case of error, the function tries to continue as much as possible.
 215 pub fn read(path: &Path) -> (Conf, Vec<Error>) {
 216     let content = match fs::read_to_string(path) {
 217         Ok(content) => content,
 218         Err(err) => return default(vec![err.into()]),
 219     };
 220
 221     assert!(ERRORS.lock().expect("no threading -> mutex always safe").is_empty());
 222     match toml::from_str(&content) {
 223         Ok(toml) => {
 224             let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
 225
 226             let toml_ref: &Conf = &toml;
 227
 228             let cyc_field: Option<u64> = toml_ref.cyclomatic_complexity_threshold;
 229
 230             if cyc_field.is_some() {
 231                 let cyc_err = "found deprecated field `cyclomatic-complexity-threshold`. Please use `cognitive-complexity-threshold` instead.".to_string();
 232                 errors.push(Error::Toml(cyc_err));
 233             }
 234
 235             (toml, errors)
 236         },
 237         Err(e) => {
 238             let mut errors = ERRORS.lock().expect("no threading -> mutex always safe").split_off(0);
 239             errors.push(Error::Toml(e.to_string()));
 240
 241             default(errors)
 242         },
 243     }
 244 }