Move methods lint declarations into sub-modules

Author: Jarcho

clippy_lints_methods/src/bind_instead_of_map.rs

@@ -1,4 +1,4 @@
-use super::{BIND_INSTEAD_OF_MAP, contains_return};
+use super::contains_return;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::peel_blocks;
 use clippy_utils::source::{snippet, snippet_with_context};
@@ -10,6 +10,38 @@ use rustc_hir::{LangItem, QPath};
 use rustc_lint::LateContext;
 use rustc_span::Span;
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.and_then(|x| Some(y))`, `_.and_then(|x| Ok(y))`
+    /// or `_.or_else(|x| Err(y))`.
+    ///
+    /// ### Why is this bad?
+    /// This can be written more concisely as `_.map(|x| y)` or `_.map_err(|x| y)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # fn opt() -> Option<&'static str> { Some("42") }
+    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+    /// let _ = opt().and_then(|s| Some(s.len()));
+    /// let _ = res().and_then(|s| if s.len() == 42 { Ok(10) } else { Ok(20) });
+    /// let _ = res().or_else(|s| if s.len() == 42 { Err(10) } else { Err(20) });
+    /// ```
+    ///
+    /// The correct use would be:
+    ///
+    /// ```no_run
+    /// # fn opt() -> Option<&'static str> { Some("42") }
+    /// # fn res() -> Result<&'static str, &'static str> { Ok("42") }
+    /// let _ = opt().map(|s| s.len());
+    /// let _ = res().map(|s| if s.len() == 42 { 10 } else { 20 });
+    /// let _ = res().map_err(|s| if s.len() == 42 { 10 } else { 20 });
+    /// ```
+    #[clippy::version = "1.45.0"]
+    pub BIND_INSTEAD_OF_MAP,
+    complexity,
+    "using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`"
+}
+
 pub(super) fn check_and_then_some(
     cx: &LateContext<'_>,
     expr: &hir::Expr<'_>,

clippy_lints_methods/src/bytecount.rs

@@ -9,7 +9,36 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::{self, UintTy};
 use rustc_span::sym;
 
-use super::NAIVE_BYTECOUNT;
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for naive byte counts
+    ///
+    /// ### Why is this bad?
+    /// The [`bytecount`](https://crates.io/crates/bytecount)
+    /// crate has methods to count your bytes faster, especially for large slices.
+    ///
+    /// ### Known problems
+    /// If you have predominantly small slices, the
+    /// `bytecount::count(..)` method may actually be slower. However, if you can
+    /// ensure that less than 2³²-1 matches arise, the `naive_count_32(..)` can be
+    /// faster in those cases.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let vec = vec![1_u8];
+    /// let count = vec.iter().filter(|x| **x == 0u8).count();
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust,ignore
+    /// # let vec = vec![1_u8];
+    /// let count = bytecount::count(&vec, 0u8);
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub NAIVE_BYTECOUNT,
+    pedantic,
+    "use of naive `<slice>.filter(|&x| x == y).count()` to count byte values"
+}
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,

clippy_lints_methods/src/bytes_count_to_len.rs

@@ -5,7 +5,30 @@ use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 
-use super::BYTES_COUNT_TO_LEN;
+declare_clippy_lint! {
+    /// ### What it does
+    /// It checks for `str::bytes().count()` and suggests replacing it with
+    /// `str::len()`.
+    ///
+    /// ### Why is this bad?
+    /// `str::bytes().count()` is longer and may not be as performant as using
+    /// `str::len()`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// "hello".bytes().count();
+    /// String::from("hello").bytes().count();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// "hello".len();
+    /// String::from("hello").len();
+    /// ```
+    #[clippy::version = "1.62.0"]
+    pub BYTES_COUNT_TO_LEN,
+    complexity,
+    "Using `bytes().count()` when `len()` performs the same functionality"
+}
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,

clippy_lints_methods/src/bytes_nth.rs

@@ -8,7 +8,28 @@ use rustc_lint::LateContext;
 
 use crate::method_call;
 
