1use crate::ClippyConfiguration;
2use crate::types::{
3 DisallowedPath, DisallowedPathWithoutReplacement, InherentImplLintScope, MacroMatcher, MatchLintBehaviour,
4 PubUnderscoreFieldsBehaviour, Rename, SourceItemOrdering, SourceItemOrderingCategory,
5 SourceItemOrderingModuleItemGroupings, SourceItemOrderingModuleItemKind, SourceItemOrderingTraitAssocItemKind,
6 SourceItemOrderingTraitAssocItemKinds, SourceItemOrderingWithinModuleItemGroupings,
7};
8use clippy_utils::msrvs::Msrv;
9use itertools::Itertools;
10use rustc_errors::Applicability;
11use rustc_session::Session;
12use rustc_span::edit_distance::edit_distance;
13use rustc_span::{BytePos, Pos, SourceFile, Span, SyntaxContext};
14use serde::de::{IgnoredAny, IntoDeserializer, MapAccess, Visitor};
15use serde::{Deserialize, Deserializer, Serialize};
16use std::collections::HashMap;
17use std::fmt::{Debug, Display, Formatter};
18use std::ops::Range;
19use std::path::PathBuf;
20use std::str::FromStr;
21use std::sync::OnceLock;
22use std::{cmp, env, fmt, fs, io};
23
24#[rustfmt::skip]
25const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
26 "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
27 "MHz", "GHz", "THz",
28 "AccessKit",
29 "CoAP", "CoreFoundation", "CoreGraphics", "CoreText",
30 "DevOps",
31 "Direct2D", "Direct3D", "DirectWrite", "DirectX",
32 "ECMAScript",
33 "GPLv2", "GPLv3",
34 "GitHub", "GitLab",
35 "IPv4", "IPv6",
36 "InfiniBand", "RoCE",
37 "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript",
38 "PowerPC", "WebAssembly",
39 "NaN", "NaNs",
40 "OAuth", "GraphQL",
41 "OCaml",
42 "OpenAL", "OpenDNS", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenTelemetry",
43 "OpenType",
44 "WebGL", "WebGL2", "WebGPU", "WebRTC", "WebSocket", "WebTransport",
45 "WebP", "OpenExr", "YCbCr", "sRGB",
46 "TensorFlow",
47 "TrueType",
48 "iOS", "macOS", "FreeBSD", "NetBSD", "OpenBSD", "NixOS",
49 "TeX", "LaTeX", "BibTeX", "BibLaTeX",
50 "MinGW",
51 "CamelCase",
52];
53const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
54const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z", "w", "n"];
55const DEFAULT_ALLOWED_PREFIXES: &[&str] = &["to", "as", "into", "from", "try_into", "try_from"];
56const DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS: &[&str] =
57 &["core::convert::From", "core::convert::TryFrom", "core::str::FromStr"];
58const DEFAULT_MODULE_ITEM_ORDERING_GROUPS: &[(&str, &[SourceItemOrderingModuleItemKind])] = {
59 #[allow(clippy::enum_glob_use)] use SourceItemOrderingModuleItemKind::*;
61 &[
62 ("modules", &[ExternCrate, Mod, ForeignMod]),
63 ("use", &[Use]),
64 ("macros", &[Macro]),
65 ("global_asm", &[GlobalAsm]),
66 ("UPPER_SNAKE_CASE", &[Static, Const]),
67 ("PascalCase", &[TyAlias, Enum, Struct, Union, Trait, TraitAlias, Impl]),
68 ("lower_snake_case", &[Fn]),
69 ]
70};
71const DEFAULT_TRAIT_ASSOC_ITEM_KINDS_ORDER: &[SourceItemOrderingTraitAssocItemKind] = {
72 #[allow(clippy::enum_glob_use)] use SourceItemOrderingTraitAssocItemKind::*;
74 &[Const, Type, Fn]
75};
76const DEFAULT_SOURCE_ITEM_ORDERING: &[SourceItemOrderingCategory] = {
77 #[allow(clippy::enum_glob_use)] use SourceItemOrderingCategory::*;
79 &[Enum, Impl, Module, Struct, Trait]
80};
81
82#[derive(Default)]
84struct TryConf {
85 conf: Conf,
86 value_spans: HashMap<String, Range<usize>>,
87 errors: Vec<ConfError>,
88 warnings: Vec<ConfError>,
89}
90
91impl TryConf {
92 fn from_toml_error(file: &SourceFile, error: &toml::de::Error) -> Self {
93 Self {
94 conf: Conf::default(),
95 value_spans: HashMap::default(),
96 errors: vec![ConfError::from_toml(file, error)],
97 warnings: vec![],
98 }
99 }
100}
101
102#[derive(Debug)]
103struct ConfError {
104 message: String,
105 suggestion: Option<Suggestion>,
106 span: Span,
107}
108
109impl ConfError {
110 fn from_toml(file: &SourceFile, error: &toml::de::Error) -> Self {
111 let span = error.span().unwrap_or(0..file.source_len.0 as usize);
112 Self::spanned(file, error.message(), None, span)
113 }
114
115 fn spanned(
116 file: &SourceFile,
117 message: impl Into<String>,
118 suggestion: Option<Suggestion>,
119 span: Range<usize>,
120 ) -> Self {
121 Self {
122 message: message.into(),
123 suggestion,
124 span: span_from_toml_range(file, span),
125 }
126 }
127}
128
129pub fn sanitize_explanation(raw_docs: &str) -> String {
131 let mut explanation = String::with_capacity(128);
133 let mut in_code = false;
134 for line in raw_docs.lines() {
135 let line = line.strip_prefix(' ').unwrap_or(line);
136
137 if let Some(lang) = line.strip_prefix("```") {
138 let tag = lang.split_once(',').map_or(lang, |(left, _)| left);
139 if !in_code && matches!(tag, "" | "rust" | "ignore" | "should_panic" | "no_run" | "compile_fail") {
140 explanation += "```rust\n";
141 } else {
142 explanation += line;
143 explanation.push('\n');
144 }
145 in_code = !in_code;
146 } else if !(in_code && line.starts_with("# ")) {
147 explanation += line;
148 explanation.push('\n');
149 }
150 }
151
152 explanation
153}
154
155macro_rules! wrap_option {
156 () => {
157 None
158 };
159 ($x:literal) => {
160 Some($x)
161 };
162}
163
164macro_rules! default_text {
165 ($value:expr) => {{
166 let mut text = String::new();
167 $value.serialize(toml::ser::ValueSerializer::new(&mut text)).unwrap();
168 text
169 }};
170 ($value:expr, $override:expr) => {
171 $override.to_string()
172 };
173}
174
175macro_rules! deserialize {
176 ($map:expr, $ty:ty, $errors:expr, $file:expr) => {{
177 let raw_value = $map.next_value::<toml::Spanned<toml::Value>>()?;
178 let value_span = raw_value.span();
179 let value = match <$ty>::deserialize(raw_value.into_inner()) {
180 Err(e) => {
181 $errors.push(ConfError::spanned(
182 $file,
183 e.to_string().replace('\n', " ").trim(),
184 None,
185 value_span,
186 ));
187 continue;
188 },
189 Ok(value) => value,
190 };
191 (value, value_span)
192 }};
193
194 ($map:expr, $ty:ty, $errors:expr, $file:expr, $replacements_allowed:expr) => {{
195 let array = $map.next_value::<Vec<toml::Spanned<toml::Value>>>()?;
196 let mut disallowed_paths_span = Range {
197 start: usize::MAX,
198 end: usize::MIN,
199 };
200 let mut disallowed_paths = Vec::new();
201 for raw_value in array {
202 let value_span = raw_value.span();
203 let mut disallowed_path = match DisallowedPath::<$replacements_allowed>::deserialize(raw_value.into_inner())
204 {
205 Err(e) => {
206 $errors.push(ConfError::spanned(
207 $file,
208 e.to_string().replace('\n', " ").trim(),
209 None,
210 value_span,
211 ));
212 continue;
213 },
214 Ok(disallowed_path) => disallowed_path,
215 };
216 disallowed_paths_span = union(&disallowed_paths_span, &value_span);
217 disallowed_path.set_span(span_from_toml_range($file, value_span));
218 disallowed_paths.push(disallowed_path);
219 }
220 (disallowed_paths, disallowed_paths_span)
221 }};
222}
223
224macro_rules! define_Conf {
225 ($(
226 $(#[doc = $doc:literal])+
227 $(#[conf_deprecated($dep:literal, $new_conf:ident)])?
228 $(#[default_text = $default_text:expr])?
229 $(#[disallowed_paths_allow_replacements = $replacements_allowed:expr])?
230 $(#[lints($($for_lints:ident),* $(,)?)])?
231 $name:ident: $ty:ty = $default:expr,
232 )*) => {
233 pub struct Conf {
235 $($(#[cfg_attr(doc, doc = $doc)])+ pub $name: $ty,)*
236 }
237
238 mod defaults {
239 use super::*;
240 $(pub fn $name() -> $ty { $default })*
241 }
242
243 impl Default for Conf {
244 fn default() -> Self {
245 Self { $($name: defaults::$name(),)* }
246 }
247 }
248
249 #[derive(Deserialize)]
250 #[serde(field_identifier, rename_all = "kebab-case")]
251 #[expect(non_camel_case_types)]
252 enum Field { $($name,)* third_party, }
253
254 struct ConfVisitor<'a>(&'a SourceFile);
255
256 impl<'de> Visitor<'de> for ConfVisitor<'_> {
257 type Value = TryConf;
258
259 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
260 formatter.write_str("Conf")
261 }
262
263 fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de> {
264 let mut value_spans = HashMap::new();
265 let mut errors = Vec::new();
266 let mut warnings = Vec::new();
267
268 $(let mut $name = None;)*
270
271 while let Some(name) = map.next_key::<toml::Spanned<String>>()? {
273 let field = match Field::deserialize(name.get_ref().as_str().into_deserializer()) {
274 Err(e) => {
275 let e: FieldError = e;
276 errors.push(ConfError::spanned(self.0, e.error, e.suggestion, name.span()));
277 continue;
278 }
279 Ok(field) => field
280 };
281
282 match field {
283 $(Field::$name => {
284 $(warnings.push(ConfError::spanned(self.0, format!("deprecated field `{}`. {}", name.get_ref(), $dep), None, name.span()));)?
286 let (value, value_span) =
287 deserialize!(map, $ty, errors, self.0 $(, $replacements_allowed)?);
288 if $name.is_some() {
290 errors.push(ConfError::spanned(self.0, format!("duplicate field `{}`", name.get_ref()), None, name.span()));
291 continue;
292 }
293 $name = Some(value);
294 value_spans.insert(name.get_ref().as_str().to_string(), value_span);
295 $(match $new_conf {
298 Some(_) => errors.push(ConfError::spanned(self.0, concat!(
299 "duplicate field `", stringify!($new_conf),
300 "` (provided as `", stringify!($name), "`)"
301 ), None, name.span())),
302 None => $new_conf = $name.clone(),
303 })?
304 })*
305 Field::third_party => drop(map.next_value::<IgnoredAny>())
307 }
308 }
309 let conf = Conf { $($name: $name.unwrap_or_else(defaults::$name),)* };
310 Ok(TryConf { conf, value_spans, errors, warnings })
311 }
312 }
313
314 pub fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
315 vec![$(
316 ClippyConfiguration {
317 name: stringify!($name).replace('_', "-"),
318 default: default_text!(defaults::$name() $(, $default_text)?),
319 lints: &[$($(stringify!($for_lints)),*)?],
320 doc: concat!($($doc, '\n',)*),
321 deprecation_reason: wrap_option!($($dep)?)
322 },
323 )*]
324 }
325 };
326}
327
328fn union(x: &Range<usize>, y: &Range<usize>) -> Range<usize> {
329 Range {
330 start: cmp::min(x.start, y.start),
331 end: cmp::max(x.end, y.end),
332 }
333}
334
335fn span_from_toml_range(file: &SourceFile, span: Range<usize>) -> Span {
336 Span::new(
337 file.start_pos + BytePos::from_usize(span.start),
338 file.start_pos + BytePos::from_usize(span.end),
339 SyntaxContext::root(),
340 None,
341 )
342}
343
344define_Conf! {
345 #[lints(absolute_paths)]
347 absolute_paths_allowed_crates: Vec<String> = Vec::new(),
348 #[lints(absolute_paths)]
351 absolute_paths_max_segments: u64 = 2,
352 #[lints(undocumented_unsafe_blocks)]
354 accept_comment_above_attributes: bool = true,
355 #[lints(undocumented_unsafe_blocks)]
357 accept_comment_above_statement: bool = true,
358 #[lints(modulo_arithmetic)]
360 allow_comparison_to_zero: bool = true,
361 #[lints(dbg_macro)]
363 allow_dbg_in_tests: bool = false,
364 #[lints(module_name_repetitions)]
366 allow_exact_repetitions: bool = true,
367 #[lints(expect_used)]
369 allow_expect_in_consts: bool = true,
370 #[lints(expect_used)]
372 allow_expect_in_tests: bool = false,
373 #[lints(indexing_slicing)]
375 allow_indexing_slicing_in_tests: bool = false,
376 #[lints(uninlined_format_args)]
378 allow_mixed_uninlined_format_args: bool = true,
379 #[lints(needless_raw_string_hashes)]
381 allow_one_hash_in_raw_strings: bool = false,
382 #[lints(panic)]
384 allow_panic_in_tests: bool = false,
385 #[lints(print_stderr, print_stdout)]
387 allow_print_in_tests: bool = false,
388 #[lints(module_inception)]
390 allow_private_module_inception: bool = false,
391 #[lints(renamed_function_params)]
405 allow_renamed_params_for: Vec<String> =
406 DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS.iter().map(ToString::to_string).collect(),
407 #[lints(unwrap_used)]
409 allow_unwrap_in_consts: bool = true,
410 #[lints(unwrap_used)]
412 allow_unwrap_in_tests: bool = false,
413 #[lints(useless_vec)]
415 allow_useless_vec_in_tests: bool = false,
416 #[lints(path_ends_with_ext)]
418 allowed_dotfiles: Vec<String> = Vec::default(),
419 #[lints(multiple_crate_versions)]
421 allowed_duplicate_crates: Vec<String> = Vec::new(),
422 #[lints(min_ident_chars)]
426 allowed_idents_below_min_chars: Vec<String> =
427 DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect(),
428 #[lints(module_name_repetitions)]
446 allowed_prefixes: Vec<String> = DEFAULT_ALLOWED_PREFIXES.iter().map(ToString::to_string).collect(),
447 #[lints(disallowed_script_idents)]
449 allowed_scripts: Vec<String> = vec!["Latin".to_string()],
450 #[lints(wildcard_imports)]
464 allowed_wildcard_imports: Vec<String> = Vec::new(),
465 #[lints(arithmetic_side_effects)]
480 arithmetic_side_effects_allowed: Vec<String> = <_>::default(),
481 #[lints(arithmetic_side_effects)]
496 arithmetic_side_effects_allowed_binary: Vec<(String, String)> = <_>::default(),
497 #[lints(arithmetic_side_effects)]
505 arithmetic_side_effects_allowed_unary: Vec<String> = <_>::default(),
506 #[lints(large_const_arrays, large_stack_arrays)]
508 array_size_threshold: u64 = 16 * 1024,
509 #[lints(
511 box_collection,
512 enum_variant_names,
513 large_types_passed_by_value,
514 linkedlist,
515 needless_pass_by_ref_mut,
516 option_option,
517 owned_cow,
518 rc_buffer,
519 rc_mutex,
520 redundant_allocation,
521 ref_option,
522 single_call_fn,
523 trivially_copy_pass_by_ref,
524 unnecessary_box_returns,
525 unnecessary_wraps,
526 unused_self,
527 upper_case_acronyms,
528 vec_box,
529 wrong_self_convention,
530 )]
531 avoid_breaking_exported_api: bool = true,
532 #[disallowed_paths_allow_replacements = false]
534 #[lints(await_holding_invalid_type)]
535 await_holding_invalid_types: Vec<DisallowedPathWithoutReplacement> = Vec::new(),
536 #[conf_deprecated("Please use `disallowed-names` instead", disallowed_names)]
540 blacklisted_names: Vec<String> = Vec::new(),
541 #[lints(cargo_common_metadata)]
543 cargo_ignore_publish: bool = false,
544 #[lints(incompatible_msrv)]
546 check_incompatible_msrv_in_tests: bool = false,
547 #[lints(inconsistent_struct_constructor)]
566 check_inconsistent_struct_field_initializers: bool = false,
567 #[lints(missing_errors_doc, missing_panics_doc, missing_safety_doc, unnecessary_safety_doc)]
569 check_private_items: bool = false,
570 #[lints(cognitive_complexity)]
572 cognitive_complexity_threshold: u64 = 25,
573 #[lints(excessive_precision)]
575 const_literal_digits_threshold: usize = 30,
576 #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
580 cyclomatic_complexity_threshold: u64 = 25,
581 #[disallowed_paths_allow_replacements = true]
590 #[lints(disallowed_macros)]
591 disallowed_macros: Vec<DisallowedPath> = Vec::new(),
592 #[disallowed_paths_allow_replacements = true]
601 #[lints(disallowed_methods)]
602 disallowed_methods: Vec<DisallowedPath> = Vec::new(),
603 #[lints(disallowed_names)]
607 disallowed_names: Vec<String> = DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect(),
608 #[disallowed_paths_allow_replacements = true]
617 #[lints(disallowed_types)]
618 disallowed_types: Vec<DisallowedPath> = Vec::new(),
619 #[lints(doc_markdown)]
625 doc_valid_idents: Vec<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect(),
626 #[lints(non_send_fields_in_send_ty)]
628 enable_raw_pointer_heuristic_for_send: bool = true,
629 #[lints(explicit_iter_loop)]
647 enforce_iter_loop_reborrow: bool = false,
648 #[lints(missing_enforced_import_renames)]
650 enforced_import_renames: Vec<Rename> = Vec::new(),
651 #[lints(enum_variant_names)]
653 enum_variant_name_threshold: u64 = 3,
654 #[lints(large_enum_variant)]
656 enum_variant_size_threshold: u64 = 200,
657 #[lints(excessive_nesting)]
659 excessive_nesting_threshold: u64 = 0,
660 #[lints(large_futures)]
662 future_size_threshold: u64 = 16 * 1024,
663 #[lints(borrow_interior_mutable_const, declare_interior_mutable_const, ifs_same_cond, mutable_key_type)]
665 ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()]),
666 #[lints(multiple_inherent_impl)]
668 inherent_impl_lint_scope: InherentImplLintScope = InherentImplLintScope::Crate,
669 #[lints(result_large_err)]
671 large_error_threshold: u64 = 128,
672 #[lints(collapsible_else_if, collapsible_if)]
675 lint_commented_code: bool = false,
676 #[conf_deprecated("Please use `check-inconsistent-struct-field-initializers` instead", check_inconsistent_struct_field_initializers)]
681 lint_inconsistent_struct_field_initializers: bool = false,
682 #[lints(decimal_literal_representation)]
684 literal_representation_threshold: u64 = 16384,
685 #[lints(manual_let_else)]
688 matches_for_let_else: MatchLintBehaviour = MatchLintBehaviour::WellKnownTypes,
689 #[lints(fn_params_excessive_bools)]
691 max_fn_params_bools: u64 = 3,
692 #[lints(large_include_file)]
694 max_include_file_size: u64 = 1_000_000,
695 #[lints(struct_excessive_bools)]
697 max_struct_bools: u64 = 3,
698 #[lints(index_refutable_slice)]
702 max_suggested_slice_pattern_length: u64 = 3,
703 #[lints(type_repetition_in_bounds)]
705 max_trait_bounds: u64 = 3,
706 #[lints(min_ident_chars)]
708 min_ident_chars_threshold: u64 = 1,
709 #[lints(missing_docs_in_private_items)]
711 missing_docs_allow_unused: bool = false,
712 #[lints(missing_docs_in_private_items)]
715 missing_docs_in_crate_items: bool = false,
716 #[lints(arbitrary_source_item_ordering)]
718 module_item_order_groupings: SourceItemOrderingModuleItemGroupings = DEFAULT_MODULE_ITEM_ORDERING_GROUPS.into(),
719 #[lints(arbitrary_source_item_ordering)]
724 module_items_ordered_within_groupings: SourceItemOrderingWithinModuleItemGroupings =
725 SourceItemOrderingWithinModuleItemGroupings::None,
726 #[default_text = "current version"]
728 #[lints(
729 allow_attributes,
730 allow_attributes_without_reason,
731 almost_complete_range,
732 approx_constant,
733 assigning_clones,
734 borrow_as_ptr,
735 cast_abs_to_unsigned,
736 checked_conversions,
737 cloned_instead_of_copied,
738 collapsible_match,
739 collapsible_str_replace,
740 deprecated_cfg_attr,
741 derivable_impls,
742 err_expect,
743 filter_map_next,
744 from_over_into,
745 if_then_some_else_none,
746 index_refutable_slice,
747 inefficient_to_string,
748 io_other_error,
749 iter_kv_map,
750 legacy_numeric_constants,
751 lines_filter_map_ok,
752 manual_abs_diff,
753 manual_bits,
754 manual_c_str_literals,
755 manual_clamp,
756 manual_div_ceil,
757 manual_flatten,
758 manual_hash_one,
759 manual_is_ascii_check,
760 manual_is_power_of_two,
761 manual_let_else,
762 manual_midpoint,
763 manual_non_exhaustive,
764 manual_option_as_slice,
765 manual_pattern_char_comparison,
766 manual_range_contains,
767 manual_rem_euclid,
768 manual_repeat_n,
769 manual_retain,
770 manual_slice_fill,
771 manual_slice_size_calculation,
772 manual_split_once,
773 manual_str_repeat,
774 manual_strip,
775 manual_try_fold,
776 map_clone,
777 map_unwrap_or,
778 map_with_unused_argument_over_ranges,
779 match_like_matches_macro,
780 mem_replace_option_with_some,
781 mem_replace_with_default,
782 missing_const_for_fn,
783 needless_borrow,
784 non_std_lazy_statics,
785 option_as_ref_deref,
786 or_fun_call,
787 ptr_as_ptr,
788 question_mark,
789 redundant_field_names,
790 redundant_static_lifetimes,
791 repeat_vec_with_capacity,
792 same_item_push,
793 seek_from_current,
794 to_digit_is_some,
795 transmute_ptr_to_ref,
796 tuple_array_conversions,
797 type_repetition_in_bounds,
798 unchecked_time_subtraction,
799 uninlined_format_args,
800 unnecessary_lazy_evaluations,
801 unnecessary_unwrap,
802 unnested_or_patterns,
803 unused_trait_names,
804 use_self,
805 zero_ptr,
806 )]
807 msrv: Msrv = Msrv::default(),
808 #[lints(large_types_passed_by_value)]
810 pass_by_value_size_limit: u64 = 256,
811 #[lints(pub_underscore_fields)]
814 pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PubliclyExported,
815 #[lints(use_self)]
817 recursive_self_in_type_definitions: bool = true,
818 #[lints(semicolon_inside_block)]
820 semicolon_inside_block_ignore_singleline: bool = false,
821 #[lints(semicolon_outside_block)]
823 semicolon_outside_block_ignore_multiline: bool = false,
824 #[lints(many_single_char_names)]
826 single_char_binding_names_threshold: u64 = 4,
827 #[lints(arbitrary_source_item_ordering)]
829 source_item_ordering: SourceItemOrdering = DEFAULT_SOURCE_ITEM_ORDERING.into(),
830 #[lints(large_stack_frames)]
832 stack_size_threshold: u64 = 512_000,
833 #[lints(nonstandard_macro_braces)]
839 standard_macro_braces: Vec<MacroMatcher> = Vec::new(),
840 #[lints(struct_field_names)]
842 struct_field_name_threshold: u64 = 3,
843 #[lints(indexing_slicing)]
849 suppress_restriction_lint_in_const: bool = false,
850 #[lints(boxed_local, useless_vec)]
852 too_large_for_stack: u64 = 200,
853 #[lints(too_many_arguments)]
855 too_many_arguments_threshold: u64 = 7,
856 #[lints(too_many_lines)]
858 too_many_lines_threshold: u64 = 100,
859 #[lints(arbitrary_source_item_ordering)]
861 trait_assoc_item_kinds_order: SourceItemOrderingTraitAssocItemKinds = DEFAULT_TRAIT_ASSOC_ITEM_KINDS_ORDER.into(),
862 #[default_text = "target_pointer_width"]
865 #[lints(trivially_copy_pass_by_ref)]
866 trivial_copy_size_limit: Option<u64> = None,
867 #[lints(type_complexity)]
869 type_complexity_threshold: u64 = 250,
870 #[lints(unnecessary_box_returns)]
872 unnecessary_box_size: u64 = 128,
873 #[lints(unreadable_literal)]
875 unreadable_literal_lint_fractions: bool = true,
876 #[lints(upper_case_acronyms)]
878 upper_case_acronyms_aggressive: bool = false,
879 #[lints(vec_box)]
881 vec_box_size_threshold: u64 = 4096,
882 #[lints(verbose_bit_mask)]
884 verbose_bit_mask_threshold: u64 = 1,
885 #[lints(wildcard_imports)]
888 warn_on_all_wildcard_imports: bool = false,
889 #[lints(macro_metavars_in_unsafe)]
891 warn_unsafe_macro_metavars_in_private_macros: bool = false,
892}
893
894pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
900 const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
902
903 let mut current = env::var_os("CLIPPY_CONF_DIR")
906 .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
907 .map_or_else(|| PathBuf::from("."), PathBuf::from)
908 .canonicalize()?;
909
910 let mut found_config: Option<PathBuf> = None;
911 let mut warnings = vec![];
912
913 loop {
914 for config_file_name in &CONFIG_FILE_NAMES {
915 if let Ok(config_file) = current.join(config_file_name).canonicalize() {
916 match fs::metadata(&config_file) {
917 Err(e) if e.kind() == io::ErrorKind::NotFound => {},
918 Err(e) => return Err(e),
919 Ok(md) if md.is_dir() => {},
920 Ok(_) => {
921 if let Some(ref found_config) = found_config {
923 warnings.push(format!(
924 "using config file `{}`, `{}` will be ignored",
925 found_config.display(),
926 config_file.display()
927 ));
928 } else {
929 found_config = Some(config_file);
930 }
931 },
932 }
933 }
934 }
935
936 if found_config.is_some() {
937 return Ok((found_config, warnings));
938 }
939
940 if !current.pop() {
942 return Ok((None, warnings));
943 }
944 }
945}
946
947fn deserialize(file: &SourceFile) -> TryConf {
948 match toml::de::Deserializer::new(file.src.as_ref().unwrap()).deserialize_map(ConfVisitor(file)) {
949 Ok(mut conf) => {
950 extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
951 extend_vec_if_indicator_present(&mut conf.conf.allowed_prefixes, DEFAULT_ALLOWED_PREFIXES);
952 extend_vec_if_indicator_present(
953 &mut conf.conf.allow_renamed_params_for,
954 DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS,
955 );
956
957 if let SourceItemOrderingWithinModuleItemGroupings::Custom(groupings) =
960 &conf.conf.module_items_ordered_within_groupings
961 {
962 for grouping in groupings {
963 if !conf.conf.module_item_order_groupings.is_grouping(grouping) {
964 let names = conf.conf.module_item_order_groupings.grouping_names();
968 let suggestion = suggest_candidate(grouping, names.iter().map(String::as_str))
969 .map(|s| format!(" perhaps you meant `{s}`?"))
970 .unwrap_or_default();
971 let names = names.iter().map(|s| format!("`{s}`")).join(", ");
972 let message = format!(
973 "unknown ordering group: `{grouping}` was not specified in `module-items-ordered-within-groupings`,{suggestion} expected one of: {names}"
974 );
975
976 let span = conf
977 .value_spans
978 .get("module_item_order_groupings")
979 .cloned()
980 .unwrap_or_default();
981 conf.errors.push(ConfError::spanned(file, message, None, span));
982 }
983 }
984 }
985
986 if conf.conf.allowed_idents_below_min_chars.iter().any(|e| e == "..") {
988 conf.conf
989 .allowed_idents_below_min_chars
990 .extend(DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string));
991 }
992 if conf.conf.doc_valid_idents.iter().any(|e| e == "..") {
993 conf.conf
994 .doc_valid_idents
995 .extend(DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string));
996 }
997
998 conf
999 },
1000 Err(e) => TryConf::from_toml_error(file, &e),
1001 }
1002}
1003
1004fn extend_vec_if_indicator_present(vec: &mut Vec<String>, default: &[&str]) {
1005 if vec.contains(&"..".to_string()) {
1006 vec.extend(default.iter().map(ToString::to_string));
1007 }
1008}
1009
1010impl Conf {
1011 pub fn read(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> &'static Conf {
1012 static CONF: OnceLock<Conf> = OnceLock::new();
1013 CONF.get_or_init(|| Conf::read_inner(sess, path))
1014 }
1015
1016 fn read_inner(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<String>)>) -> Conf {
1017 match path {
1018 Ok((_, warnings)) => {
1019 for warning in warnings {
1020 sess.dcx().warn(warning.clone());
1021 }
1022 },
1023 Err(error) => {
1024 sess.dcx()
1025 .err(format!("error finding Clippy's configuration file: {error}"));
1026 },
1027 }
1028
1029 let TryConf {
1030 mut conf,
1031 value_spans: _,
1032 errors,
1033 warnings,
1034 } = match path {
1035 Ok((Some(path), _)) => match sess.source_map().load_file(path) {
1036 Ok(file) => deserialize(&file),
1037 Err(error) => {
1038 sess.dcx().err(format!("failed to read `{}`: {error}", path.display()));
1039 TryConf::default()
1040 },
1041 },
1042 _ => TryConf::default(),
1043 };
1044
1045 conf.msrv.read_cargo(sess);
1046
1047 for error in errors {
1049 let mut diag = sess.dcx().struct_span_err(
1050 error.span,
1051 format!("error reading Clippy's configuration file: {}", error.message),
1052 );
1053
1054 if let Some(sugg) = error.suggestion {
1055 diag.span_suggestion(error.span, sugg.message, sugg.suggestion, Applicability::MaybeIncorrect);
1056 }
1057
1058 diag.emit();
1059 }
1060
1061 for warning in warnings {
1062 sess.dcx().span_warn(
1063 warning.span,
1064 format!("error reading Clippy's configuration file: {}", warning.message),
1065 );
1066 }
1067
1068 conf
1069 }
1070}
1071
1072const SEPARATOR_WIDTH: usize = 4;
1073
1074#[derive(Debug)]
1075struct FieldError {
1076 error: String,
1077 suggestion: Option<Suggestion>,
1078}
1079
1080#[derive(Debug)]
1081struct Suggestion {
1082 message: &'static str,
1083 suggestion: &'static str,
1084}
1085
1086impl std::error::Error for FieldError {}
1087
1088impl Display for FieldError {
1089 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
1090 f.pad(&self.error)
1091 }
1092}
1093
1094impl serde::de::Error for FieldError {
1095 fn custom<T: Display>(msg: T) -> Self {
1096 Self {
1097 error: msg.to_string(),
1098 suggestion: None,
1099 }
1100 }
1101
1102 fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
1103 use fmt::Write;
1106
1107 let metadata = get_configuration_metadata();
1108 let deprecated = metadata
1109 .iter()
1110 .filter_map(|conf| {
1111 if conf.deprecation_reason.is_some() {
1112 Some(conf.name.as_str())
1113 } else {
1114 None
1115 }
1116 })
1117 .collect::<Vec<_>>();
1118
1119 let mut expected = expected
1120 .iter()
1121 .copied()
1122 .filter(|name| !deprecated.contains(name))
1123 .collect::<Vec<_>>();
1124 expected.sort_unstable();
1125
1126 let (rows, column_widths) = calculate_dimensions(&expected);
1127
1128 let mut msg = format!("unknown field `{field}`, expected one of");
1129 for row in 0..rows {
1130 writeln!(msg).unwrap();
1131 for (column, column_width) in column_widths.iter().copied().enumerate() {
1132 let index = column * rows + row;
1133 let field = expected.get(index).copied().unwrap_or_default();
1134 write!(msg, "{:SEPARATOR_WIDTH$}{field:column_width$}", " ").unwrap();
1135 }
1136 }
1137
1138 let suggestion = suggest_candidate(field, expected).map(|suggestion| Suggestion {
1139 message: "perhaps you meant",
1140 suggestion,
1141 });
1142
1143 Self { error: msg, suggestion }
1144 }
1145}
1146
1147fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
1148 let columns = env::var("CLIPPY_TERMINAL_WIDTH")
1149 .ok()
1150 .and_then(|s| <usize as FromStr>::from_str(&s).ok())
1151 .map_or(1, |terminal_width| {
1152 let max_field_width = fields.iter().map(|field| field.len()).max().unwrap();
1153 cmp::max(1, terminal_width / (SEPARATOR_WIDTH + max_field_width))
1154 });
1155
1156 let rows = fields.len().div_ceil(columns);
1157
1158 let column_widths = (0..columns)
1159 .map(|column| {
1160 if column < columns - 1 {
1161 (0..rows)
1162 .map(|row| {
1163 let index = column * rows + row;
1164 let field = fields.get(index).copied().unwrap_or_default();
1165 field.len()
1166 })
1167 .max()
1168 .unwrap()
1169 } else {
1170 0
1172 }
1173 })
1174 .collect::<Vec<_>>();
1175
1176 (rows, column_widths)
1177}
1178
1179fn suggest_candidate<'a, I>(value: &str, candidates: I) -> Option<&'a str>
1182where
1183 I: IntoIterator<Item = &'a str>,
1184{
1185 candidates
1186 .into_iter()
1187 .filter_map(|expected| {
1188 let dist = edit_distance(value, expected, 4)?;
1189 Some((dist, expected))
1190 })
1191 .min_by_key(|&(dist, _)| dist)
1192 .map(|(_, suggestion)| suggestion)
1193}
1194
1195#[cfg(test)]
1196mod tests {
1197 use serde::de::IgnoredAny;
1198 use std::collections::{HashMap, HashSet};
1199 use std::fs;
1200 use walkdir::WalkDir;
1201
1202 #[test]
1203 fn configs_are_tested() {
1204 let mut names: HashSet<String> = crate::get_configuration_metadata()
1205 .into_iter()
1206 .filter_map(|meta| {
1207 if meta.deprecation_reason.is_none() {
1208 Some(meta.name.replace('_', "-"))
1209 } else {
1210 None
1211 }
1212 })
1213 .collect();
1214
1215 let toml_files = WalkDir::new("../tests")
1216 .into_iter()
1217 .map(Result::unwrap)
1218 .filter(|entry| entry.file_name() == "clippy.toml");
1219
1220 for entry in toml_files {
1221 let file = fs::read_to_string(entry.path()).unwrap();
1222 #[expect(clippy::zero_sized_map_values)]
1223 if let Ok(map) = toml::from_str::<HashMap<String, IgnoredAny>>(&file) {
1224 for name in map.keys() {
1225 names.remove(name.as_str());
1226 }
1227 }
1228 }
1229
1230 assert!(
1231 names.is_empty(),
1232 "Configuration variable lacks test: {names:?}\nAdd a test to `tests/ui-toml`"
1233 );
1234 }
1235}