mod bind_instead_of_map;

mod bytecount;

mod bytes_count_to_len;

mod bytes_nth;

mod case_sensitive_file_extension_comparisons;

mod chars_cmp;

mod chars_cmp_with_unwrap;

mod chars_last_cmp;

mod chars_last_cmp_with_unwrap;

mod chars_next_cmp;

mod chars_next_cmp_with_unwrap;

mod clear_with_drain;

mod clone_on_copy;

mod clone_on_ref_ptr;

mod cloned_instead_of_copied;

mod collapsible_str_replace;

mod double_ended_iterator_last;

mod drain_collect;

mod err_expect;

mod expect_fun_call;

mod extend_with_drain;

mod filetype_is_file;

mod filter_map;

mod filter_map_bool_then;

mod filter_map_identity;

mod filter_map_next;

mod filter_next;

mod flat_map_identity;

mod flat_map_option;

mod format_collect;

mod from_iter_instead_of_collect;

mod get_first;

mod get_last_with_len;

mod get_unwrap;

mod implicit_clone;

mod inefficient_to_string;

mod inspect_for_each;

mod into_iter_on_ref;

mod io_other_error;

mod ip_constant;

mod is_digit_ascii_radix;

mod is_empty;

mod iter_cloned_collect;

mod iter_count;

mod iter_filter;

mod iter_kv_map;

mod iter_next_slice;

mod iter_nth;

mod iter_nth_zero;

mod iter_on_single_or_empty_collections;

mod iter_out_of_bounds;

mod iter_overeager_cloned;

mod iter_skip_next;

mod iter_skip_zero;

mod iter_with_drain;

mod iterator_step_by_zero;

mod join_absolute_paths;

mod lib;

mod lines_filter_map_ok;

mod manual_c_str_literals;

mod manual_contains;

mod manual_inspect;

mod manual_is_variant_and;

mod manual_next_back;

mod manual_ok_or;

mod manual_option_zip;

mod manual_repeat_n;

mod manual_saturating_arithmetic;

mod manual_str_repeat;

mod manual_try_fold;

mod map_all_any_identity;

mod map_clone;

mod map_collect_result_unit;

mod map_err_ignore;

mod map_flatten;

mod map_identity;

mod map_unwrap_or;

mod map_unwrap_or_else;

mod map_with_unused_argument_over_ranges;

mod mut_mutex_lock;

mod needless_as_bytes;

mod needless_character_iteration;

mod needless_collect;

mod needless_option_as_deref;

mod needless_option_take;

mod new_ret_no_self;

mod no_effect_replace;

mod obfuscated_if_else;

mod ok_expect;

mod open_options;

mod option_as_ref_cloned;

mod option_as_ref_deref;

mod option_map_or_none;

mod or_fun_call;

mod or_then_unwrap;

mod path_buf_push_overwrite;

mod path_ends_with_ext;

mod ptr_offset_by_literal;

mod ptr_offset_with_cast;

mod range_zip_with_len;

mod read_line_without_trim;

mod readonly_write_lock;

mod redundant_as_str;

mod repeat_once;

mod result_map_or_else_none;

mod return_and_then;

mod search_is_some;

mod seek_from_current;

mod seek_to_start_instead_of_rewind;

mod should_implement_trait;

mod single_char_add_str;

mod skip_while_next;

mod sliced_string_as_bytes;

mod stable_sort_primitive;

mod str_split;

mod str_splitn;

mod string_extend_chars;

mod string_lit_chars_any;

mod suspicious_command_arg_space;

mod suspicious_map;

mod suspicious_splitn;

mod suspicious_to_owned;

mod swap_with_temporary;

mod type_id_on_box;

mod unbuffered_bytes;

mod uninit_assumed_init;

mod unit_hash;

mod unnecessary_fallible_conversions;

mod unnecessary_filter_map;

mod unnecessary_first_then_check;

mod unnecessary_fold;

mod unnecessary_get_then_check;

mod unnecessary_iter_cloned;

mod unnecessary_join;

mod unnecessary_lazy_eval;

mod unnecessary_literal_unwrap;

mod unnecessary_map_or;

mod unnecessary_map_or_else;

