From cf91c54cc6e20462bf6c5c63a3ab0b6afe8b7f0e Mon Sep 17 00:00:00 2001 From: Tamir Duberstein Date: Tue, 7 Jul 2020 11:12:44 -0400 Subject: [PATCH] Avoid "whitelist" Other terms are more inclusive and precise. --- clippy_lints/src/attrs.rs | 4 ++-- clippy_lints/src/eq_op.rs | 2 +- clippy_lints/src/needless_pass_by_value.rs | 4 ++-- clippy_lints/src/non_expressive_names.rs | 18 +++++++++--------- clippy_lints/src/precedence.rs | 4 ++-- clippy_lints/src/types.rs | 4 ++-- .../{whitelist => third-party}/clippy.toml | 0 .../conf_allowlisted.rs} | 0 tests/ui/needless_pass_by_value.rs | 2 +- tests/ui/neg_cmp_op_on_partial_ord.rs | 2 +- 10 files changed, 20 insertions(+), 20 deletions(-) rename tests/ui/crashes/{whitelist => third-party}/clippy.toml (100%) rename tests/ui/crashes/{whitelist/conf_whitelisted.rs => third-party/conf_allowlisted.rs} (100%) diff --git a/clippy_lints/src/attrs.rs b/clippy_lints/src/attrs.rs index 2505ff32fe5..3f7d6ba6467 100644 --- a/clippy_lints/src/attrs.rs +++ b/clippy_lints/src/attrs.rs @@ -72,7 +72,7 @@ declare_clippy_lint! { /// **What it does:** Checks for `extern crate` and `use` items annotated with /// lint attributes. /// - /// This lint whitelists `#[allow(unused_imports)]`, `#[allow(deprecated)]` and + /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]` and /// `#[allow(unreachable_pub)]` on `use` items and `#[allow(unused_imports)]` on /// `extern crate` items with a `#[macro_use]` attribute. /// @@ -294,7 +294,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes { if let Some(ident) = attr.ident() { match &*ident.as_str() { "allow" | "warn" | "deny" | "forbid" => { - // whitelist `unused_imports`, `deprecated` and `unreachable_pub` for `use` items + // permit `unused_imports`, `deprecated` and `unreachable_pub` for `use` items // and `unused_imports` for `extern crate` items with `macro_use` for lint in lint_list { match item.kind { diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs index ca921dcfdfe..cbc93d772dd 100644 --- a/clippy_lints/src/eq_op.rs +++ b/clippy_lints/src/eq_op.rs @@ -16,7 +16,7 @@ declare_clippy_lint! { /// **Known problems:** False negatives: We had some false positives regarding /// calls (notably [racer](https://github.com/phildawes/racer) had one instance /// of `x.pop() && x.pop()`), so we removed matching any function or method - /// calls. We may introduce a whitelist of known pure functions in the future. + /// calls. We may introduce a list of known pure functions in the future. /// /// **Example:** /// ```rust diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs index 5d47f9425e3..29e5d4d1664 100644 --- a/clippy_lints/src/needless_pass_by_value.rs +++ b/clippy_lints/src/needless_pass_by_value.rs @@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue { // Allow `Borrow` or functions to be taken by value let borrow_trait = need!(get_trait_def_id(cx, &paths::BORROW_TRAIT)); - let whitelisted_traits = [ + let allowed_traits = [ need!(cx.tcx.lang_items().fn_trait()), need!(cx.tcx.lang_items().fn_once_trait()), need!(cx.tcx.lang_items().fn_mut_trait()), @@ -184,7 +184,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue { if !is_self(arg); if !ty.is_mutable_ptr(); if !is_copy(cx, ty); - if !whitelisted_traits.iter().any(|&t| implements_trait(cx, ty, t, &[])); + if !allowed_traits.iter().any(|&t| implements_trait(cx, ty, t, &[])); if !implements_borrow_trait; if !all_borrowable_trait; diff --git a/clippy_lints/src/non_expressive_names.rs b/clippy_lints/src/non_expressive_names.rs index 5f14fe97afe..7128fee9bcf 100644 --- a/clippy_lints/src/non_expressive_names.rs +++ b/clippy_lints/src/non_expressive_names.rs @@ -78,7 +78,7 @@ struct ExistingName { interned: SymbolStr, span: Span, len: usize, - whitelist: &'static [&'static str], + exemptions: &'static [&'static str], } struct SimilarNamesLocalVisitor<'a, 'tcx> { @@ -117,7 +117,7 @@ impl<'a, 'tcx> SimilarNamesLocalVisitor<'a, 'tcx> { // this list contains lists of names that are allowed to be similar // the assumption is that no name is ever contained in multiple lists. #[rustfmt::skip] -const WHITELIST: &[&[&str]] = &[ +const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[ &["parsed", "parser"], &["lhs", "rhs"], &["tx", "rx"], @@ -156,17 +156,17 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> { } #[must_use] -fn get_whitelist(interned_name: &str) -> Option<&'static [&'static str]> { - for &allow in WHITELIST { - if whitelisted(interned_name, allow) { - return Some(allow); +fn get_exemptions(interned_name: &str) -> Option<&'static [&'static str]> { + for &list in ALLOWED_TO_BE_SIMILAR { + if allowed_to_be_similar(interned_name, list) { + return Some(list); } } None } #[must_use] -fn whitelisted(interned_name: &str, list: &[&str]) -> bool { +fn allowed_to_be_similar(interned_name: &str, list: &[&str]) -> bool { list.iter() .any(|&name| interned_name.starts_with(name) || interned_name.ends_with(name)) } @@ -212,7 +212,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { return; } for existing_name in &self.0.names { - if whitelisted(&interned_name, existing_name.whitelist) { + if allowed_to_be_similar(&interned_name, existing_name.exemptions) { continue; } let mut split_at = None; @@ -301,7 +301,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { return; } self.0.names.push(ExistingName { - whitelist: get_whitelist(&interned_name).unwrap_or(&[]), + exemptions: get_exemptions(&interned_name).unwrap_or(&[]), interned: interned_name, span: ident.span, len: count, diff --git a/clippy_lints/src/precedence.rs b/clippy_lints/src/precedence.rs index 7dce23dd223..23793678fa0 100644 --- a/clippy_lints/src/precedence.rs +++ b/clippy_lints/src/precedence.rs @@ -5,7 +5,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; -const ODD_FUNCTIONS_WHITELIST: [&str; 14] = [ +const ALLOWED_ODD_FUNCTIONS: [&str; 14] = [ "asin", "asinh", "atan", @@ -109,7 +109,7 @@ impl EarlyLintPass for Precedence { if let ExprKind::Lit(ref lit) = slf.kind { match lit.kind { LitKind::Int(..) | LitKind::Float(..) => { - if ODD_FUNCTIONS_WHITELIST + if ALLOWED_ODD_FUNCTIONS .iter() .any(|odd_function| **odd_function == *path_segment_str) { diff --git a/clippy_lints/src/types.rs b/clippy_lints/src/types.rs index b1345f0de5e..68f51f0afdc 100644 --- a/clippy_lints/src/types.rs +++ b/clippy_lints/src/types.rs @@ -1256,7 +1256,7 @@ fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast // don't lint for the result of methods that always return non-negative values if let ExprKind::MethodCall(ref path, _, _, _) = op.kind { let mut method_name = path.ident.name.as_str(); - let whitelisted_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"]; + let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"]; if_chain! { if method_name == "unwrap"; @@ -1267,7 +1267,7 @@ fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast } } - if whitelisted_methods.iter().any(|&name| method_name == name) { + if allowed_methods.iter().any(|&name| method_name == name) { return; } } diff --git a/tests/ui/crashes/whitelist/clippy.toml b/tests/ui/crashes/third-party/clippy.toml similarity index 100% rename from tests/ui/crashes/whitelist/clippy.toml rename to tests/ui/crashes/third-party/clippy.toml diff --git a/tests/ui/crashes/whitelist/conf_whitelisted.rs b/tests/ui/crashes/third-party/conf_allowlisted.rs similarity index 100% rename from tests/ui/crashes/whitelist/conf_whitelisted.rs rename to tests/ui/crashes/third-party/conf_allowlisted.rs diff --git a/tests/ui/needless_pass_by_value.rs b/tests/ui/needless_pass_by_value.rs index e93a7fe2985..7a9ba55590d 100644 --- a/tests/ui/needless_pass_by_value.rs +++ b/tests/ui/needless_pass_by_value.rs @@ -116,7 +116,7 @@ extern "C" fn ext(x: MaybeUninit) -> usize { unsafe { x.assume_init() } } -// whitelist RangeArgument +// exempt RangeArgument fn range>(range: T) { let _ = range.start_bound(); } diff --git a/tests/ui/neg_cmp_op_on_partial_ord.rs b/tests/ui/neg_cmp_op_on_partial_ord.rs index ca70e3b7148..0b471195272 100644 --- a/tests/ui/neg_cmp_op_on_partial_ord.rs +++ b/tests/ui/neg_cmp_op_on_partial_ord.rs @@ -57,6 +57,6 @@ fn main() { // The macro always negates the result of the given comparison in its // internal check which automatically triggered the lint. As it's an // external macro there was no chance to do anything about it which led - // to a whitelisting of all external macros. + // to an exempting of all external macros. assert!(a_value < another_value); }