-use super::BYTES_NTH;
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for the use of `.bytes().nth()`.
+    ///
+    /// ### Why is this bad?
+    /// `.as_bytes().get()` is more efficient and more
+    /// readable.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// "Hello".bytes().nth(3);
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// "Hello".as_bytes().get(3);
+    /// ```
+    #[clippy::version = "1.52.0"]
+    pub BYTES_NTH,
+    style,
+    "replace `.bytes().nth()` with `.as_bytes().get()`"
+}
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, n_arg: &'tcx Expr<'tcx>) {
     let ty = cx.typeck_results().expr_ty(recv).peel_refs();

clippy_lints_methods/src/case_sensitive_file_extension_comparisons.rs

@@ -10,7 +10,33 @@ use rustc_lint::LateContext;
 use rustc_span::Span;
 use rustc_span::source_map::Spanned;
 
-use super::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS;
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `ends_with` with possible file extensions
+    /// and suggests to use a case-insensitive approach instead.
+    ///
+    /// ### Why is this bad?
+    /// `ends_with` is case-sensitive and may not detect files with a valid extension.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     filename.ends_with(".rs")
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn is_rust_file(filename: &str) -> bool {
+    ///     let filename = std::path::Path::new(filename);
+    ///     filename.extension()
+    ///         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+    /// }
+    /// ```
+    #[clippy::version = "1.51.0"]
+    pub CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+    pedantic,
+    "Checks for calls to ends_with with case-sensitive file extensions"
+}
 
 pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,

clippy_lints_methods/src/chars_cmp.rs

@@ -1,14 +1,112 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{method_chain_args, path_def_id};
+use clippy_utils::{method_chain_args, path_def_id, sym};
 use rustc_errors::Applicability;
-use rustc_hir as hir;
 use rustc_lint::{LateContext, Lint};
 use rustc_middle::ty;
 use rustc_span::Symbol;
+use {rustc_ast as ast, rustc_hir as hir};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `.chars().next()` on a `str` to check
+    /// if it starts with a given char.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.starts_with(_)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let name = "foo";
+    /// if name.chars().next() == Some('_') {};
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let name = "foo";
+    /// if name.starts_with('_') {};
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub CHARS_NEXT_CMP,
+    style,
+    "using `.chars().next()` to check if a string starts with a char"
+}
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for usage of `_.chars().last()` or
+    /// `_.chars().next_back()` on a `str` to check if it ends with a given char.
+    ///
+    /// ### Why is this bad?
+    /// Readability, this can be written more concisely as
+    /// `_.ends_with(_)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let name = "_";
+    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # let name = "_";
+    /// name.ends_with('_') || name.ends_with('-');
+    /// ```
+    #[clippy::version = "pre 1.29.0"]
+    pub CHARS_LAST_CMP,
+    style,
+    "using `.chars().last()` or `.chars().next_back()` to check if a string ends with a char"
+}
+
+/// Checks for the `CHARS_NEXT_CMP` lint.
+pub(super) fn check_next(cx: &LateContext<'_>, info: &crate::BinaryExprInfo<'_>) -> bool {
+    check(cx, info, &[sym::chars, sym::next], CHARS_NEXT_CMP, "starts_with")
+}
+
+/// Checks for the `CHARS_NEXT_CMP` lint with `unwrap()`.
+pub(super) fn check_next_unwrap(cx: &LateContext<'_>, info: &crate::BinaryExprInfo<'_>) -> bool {
+    check_unwrap(
+        cx,
+        info,
+        &[sym::chars, sym::next, sym::unwrap],
+        CHARS_NEXT_CMP,
+        "starts_with",
+    )
+}
+
+/// Checks for the `CHARS_LAST_CMP` lint.
+pub(super) fn check_last(cx: &LateContext<'_>, info: &crate::BinaryExprInfo<'_>) -> bool {
+    if check(cx, info, &[sym::chars, sym::last], CHARS_LAST_CMP, "ends_with") {
+        true
+    } else {
+        check(cx, info, &[sym::chars, sym::next_back], CHARS_LAST_CMP, "ends_with")
+    }
+}
+
+/// Checks for the `CHARS_LAST_CMP` lint with `unwrap()`.
+pub(super) fn check_last_unwrap(cx: &LateContext<'_>, info: &crate::BinaryExprInfo<'_>) -> bool {
+    if check_unwrap(
+        cx,
+        info,
+        &[sym::chars, sym::last, sym::unwrap],
+        CHARS_LAST_CMP,
+        "ends_with",
+    ) {
+        true
+    } else {
+        check_unwrap(
+            cx,
+            info,
+            &[sym::chars, sym::next_back, sym::unwrap],
+            CHARS_LAST_CMP,
+            "ends_with",
+        )
+    }
+}
 
 /// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
-pub(super) fn check(
+fn check(
     cx: &LateContext<'_>,
     info: &crate::BinaryExprInfo<'_>,
     chain_methods: &[Symbol],
@@ -47,3 +145,37 @@ pub(super) fn check(
 
     false
 }
+
+/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
+fn check_unwrap(
+    cx: &LateContext<'_>,
+    info: &crate::BinaryExprInfo<'_>,
+    chain_methods: &[Symbol],
+    lint: &'static Lint,
+    suggest: &str,
+) -> bool {
+    if let Some(args) = method_chain_args(info.chain, chain_methods)
+        && let hir::ExprKind::Lit(lit) = info.other.kind
+        && let ast::LitKind::Char(c) = lit.node
+    {
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            lint,
+            info.expr.span,
+            format!("you should use the `{suggest}` method"),
+            "like this",
+            format!(
+                "{}{}.{suggest}('{}')",
+                if info.eq { "" } else { "!" },
+                snippet_with_applicability(cx, args[0].0.span, "..", &mut applicability),
+                c.escape_default()
+            ),
+            applicability,
+        );
+
+        true
+    } else {
+        false
+    }
+}