mod unnecessary_min_or_max;

mod unnecessary_sort_by;

mod unnecessary_to_owned;

mod unwrap_expect_used;

mod useless_asref;

mod useless_nonzero_new_unchecked;

mod utils;

mod vec_resize_to_zero;

mod verbose_file_reads;

mod waker_clone_wake;

mod wrong_self_convention;

mod zst_offset;

use clippy_config::Conf;

use clippy_utils::consts::{ConstEvalCtxt, Constant};

use clippy_utils::macros::FormatArgsStorage;

use clippy_utils::msrvs::{self, Msrv};

use clippy_utils::res::{MaybeDef, MaybeTypeckRes};

use clippy_utils::{contains_return, iter_input_pats, peel_blocks, sym};

use rustc_data_structures::fx::FxHashSet;

use rustc_hir::{self as hir, Expr, ExprKind, Node, Stmt, StmtKind, TraitItem, TraitItemKind};

use rustc_lint::{LateContext, LateLintPass, LintContext};

use rustc_middle::ty::TraitRef;

use rustc_session::impl_lint_pass;

use rustc_span::{Span, Symbol};

use crate::matches::manual_filter;

pub use implicit_clone::is_clone_like;

pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;

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)`"

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"

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()`"

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"

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"

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 `.drain(..)` for the sole purpose of clearing a container.

///

/// ### Why is this bad?

/// This creates an unnecessary iterator that is dropped immediately.

///

/// Calling `.clear()` also makes the intent clearer.

///

/// ### Example

/// ```no_run

/// let mut v = vec![1, 2, 3];

/// v.drain(..);

/// ```

/// Use instead:

/// ```no_run

/// let mut v = vec![1, 2, 3];

/// v.clear();

/// ```

#[clippy::version = "1.70.0"]

pub CLEAR_WITH_DRAIN,

nursery,

"calling `drain` in order to `clear` a container"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `.clone()` on a `Copy` type.

///

/// ### Why is this bad?

/// The only reason `Copy` types implement `Clone` is for

/// generics, not for using the `clone` method on a concrete type.

///

/// ### Example

/// ```no_run

/// 42u64.clone();

/// ```

#[clippy::version = "pre 1.29.0"]

pub CLONE_ON_COPY,

complexity,

"using `clone` on a `Copy` type"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `.clone()` on a ref-counted pointer,

/// (`Rc`, `Arc`, `rc::Weak`, or `sync::Weak`), and suggests calling Clone via unified

/// function syntax instead (e.g., `Rc::clone(foo)`).

///

/// ### Why restrict this?

/// Calling `.clone()` on an `Rc`, `Arc`, or `Weak`

/// can obscure the fact that only the pointer is being cloned, not the underlying

/// data.

///

/// ### Example

/// ```no_run

/// # use std::rc::Rc;

/// let x = Rc::new(1);

///

/// x.clone();

/// ```

///

/// Use instead:

/// ```no_run

/// # use std::rc::Rc;

/// # let x = Rc::new(1);

/// Rc::clone(&x);

/// ```

#[clippy::version = "pre 1.29.0"]

pub CLONE_ON_REF_PTR,

restriction,

"using `clone` on a ref-counted pointer"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `cloned()` on an `Iterator` or `Option` where

/// `copied()` could be used instead.

///

/// ### Why is this bad?

/// `copied()` is better because it guarantees that the type being cloned

/// implements `Copy`.

///

/// ### Example

/// ```no_run

/// [1, 2, 3].iter().cloned();

/// ```

/// Use instead:

/// ```no_run

/// [1, 2, 3].iter().copied();

/// ```

#[clippy::version = "1.53.0"]

pub CLONED_INSTEAD_OF_COPIED,

pedantic,

"used `cloned` where `copied` could be used instead"

declare_clippy_lint! {

/// ### What it does

/// Checks for consecutive calls to `str::replace` (2 or more)

/// that can be collapsed into a single call.

///

/// ### Why is this bad?

/// Consecutive `str::replace` calls scan the string multiple times

/// with repetitive code.

///

/// ### Example

/// ```no_run

/// let hello = "hesuo worpd"

/// .replace('s', "l")

/// .replace("u", "l")

/// .replace('p', "l");

/// ```

/// Use instead:

/// ```no_run

/// let hello = "hesuo worpd".replace(['s', 'u', 'p'], "l");

/// ```

#[clippy::version = "1.65.0"]

pub COLLAPSIBLE_STR_REPLACE,

perf,

"collapse consecutive calls to str::replace (2 or more) into a single call"

declare_clippy_lint! {

/// ### What it does

/// It identifies calls to `.is_empty()` on constant values.

///

/// ### Why is this bad?

/// String literals and constant values are known at compile time. Checking if they

/// are empty will always return the same value. This might not be the intention of

/// the expression.

///

/// ### Example

/// ```no_run

/// let value = "";

/// if value.is_empty() {

/// println!("the string is empty");

/// }

/// ```

/// Use instead:

/// ```no_run

/// println!("the string is empty");

/// ```

#[clippy::version = "1.79.0"]

pub CONST_IS_EMPTY,

suspicious,

"is_empty() called on strings known at compile time"

declare_clippy_lint! {

/// ### What it does

///

/// Checks for `Iterator::last` being called on a `DoubleEndedIterator`, which can be replaced

/// with `DoubleEndedIterator::next_back`.

///

/// ### Why is this bad?

///

/// `Iterator::last` is implemented by consuming the iterator, which is unnecessary if

/// the iterator is a `DoubleEndedIterator`. Since Rust traits do not allow specialization,

/// `Iterator::last` cannot be optimized for `DoubleEndedIterator`.

///

/// ### Example

/// ```no_run

/// let last_arg = "echo hello world".split(' ').last();

/// ```

/// Use instead:

/// ```no_run

/// let last_arg = "echo hello world".split(' ').next_back();

/// ```

#[clippy::version = "1.86.0"]

pub DOUBLE_ENDED_ITERATOR_LAST,

perf,

"using `Iterator::last` on a `DoubleEndedIterator`"

declare_clippy_lint! {

/// ### What it does

/// Checks for calls to `.drain()` that clear the collection, immediately followed by a call to `.collect()`.

///

/// > "Collection" in this context refers to any type with a `drain` method:

/// > `Vec`, `VecDeque`, `BinaryHeap`, `HashSet`,`HashMap`, `String`

///

/// ### Why is this bad?

/// Using `mem::take` is faster as it avoids the allocation.

/// When using `mem::take`, the old collection is replaced with an empty one and ownership of

/// the old collection is returned.

///

/// ### Known issues

/// `mem::take(&mut vec)` is almost equivalent to `vec.drain(..).collect()`, except that

/// it also moves the **capacity**. The user might have explicitly written it this way

/// to keep the capacity on the original `Vec`.

///

/// ### Example

/// ```no_run

/// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {

/// v.drain(..).collect()

/// }

/// ```

/// Use instead:

/// ```no_run

/// use std::mem;

/// fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {

/// mem::take(v)

/// }

/// ```

#[clippy::version = "1.72.0"]

pub DRAIN_COLLECT,

perf,

"calling `.drain(..).collect()` to move all elements into a new collection"

declare_clippy_lint! {

/// ### What it does

/// Checks for `.err().expect()` calls on the `Result` type.

///

/// ### Why is this bad?

/// `.expect_err()` can be called directly to avoid the extra type conversion from `err()`.

///

/// ### Example

/// ```should_panic

/// let x: Result<u32, &str> = Ok(10);

/// x.err().expect("Testing err().expect()");

/// ```

/// Use instead:

/// ```should_panic

/// let x: Result<u32, &str> = Ok(10);

/// x.expect_err("Testing expect_err");

/// ```

#[clippy::version = "1.62.0"]

pub ERR_EXPECT,

style,

r#"using `.err().expect("")` when `.expect_err("")` can be used"#

declare_clippy_lint! {

/// ### What it does

/// Checks for calls to `.expect(&format!(...))`, `.expect(foo(..))`,

/// etc., and suggests to use `unwrap_or_else` instead

///

/// ### Why is this bad?

/// The function will always be called.

///

/// ### Known problems

/// If the function has side-effects, not calling it will

/// change the semantics of the program, but you shouldn't rely on that anyway.

///

/// ### Example

/// ```no_run

/// # let foo = Some(String::new());

/// # let err_code = "418";

/// # let err_msg = "I'm a teapot";

/// foo.expect(&format!("Err {}: {}", err_code, err_msg));

///

/// // or

///

/// # let foo = Some(String::new());

/// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());

/// ```

///

/// Use instead:

/// ```no_run

/// # let foo = Some(String::new());

/// # let err_code = "418";

/// # let err_msg = "I'm a teapot";

/// foo.unwrap_or_else(|| panic!("Err {}: {}", err_code, err_msg));

/// ```

#[clippy::version = "pre 1.29.0"]

pub EXPECT_FUN_CALL,

perf,

"using any `expect` method with a function call"

declare_clippy_lint! {

/// ### What it does

/// Checks for `.expect()` or `.expect_err()` calls on `Result`s and `.expect()` call on `Option`s.

///

/// ### Why restrict this?

/// Usually it is better to handle the `None` or `Err` case.

/// Still, for a lot of quick-and-dirty code, `expect` is a good choice, which is why

/// this lint is `Allow` by default.

///

/// `result.expect()` will let the thread panic on `Err`

/// values. Normally, you want to implement more sophisticated error handling,

/// and propagate errors upwards with `?` operator.

///

/// ### Examples

/// ```rust,ignore

/// # let option = Some(1);

/// # let result: Result<usize, ()> = Ok(1);

/// option.expect("one");

/// result.expect("one");

/// ```

///

/// Use instead:

/// ```rust,ignore

/// # let option = Some(1);

/// # let result: Result<usize, ()> = Ok(1);

/// option?;

///

/// // or

///

/// result?;

/// ```

#[clippy::version = "1.45.0"]

pub EXPECT_USED,

restriction,

"using `.expect()` on `Result` or `Option`, which might be better handled"

declare_clippy_lint! {

/// ### What it does

/// Checks for occurrences where one vector gets extended instead of append

///

/// ### Why is this bad?

/// Using `append` instead of `extend` is more concise and faster

///

/// ### Example

/// ```no_run

/// let mut a = vec![1, 2, 3];

/// let mut b = vec![4, 5, 6];

///

/// a.extend(b.drain(..));

/// ```

///

/// Use instead:

/// ```no_run

/// let mut a = vec![1, 2, 3];

/// let mut b = vec![4, 5, 6];

///

/// a.append(&mut b);

/// ```

#[clippy::version = "1.55.0"]

pub EXTEND_WITH_DRAIN,

perf,

"using vec.append(&mut vec) to move the full range of a vector to another"

declare_clippy_lint! {

/// ### What it does

/// Checks for `FileType::is_file()`.

///

/// ### Why restrict this?

/// When people testing a file type with `FileType::is_file`

/// they are testing whether a path is something they can get bytes from. But

/// `is_file` doesn't cover special file types in unix-like systems, and doesn't cover

/// symlink in windows. Using `!FileType::is_dir()` is a better way to that intention.

///

/// ### Example

/// ```no_run

/// # || {

/// let metadata = std::fs::metadata("foo.txt")?;

/// let filetype = metadata.file_type();

///

/// if filetype.is_file() {

/// // read file

/// }

/// # Ok::<_, std::io::Error>(())

/// # };

/// ```

///

/// should be written as:

///

/// ```no_run

/// # || {

/// let metadata = std::fs::metadata("foo.txt")?;

/// let filetype = metadata.file_type();

///

/// if !filetype.is_dir() {

/// // read file

/// }

/// # Ok::<_, std::io::Error>(())

/// # };

/// ```

#[clippy::version = "1.42.0"]

pub FILETYPE_IS_FILE,

restriction,

"`FileType::is_file` is not recommended to test for readable file type"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `bool::then` in `Iterator::filter_map`.

///

/// ### Why is this bad?

/// This can be written with `filter` then `map` instead, which would reduce nesting and

/// separates the filtering from the transformation phase. This comes with no cost to

/// performance and is just cleaner.

///

/// ### Limitations

/// Does not lint `bool::then_some`, as it eagerly evaluates its arguments rather than lazily.

/// This can create differing behavior, so better safe than sorry.

///

/// ### Example

/// ```no_run

/// # fn really_expensive_fn(i: i32) -> i32 { i }

/// # let v = vec![];

/// _ = v.into_iter().filter_map(|i| (i % 2 == 0).then(|| really_expensive_fn(i)));

/// ```

/// Use instead:

/// ```no_run

/// # fn really_expensive_fn(i: i32) -> i32 { i }

/// # let v = vec![];

/// _ = v.into_iter().filter(|i| i % 2 == 0).map(|i| really_expensive_fn(i));

/// ```

#[clippy::version = "1.73.0"]

pub FILTER_MAP_BOOL_THEN,

style,

"checks for usage of `bool::then` in `Iterator::filter_map`"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `filter_map(|x| x)`.

///

/// ### Why is this bad?

/// Readability, this can be written more concisely by using `flatten`.

///

/// ### Example

/// ```no_run

/// # let iter = vec![Some(1)].into_iter();

/// iter.filter_map(|x| x);

/// ```

/// Use instead:

/// ```no_run

/// # let iter = vec![Some(1)].into_iter();

/// iter.flatten();

/// ```

#[clippy::version = "1.52.0"]

pub FILTER_MAP_IDENTITY,

complexity,

"call to `filter_map` where `flatten` is sufficient"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `_.filter_map(_).next()`.

///

/// ### Why is this bad?

/// Readability, this can be written more concisely as

/// `_.find_map(_)`.

///

/// ### Example

/// ```no_run

/// (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();

/// ```

/// Can be written as

///

/// ```no_run

/// (0..3).find_map(|x| if x == 2 { Some(x) } else { None });

/// ```

#[clippy::version = "1.36.0"]

pub FILTER_MAP_NEXT,

pedantic,

"using combination of `filter_map` and `next` which can usually be written as a single method call"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `_.filter(_).next()`.

///

/// ### Why is this bad?

/// Readability, this can be written more concisely as

/// `_.find(_)`.

///

/// ### Example

/// ```no_run

/// # let vec = vec![1];

/// vec.iter().filter(|x| **x == 0).next();

/// ```

///

/// Use instead:

/// ```no_run

/// # let vec = vec![1];

/// vec.iter().find(|x| **x == 0);

/// ```

#[clippy::version = "pre 1.29.0"]

pub FILTER_NEXT,

complexity,

"using `filter(p).next()`, which is more succinctly expressed as `.find(p)`"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `flat_map(|x| x)`.

///

/// ### Why is this bad?

/// Readability, this can be written more concisely by using `flatten`.

///

/// ### Example

/// ```no_run

/// # let iter = vec![vec![0]].into_iter();

/// iter.flat_map(|x| x);

/// ```

/// Can be written as

/// ```no_run

/// # let iter = vec![vec![0]].into_iter();

/// iter.flatten();

/// ```

#[clippy::version = "1.39.0"]

pub FLAT_MAP_IDENTITY,

complexity,

"call to `flat_map` where `flatten` is sufficient"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `Iterator::flat_map()` where `filter_map()` could be

/// used instead.

///

/// ### Why is this bad?

/// `filter_map()` is known to always produce 0 or 1 output items per input item,

/// rather than however many the inner iterator type produces.

/// Therefore, it maintains the upper bound in `Iterator::size_hint()`,

/// and communicates to the reader that the input items are not being expanded into

/// multiple output items without their having to notice that the mapping function

/// returns an `Option`.

///

/// ### Example

/// ```no_run

/// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();

/// ```

/// Use instead:

/// ```no_run

/// let nums: Vec<i32> = ["1", "2", "whee!"].iter().filter_map(|x| x.parse().ok()).collect();

/// ```

#[clippy::version = "1.53.0"]

pub FLAT_MAP_OPTION,

pedantic,

"used `flat_map` where `filter_map` could be used instead"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `.map(|_| format!(..)).collect::<String>()`.

///

/// ### Why is this bad?

/// This allocates a new string for every element in the iterator.

/// This can be done more efficiently by creating the `String` once and appending to it in `Iterator::fold`,

/// using either the `write!` macro which supports exactly the same syntax as the `format!` macro,

/// or concatenating with `+` in case the iterator yields `&str`/`String`.

///

/// Note also that `write!`-ing into a `String` can never fail, despite the return type of `write!` being `std::fmt::Result`,

/// so it can be safely ignored or unwrapped.

///

/// ### Example

/// ```no_run

/// fn hex_encode(bytes: &[u8]) -> String {

/// bytes.iter().map(|b| format!("{b:02X}")).collect()

/// }

/// ```

/// Use instead:

/// ```no_run

/// use std::fmt::Write;

/// fn hex_encode(bytes: &[u8]) -> String {

/// bytes.iter().fold(String::new(), |mut output, b| {

/// let _ = write!(output, "{b:02X}");

/// output

/// })

/// }

/// ```

#[clippy::version = "1.73.0"]

pub FORMAT_COLLECT,

pedantic,

"`format!`ing every element in a collection, then collecting the strings into a new `String`"

declare_clippy_lint! {

/// ### What it does

/// Checks for `from_iter()` function calls on types that implement the `FromIterator`

/// trait.

///

/// ### Why is this bad?

/// If it's needed to create a collection from the contents of an iterator, the `Iterator::collect(_)`

/// method is preferred. However, when it's needed to specify the container type,

/// `Vec::from_iter(_)` can be more readable than using a turbofish (e.g. `_.collect::<Vec<_>>()`). See

/// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)

///

/// ### Example

/// ```no_run

/// let five_fives = std::iter::repeat(5).take(5);

///

/// let v = Vec::from_iter(five_fives);

///

/// assert_eq!(v, vec![5, 5, 5, 5, 5]);

/// ```

/// Use instead:

/// ```no_run

/// let five_fives = std::iter::repeat(5).take(5);

///

/// let v: Vec<i32> = five_fives.collect();

///

/// assert_eq!(v, vec![5, 5, 5, 5, 5]);

/// ```

/// but prefer to use

/// ```no_run

/// let numbers: Vec<i32> = FromIterator::from_iter(1..=5);

/// ```

/// instead of

/// ```no_run

/// let numbers = (1..=5).collect::<Vec<_>>();

/// ```

#[clippy::version = "1.49.0"]

pub FROM_ITER_INSTEAD_OF_COLLECT,

pedantic,

"use `.collect()` instead of `::from_iter()`"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `x.get(0)` instead of

/// `x.first()` or `x.front()`.

///

/// ### Why is this bad?

/// Using `x.first()` for `Vec`s and slices or `x.front()`

/// for `VecDeque`s is easier to read and has the same result.

///

/// ### Example

/// ```no_run

/// let x = vec![2, 3, 5];

/// let first_element = x.get(0);

/// ```

///

/// Use instead:

/// ```no_run

/// let x = vec![2, 3, 5];

/// let first_element = x.first();

/// ```

#[clippy::version = "1.63.0"]

pub GET_FIRST,

style,

"Using `x.get(0)` when `x.first()` or `x.front()` is simpler"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `x.get(x.len() - 1)` instead of

/// `x.last()`.

///

/// ### Why is this bad?

/// Using `x.last()` is easier to read and has the same

/// result.

///

/// Note that using `x[x.len() - 1]` is semantically different from

/// `x.last()`. Indexing into the array will panic on out-of-bounds

/// accesses, while `x.get()` and `x.last()` will return `None`.

///

/// There is another lint (get_unwrap) that covers the case of using

/// `x.get(index).unwrap()` instead of `x[index]`.

///

/// ### Example

/// ```no_run

/// let x = vec![2, 3, 5];

/// let last_element = x.get(x.len() - 1);

/// ```

///

/// Use instead:

/// ```no_run

/// let x = vec![2, 3, 5];

/// let last_element = x.last();

/// ```

#[clippy::version = "1.37.0"]

pub GET_LAST_WITH_LEN,

complexity,

"Using `x.get(x.len() - 1)` when `x.last()` is correct and simpler"

declare_clippy_lint! {

/// ### What it does

/// Checks for usage of `.get().unwrap()` (or

/// `.get_mut().unwrap`) on a standard library type which implements `Index`

///