Merge commit '8d14c94b5c0a66241b4244f1c60ac5859cec1d97' into clippyup

author flip1995 <philipp.krones@embecosm.com>

Mon, 17 Jan 2022 12:29:07 +0000 (13:29 +0100)

committer flip1995 <philipp.krones@embecosm.com>

Mon, 17 Jan 2022 12:29:07 +0000 (13:29 +0100)
author flip1995 <philipp.krones@embecosm.com>
Mon, 17 Jan 2022 12:29:07 +0000 (13:29 +0100)
committer flip1995 <philipp.krones@embecosm.com>
Mon, 17 Jan 2022 12:29:07 +0000 (13:29 +0100)
diff --cc src/tools/clippy/CHANGELOG.md

index 8f4da9a382792a31443c9a81c6db1794ff2a04d1,0000000000000000000000000000000000000000..258a8256f53177752b46ed1914cd5a1789e639aa

mode 100644,000000..100644
--- 1/src/tools/clippy/CHANGELOG.md
--- /dev/null
+++ b/src/tools/clippy/CHANGELOG.md
@@@ -1,3390 -1,0 +1,3391 @@@
+ +# Changelog
+ +
+ +All notable changes to this project will be documented in this file.
+ +See [Changelog Update](doc/changelog_update.md) if you want to update this
+ +document.
+ +
+ +## Unreleased / In Rust Nightly
+ +
+ +[e181011...master](https://github.com/rust-lang/rust-clippy/compare/e181011...master)
+ +
+ +## Rust 1.58 (beta)
+ +
+ +Current beta, release 2022-01-13
+ +
+ +[00e31fa...e181011](https://github.com/rust-lang/rust-clippy/compare/00e31fa...e181011)
+ +
+ +### New lints
+ +
+ +* [`transmute_num_to_bytes`]
+ +  [#7805](https://github.com/rust-lang/rust-clippy/pull/7805)
+ +* [`match_str_case_mismatch`]
+ +  [#7806](https://github.com/rust-lang/rust-clippy/pull/7806)
+ +* [`format_in_format_args`], [`to_string_in_format_args`]
+ +  [#7743](https://github.com/rust-lang/rust-clippy/pull/7743)
+ +* [`uninit_vec`]
+ +  [#7682](https://github.com/rust-lang/rust-clippy/pull/7682)
+ +* [`fn_to_numeric_cast_any`]
+ +  [#7705](https://github.com/rust-lang/rust-clippy/pull/7705)
+ +* [`undocumented_unsafe_blocks`]
+ +  [#7748](https://github.com/rust-lang/rust-clippy/pull/7748)
+ +* [`trailing_empty_array`]
+ +  [#7838](https://github.com/rust-lang/rust-clippy/pull/7838)
+ +* [`string_slice`]
+ +  [#7878](https://github.com/rust-lang/rust-clippy/pull/7878)
+ +
+ +### Moves or deprecations of lints
+ +
+ +* Move [`non_send_fields_in_send_ty`] to `suspicious`
+ +  [#7874](https://github.com/rust-lang/rust-clippy/pull/7874)
+ +* Move [`non_ascii_literal`] to `restriction`
+ +  [#7907](https://github.com/rust-lang/rust-clippy/pull/7907)
+ +
+ +### Changes that expand what code existing lints cover
+ +
+ +* [`question_mark`] now covers `Result`
+ +  [#7840](https://github.com/rust-lang/rust-clippy/pull/7840)
+ +* Make [`useless_format`] recognize bare `format!("")`
+ +  [#7801](https://github.com/rust-lang/rust-clippy/pull/7801)
+ +* Lint on underscored variables with no side effects in [`no_effect`]
+ +  [#7775](https://github.com/rust-lang/rust-clippy/pull/7775)
+ +* Expand [`match_ref_pats`] to check for multiple reference patterns
+ +  [#7800](https://github.com/rust-lang/rust-clippy/pull/7800)
+ +
+ +### False positive fixes
+ +
+ +* Fix false positive of [`implicit_saturating_sub`] with `else` clause
+ +  [#7832](https://github.com/rust-lang/rust-clippy/pull/7832)
+ +* Fix [`question_mark`] when there is call in conditional predicate
+ +  [#7860](https://github.com/rust-lang/rust-clippy/pull/7860)
+ +* [`mut_mut`] no longer lints when type is defined in external macros
+ +  [#7795](https://github.com/rust-lang/rust-clippy/pull/7795)
+ +* Avoid [`eq_op`] in test functions
+ +  [#7811](https://github.com/rust-lang/rust-clippy/pull/7811)
+ +* [`cast_possible_truncation`] no longer lints when cast is coming from `signum`
+ +  method call [#7850](https://github.com/rust-lang/rust-clippy/pull/7850)
+ +* [`match_str_case_mismatch`] no longer lints on uncased characters
+ +  [#7865](https://github.com/rust-lang/rust-clippy/pull/7865)
+ +* [`ptr_arg`] no longer lints references to type aliases
+ +  [#7890](https://github.com/rust-lang/rust-clippy/pull/7890)
+ +* [`missing_safety_doc`] now also accepts "implementation safety" headers
+ +  [#7856](https://github.com/rust-lang/rust-clippy/pull/7856)
+ +* [`missing_safety_doc`] no longer lints if any parent has `#[doc(hidden)]`
+ +  attribute [#7849](https://github.com/rust-lang/rust-clippy/pull/7849)
+ +* [`if_not_else`] now ignores else-if statements
+ +  [#7895](https://github.com/rust-lang/rust-clippy/pull/7895)
+ +* Avoid linting [`cast_possible_truncation`] on bit-reducing operations
+ +  [#7819](https://github.com/rust-lang/rust-clippy/pull/7819)
+ +* Avoid linting [`field_reassign_with_default`] when `Drop` and `Copy` are
+ +  involved [#7794](https://github.com/rust-lang/rust-clippy/pull/7794)
+ +* [`unnecessary_sort_by`] now checks if argument implements `Ord` trait
+ +  [#7824](https://github.com/rust-lang/rust-clippy/pull/7824)
+ +* Fix false positive in [`match_overlapping_arm`]
+ +  [#7847](https://github.com/rust-lang/rust-clippy/pull/7847)
+ +* Prevent [`needless_lifetimes`] false positive in `async` function definition
+ +  [#7901](https://github.com/rust-lang/rust-clippy/pull/7901)
+ +
+ +### Suggestion fixes/improvements
+ +
+ +* Keep an initial `::` when [`doc_markdown`] suggests to use ticks
+ +  [#7916](https://github.com/rust-lang/rust-clippy/pull/7916)
+ +* Add a machine applicable suggestion for the [`doc_markdown`] missing backticks
+ +  lint [#7904](https://github.com/rust-lang/rust-clippy/pull/7904)
+ +* [`equatable_if_let`] no longer expands macros in the suggestion
+ +  [#7788](https://github.com/rust-lang/rust-clippy/pull/7788)
+ +* Make [`shadow_reuse`] suggestion less verbose
+ +  [#7782](https://github.com/rust-lang/rust-clippy/pull/7782)
+ +
+ +### ICE fixes
+ +
+ +* Fix ICE in [`enum_variant_names`]
+ +  [#7873](https://github.com/rust-lang/rust-clippy/pull/7873)
+ +* Fix ICE in [`undocumented_unsafe_blocks`]
+ +  [#7891](https://github.com/rust-lang/rust-clippy/pull/7891)
+ +
+ +### Documentation improvements
+ +
+ +* Fixed naive doc formatting for `#[must_use]` lints ([`must_use_unit`],
+ +  [`double_must_use`], [`must_use_candidate`], [`let_underscore_must_use`])
+ +  [#7827](https://github.com/rust-lang/rust-clippy/pull/7827)
+ +* Fix typo in example for [`match_result_ok`]
+ +  [#7815](https://github.com/rust-lang/rust-clippy/pull/7815)
+ +
+ +### Others
+ +
+ +* Allow giving reasons for [`disallowed_types`]
+ +  [#7791](https://github.com/rust-lang/rust-clippy/pull/7791)
+ +* Fix [`manual_assert`] and [`match_wild_err_arm`] for `#![no_std]` and Rust
+ +  2021. [#7851](https://github.com/rust-lang/rust-clippy/pull/7851)
+ +* Fix regression in [`semicolon_if_nothing_returned`] on macros containing while
+ +  loops [#7789](https://github.com/rust-lang/rust-clippy/pull/7789)
+ +* Added a new configuration `literal-suffix-style` to enforce a certain style
+ +  writing [`unseparated_literal_suffix`]
+ +  [#7726](https://github.com/rust-lang/rust-clippy/pull/7726)
+ +
+ +## Rust 1.57
+ +
+ +Current stable, released 2021-12-02
+ +
+ +[7bfc26e...00e31fa](https://github.com/rust-lang/rust-clippy/compare/7bfc26e...00e31fa)
+ +
+ +### New Lints
+ +
+ +* [`negative_feature_names`]
+ +  [#7539](https://github.com/rust-lang/rust-clippy/pull/7539)
+ +* [`redundant_feature_names`]
+ +  [#7539](https://github.com/rust-lang/rust-clippy/pull/7539)
+ +* [`mod_module_files`]
+ +  [#7543](https://github.com/rust-lang/rust-clippy/pull/7543)
+ +* [`self_named_module_files`]
+ +  [#7543](https://github.com/rust-lang/rust-clippy/pull/7543)
+ +* [`manual_split_once`]
+ +  [#7565](https://github.com/rust-lang/rust-clippy/pull/7565)
+ +* [`derivable_impls`]
+ +  [#7570](https://github.com/rust-lang/rust-clippy/pull/7570)
+ +* [`needless_option_as_deref`]
+ +  [#7596](https://github.com/rust-lang/rust-clippy/pull/7596)
+ +* [`iter_not_returning_iterator`]
+ +  [#7610](https://github.com/rust-lang/rust-clippy/pull/7610)
+ +* [`same_name_method`]
+ +  [#7653](https://github.com/rust-lang/rust-clippy/pull/7653)
+ +* [`manual_assert`] [#7669](https://github.com/rust-lang/rust-clippy/pull/7669)
+ +* [`non_send_fields_in_send_ty`]
+ +  [#7709](https://github.com/rust-lang/rust-clippy/pull/7709)
+ +* [`equatable_if_let`]
+ +  [#7762](https://github.com/rust-lang/rust-clippy/pull/7762)
+ +
+ +### Moves and Deprecations
+ +
+ +* Move [`shadow_unrelated`] to `restriction`
+ +  [#7338](https://github.com/rust-lang/rust-clippy/pull/7338)
+ +* Move [`option_if_let_else`] to `nursery`
+ +  [#7568](https://github.com/rust-lang/rust-clippy/pull/7568)
+ +* Move [`branches_sharing_code`] to `nursery`
+ +  [#7595](https://github.com/rust-lang/rust-clippy/pull/7595)
+ +* Rename `if_let_some_result` to [`match_result_ok`] which now also handles
+ +  `while let` cases [#7608](https://github.com/rust-lang/rust-clippy/pull/7608)
+ +* Move [`many_single_char_names`] to `pedantic`
+ +  [#7671](https://github.com/rust-lang/rust-clippy/pull/7671)
+ +* Move [`float_cmp`] to `pedantic`
+ +  [#7692](https://github.com/rust-lang/rust-clippy/pull/7692)
+ +* Rename `box_vec` to [`box_collection`] and lint on more general cases
+ +  [#7693](https://github.com/rust-lang/rust-clippy/pull/7693)
+ +* Uplift `invalid_atomic_ordering` to rustc
+ +  [rust-lang/rust#84039](https://github.com/rust-lang/rust/pull/84039)
+ +
+ +### Enhancements
+ +
+ +* Rewrite the `shadow*` lints, so that they find a lot more shadows and are not
+ +  limited to certain patterns
+ +  [#7338](https://github.com/rust-lang/rust-clippy/pull/7338)
+ +* The `avoid-breaking-exported-api` configuration now also works for
+ +  [`box_collection`], [`redundant_allocation`], [`rc_buffer`], [`vec_box`],
+ +  [`option_option`], [`linkedlist`], [`rc_mutex`]
+ +  [#7560](https://github.com/rust-lang/rust-clippy/pull/7560)
+ +* [`unnecessary_unwrap`]: Now also checks for `expect`s
+ +  [#7584](https://github.com/rust-lang/rust-clippy/pull/7584)
+ +* [`disallowed_methods`]: Allow adding a reason that will be displayed with the
+ +  lint message
+ +  [#7621](https://github.com/rust-lang/rust-clippy/pull/7621)
+ +* [`approx_constant`]: Now checks the MSRV for `LOG10_2` and `LOG2_10`
+ +  [#7629](https://github.com/rust-lang/rust-clippy/pull/7629)
+ +* [`approx_constant`]: Add `TAU`
+ +  [#7642](https://github.com/rust-lang/rust-clippy/pull/7642)
+ +* [`needless_borrow`]: Now also lints on needless mutable borrows
+ +  [#7657](https://github.com/rust-lang/rust-clippy/pull/7657)
+ +* [`missing_safety_doc`]: Now also lints on unsafe traits
+ +  [#7734](https://github.com/rust-lang/rust-clippy/pull/7734)
+ +
+ +### False Positive Fixes
+ +
+ +* [`manual_map`]: No longer lints when the option is borrowed in the match and
+ +  also consumed in the arm
+ +  [#7531](https://github.com/rust-lang/rust-clippy/pull/7531)
+ +* [`filter_next`]: No longer lints if `filter` method is not the
+ +  `Iterator::filter` method
+ +  [#7562](https://github.com/rust-lang/rust-clippy/pull/7562)
+ +* [`manual_flatten`]: No longer lints if expression is used after `if let`
+ +  [#7566](https://github.com/rust-lang/rust-clippy/pull/7566)
+ +* [`option_if_let_else`]: Multiple fixes
+ +  [#7573](https://github.com/rust-lang/rust-clippy/pull/7573)
+ +    * `break` and `continue` statements local to the would-be closure are
+ +      allowed
+ +    * Don't lint in const contexts
+ +    * Don't lint when yield expressions are used
+ +    * Don't lint when the captures made by the would-be closure conflict with
+ +      the other branch
+ +    * Don't lint when a field of a local is used when the type could be
+ +      potentially moved from
+ +    * In some cases, don't lint when scrutinee expression conflicts with the
+ +      captures of the would-be closure
+ +* [`redundant_allocation`]: No longer lints on `Box<Box<dyn T>>` which replaces
+ +  wide pointers with thin pointers
+ +  [#7592](https://github.com/rust-lang/rust-clippy/pull/7592)
+ +* [`bool_assert_comparison`]: No longer lints on types that do not implement the
+ +  `Not` trait with `Output = bool`
+ +  [#7605](https://github.com/rust-lang/rust-clippy/pull/7605)
+ +* [`mut_range_bound`]: No longer lints on range bound mutations, that are
+ +  immediately followed by a `break;`
+ +  [#7607](https://github.com/rust-lang/rust-clippy/pull/7607)
+ +* [`mutable_key_type`]: Improve accuracy and document remaining false positives
+ +  and false negatives
+ +  [#7640](https://github.com/rust-lang/rust-clippy/pull/7640)
+ +* [`redundant_closure`]: Rewrite the lint to fix various false positives and
+ +  false negatives [#7661](https://github.com/rust-lang/rust-clippy/pull/7661)
+ +* [`large_enum_variant`]: No longer wrongly identifies the second largest
+ +  variant [#7677](https://github.com/rust-lang/rust-clippy/pull/7677)
+ +* [`needless_return`]: No longer lints on let-else expressions
+ +  [#7685](https://github.com/rust-lang/rust-clippy/pull/7685)
+ +* [`suspicious_else_formatting`]: No longer lints in proc-macros
+ +  [#7707](https://github.com/rust-lang/rust-clippy/pull/7707)
+ +* [`excessive_precision`]: No longer lints when in some cases the float was
+ +  already written in the shortest form
+ +  [#7722](https://github.com/rust-lang/rust-clippy/pull/7722)
+ +* [`doc_markdown`]: No longer lints on intra-doc links
+ +  [#7772](https://github.com/rust-lang/rust-clippy/pull/7772)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`unnecessary_operation`]: Recommend using an `assert!` instead of using a
+ +  function call in an indexing operation
+ +  [#7453](https://github.com/rust-lang/rust-clippy/pull/7453)
+ +* [`manual_split_once`]: Produce semantically equivalent suggestion when
+ +  `rsplitn` is used [#7663](https://github.com/rust-lang/rust-clippy/pull/7663)
+ +* [`while_let_on_iterator`]: Produce correct suggestion when using `&mut`
+ +  [#7690](https://github.com/rust-lang/rust-clippy/pull/7690)
+ +* [`manual_assert`]: No better handles complex conditions
+ +  [#7741](https://github.com/rust-lang/rust-clippy/pull/7741)
+ +* Correctly handle signs in exponents in numeric literals lints
+ +  [#7747](https://github.com/rust-lang/rust-clippy/pull/7747)
+ +* [`suspicious_map`]: Now also suggests to use `inspect` as an alternative
+ +  [#7770](https://github.com/rust-lang/rust-clippy/pull/7770)
+ +* Drop exponent from suggestion if it is 0 in numeric literals lints
+ +  [#7774](https://github.com/rust-lang/rust-clippy/pull/7774)
+ +
+ +### ICE Fixes
+ +
+ +* [`implicit_hasher`]
+ +  [#7761](https://github.com/rust-lang/rust-clippy/pull/7761)
+ +
+ +### Others
+ +
+ +* Clippy now uses the 2021
+ +  [Edition!](https://www.youtube.com/watch?v=q0aNduqb2Ro)
+ +  [#7664](https://github.com/rust-lang/rust-clippy/pull/7664)
+ +
+ +## Rust 1.56
+ +
+ +Released 2021-10-21
+ +
+ +[74d1561...7bfc26e](https://github.com/rust-lang/rust-clippy/compare/74d1561...7bfc26e)
+ +
+ +### New Lints
+ +
+ +* [`unwrap_or_else_default`]
+ +  [#7516](https://github.com/rust-lang/rust-clippy/pull/7516)
+ +
+ +### Enhancements
+ +
+ +* [`needless_continue`]: Now also lints in `loop { continue; }` case
+ +  [#7477](https://github.com/rust-lang/rust-clippy/pull/7477)
+ +* [`disallowed_types`]: Now also primitive types can be disallowed
+ +  [#7488](https://github.com/rust-lang/rust-clippy/pull/7488)
+ +* [`manual_swap`]: Now also lints on xor swaps
+ +  [#7506](https://github.com/rust-lang/rust-clippy/pull/7506)
+ +* [`map_flatten`]: Now also lints on the `Result` type
+ +  [#7522](https://github.com/rust-lang/rust-clippy/pull/7522)
+ +* [`no_effect`]: Now also lints on inclusive ranges
+ +  [#7556](https://github.com/rust-lang/rust-clippy/pull/7556)
+ +
+ +### False Positive Fixes
+ +
+ +* [`nonstandard_macro_braces`]: No longer lints on similar named nested macros
+ +  [#7478](https://github.com/rust-lang/rust-clippy/pull/7478)
+ +* [`too_many_lines`]: No longer lints in closures to avoid duplicated diagnostics
+ +  [#7534](https://github.com/rust-lang/rust-clippy/pull/7534)
+ +* [`similar_names`]: No longer complains about `iter` and `item` being too
+ +  similar [#7546](https://github.com/rust-lang/rust-clippy/pull/7546)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`similar_names`]: No longer suggests to insert or add an underscore as a fix
+ +  [#7221](https://github.com/rust-lang/rust-clippy/pull/7221)
+ +* [`new_without_default`]: No longer shows the full qualified type path when
+ +  suggesting adding a `Default` implementation
+ +  [#7493](https://github.com/rust-lang/rust-clippy/pull/7493)
+ +* [`while_let_on_iterator`]: Now suggests re-borrowing mutable references
+ +  [#7520](https://github.com/rust-lang/rust-clippy/pull/7520)
+ +* [`extend_with_drain`]: Improve code suggestion for mutable and immutable
+ +  references [#7533](https://github.com/rust-lang/rust-clippy/pull/7533)
+ +* [`trivially_copy_pass_by_ref`]: Now properly handles `Self` type
+ +  [#7535](https://github.com/rust-lang/rust-clippy/pull/7535)
+ +* [`never_loop`]: Now suggests using `if let` instead of a `for` loop when
+ +  applicable [#7541](https://github.com/rust-lang/rust-clippy/pull/7541)
+ +
+ +### Documentation Improvements
+ +
+ +* Clippy now uses a lint to generate its lint documentation. [Lints all the way
+ +  down](https://en.wikipedia.org/wiki/Turtles_all_the_way_down).
+ +  [#7502](https://github.com/rust-lang/rust-clippy/pull/7502)
+ +* Reworked Clippy's website:
+ +  [#7172](https://github.com/rust-lang/rust-clippy/issues/7172)
+ +  [#7279](https://github.com/rust-lang/rust-clippy/pull/7279)
+ +  * Added applicability information about lints
+ +  * Added a link to jump into the implementation
+ +  * Improved loading times
+ +  * Adapted some styling
+ +* `cargo clippy --help` now also explains the `--fix` and `--no-deps` flag
+ +  [#7492](https://github.com/rust-lang/rust-clippy/pull/7492)
+ +* [`unnested_or_patterns`]: Removed `or_patterns` feature gate in the code
+ +  example [#7507](https://github.com/rust-lang/rust-clippy/pull/7507)
+ +
+ +## Rust 1.55
+ +
+ +Released 2021-09-09
+ +
+ +[3ae8faf...74d1561](https://github.com/rust-lang/rust-clippy/compare/3ae8faf...74d1561)
+ +
+ +### Important Changes
+ +
+ +* Stabilized `cargo clippy --fix` :tada:
+ +  [#7405](https://github.com/rust-lang/rust-clippy/pull/7405)
+ +
+ +### New Lints
+ +
+ +* [`rc_mutex`]
+ +  [#7316](https://github.com/rust-lang/rust-clippy/pull/7316)
+ +* [`nonstandard_macro_braces`]
+ +  [#7299](https://github.com/rust-lang/rust-clippy/pull/7299)
+ +* [`strlen_on_c_strings`]
+ +  [#7243](https://github.com/rust-lang/rust-clippy/pull/7243)
+ +* [`self_named_constructors`]
+ +  [#7403](https://github.com/rust-lang/rust-clippy/pull/7403)
+ +* [`disallowed_script_idents`]
+ +  [#7400](https://github.com/rust-lang/rust-clippy/pull/7400)
+ +* [`disallowed_types`]
+ +  [#7315](https://github.com/rust-lang/rust-clippy/pull/7315)
+ +* [`missing_enforced_import_renames`]
+ +  [#7300](https://github.com/rust-lang/rust-clippy/pull/7300)
+ +* [`extend_with_drain`]
+ +  [#7270](https://github.com/rust-lang/rust-clippy/pull/7270)
+ +
+ +### Moves and Deprecations
+ +
+ +* Moved [`from_iter_instead_of_collect`] to `pedantic`
+ +  [#7375](https://github.com/rust-lang/rust-clippy/pull/7375)
+ +* Added `suspicious` as a new lint group for *code that is most likely wrong or useless*
+ +  [#7350](https://github.com/rust-lang/rust-clippy/pull/7350)
+ +  * Moved [`blanket_clippy_restriction_lints`] to `suspicious`
+ +  * Moved [`empty_loop`] to `suspicious`
+ +  * Moved [`eval_order_dependence`] to `suspicious`
+ +  * Moved [`float_equality_without_abs`] to `suspicious`
+ +  * Moved [`for_loops_over_fallibles`] to `suspicious`
+ +  * Moved [`misrefactored_assign_op`] to `suspicious`
+ +  * Moved [`mut_range_bound`] to `suspicious`
+ +  * Moved [`mutable_key_type`] to `suspicious`
+ +  * Moved [`suspicious_arithmetic_impl`] to `suspicious`
+ +  * Moved [`suspicious_assignment_formatting`] to `suspicious`
+ +  * Moved [`suspicious_else_formatting`] to `suspicious`
+ +  * Moved [`suspicious_map`] to `suspicious`
+ +  * Moved [`suspicious_op_assign_impl`] to `suspicious`
+ +  * Moved [`suspicious_unary_op_formatting`] to `suspicious`
+ +
+ +### Enhancements
+ +
+ +* [`while_let_on_iterator`]: Now suggests `&mut iter` inside closures
+ +  [#7262](https://github.com/rust-lang/rust-clippy/pull/7262)
+ +* [`doc_markdown`]:
+ +  * Now detects unbalanced ticks
+ +    [#7357](https://github.com/rust-lang/rust-clippy/pull/7357)
+ +  * Add `FreeBSD` to the default configuration as an allowed identifier
+ +    [#7334](https://github.com/rust-lang/rust-clippy/pull/7334)
+ +* [`wildcard_enum_match_arm`], [`match_wildcard_for_single_variants`]: Now allows wildcards for enums with unstable
+ +  or hidden variants
+ +  [#7407](https://github.com/rust-lang/rust-clippy/pull/7407)
+ +* [`redundant_allocation`]: Now additionally supports the `Arc<>` type
+ +  [#7308](https://github.com/rust-lang/rust-clippy/pull/7308)
+ +* [`blacklisted_name`]: Now allows blacklisted names in test code
+ +  [#7379](https://github.com/rust-lang/rust-clippy/pull/7379)
+ +* [`redundant_closure`]: Suggests `&mut` for `FnMut`
+ +  [#7437](https://github.com/rust-lang/rust-clippy/pull/7437)
+ +* [`disallowed_methods`], [`disallowed_types`]: The configuration values `disallowed-method` and `disallowed-type`
+ +  no longer require fully qualified paths
+ +  [#7345](https://github.com/rust-lang/rust-clippy/pull/7345)
+ +* [`zst_offset`]: Fixed lint invocation after it was accidentally suppressed
+ +  [#7396](https://github.com/rust-lang/rust-clippy/pull/7396)
+ +
+ +### False Positive Fixes
+ +
+ +* [`default_numeric_fallback`]: No longer lints on float literals as function arguments
+ +  [#7446](https://github.com/rust-lang/rust-clippy/pull/7446)
+ +* [`use_self`]: No longer lints on type parameters
+ +  [#7288](https://github.com/rust-lang/rust-clippy/pull/7288)
+ +* [`unimplemented`]: Now ignores the `assert` and `debug_assert` macros
+ +  [#7439](https://github.com/rust-lang/rust-clippy/pull/7439)
+ +* [`branches_sharing_code`]: Now always checks for block expressions
+ +  [#7462](https://github.com/rust-lang/rust-clippy/pull/7462)
+ +* [`field_reassign_with_default`]: No longer triggers in macros
+ +  [#7160](https://github.com/rust-lang/rust-clippy/pull/7160)
+ +* [`redundant_clone`]: No longer lints on required clones for borrowed data
+ +  [#7346](https://github.com/rust-lang/rust-clippy/pull/7346)
+ +* [`default_numeric_fallback`]: No longer triggers in external macros
+ +  [#7325](https://github.com/rust-lang/rust-clippy/pull/7325)
+ +* [`needless_bool`]: No longer lints in macros
+ +  [#7442](https://github.com/rust-lang/rust-clippy/pull/7442)
+ +* [`useless_format`]: No longer triggers when additional text is being appended
+ +  [#7442](https://github.com/rust-lang/rust-clippy/pull/7442)
+ +* [`assertions_on_constants`]: `cfg!(...)` is no longer considered to be a constant
+ +  [#7319](https://github.com/rust-lang/rust-clippy/pull/7319)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`needless_collect`]: Now show correct lint messages for shadowed values
+ +  [#7289](https://github.com/rust-lang/rust-clippy/pull/7289)
+ +* [`wrong_pub_self_convention`]: The deprecated message now suggest the correct configuration value
+ +  [#7382](https://github.com/rust-lang/rust-clippy/pull/7382)
+ +* [`semicolon_if_nothing_returned`]: Allow missing semicolon in blocks with only one expression
+ +  [#7326](https://github.com/rust-lang/rust-clippy/pull/7326)
+ +
+ +### ICE Fixes
+ +
+ +* [`zero_sized_map_values`]
+ +  [#7470](https://github.com/rust-lang/rust-clippy/pull/7470)
+ +* [`redundant_pattern_matching`]
+ +  [#7471](https://github.com/rust-lang/rust-clippy/pull/7471)
+ +* [`modulo_one`]
+ +  [#7473](https://github.com/rust-lang/rust-clippy/pull/7473)
+ +* [`use_self`]
+ +  [#7428](https://github.com/rust-lang/rust-clippy/pull/7428)
+ +
+ +## Rust 1.54
+ +
+ +Released 2021-07-29
+ +
+ +[7c7683c...3ae8faf](https://github.com/rust-lang/rust-clippy/compare/7c7683c...3ae8faf)
+ +
+ +### New Lints
+ +
+ +- [`ref_binding_to_reference`]
+ +  [#7105](https://github.com/rust-lang/rust-clippy/pull/7105)
+ +- [`needless_bitwise_bool`]
+ +  [#7133](https://github.com/rust-lang/rust-clippy/pull/7133)
+ +- [`unused_async`] [#7225](https://github.com/rust-lang/rust-clippy/pull/7225)
+ +- [`manual_str_repeat`]
+ +  [#7265](https://github.com/rust-lang/rust-clippy/pull/7265)
+ +- [`suspicious_splitn`]
+ +  [#7292](https://github.com/rust-lang/rust-clippy/pull/7292)
+ +
+ +### Moves and Deprecations
+ +
+ +- Deprecate `pub_enum_variant_names` and `wrong_pub_self_convention` in favor of
+ +  the new `avoid-breaking-exported-api` config option (see
+ +  [Enhancements](#1-54-enhancements))
+ +  [#7187](https://github.com/rust-lang/rust-clippy/pull/7187)
+ +- Move [`inconsistent_struct_constructor`] to `pedantic`
+ +  [#7193](https://github.com/rust-lang/rust-clippy/pull/7193)
+ +- Move [`needless_borrow`] to `style` (now warn-by-default)
+ +  [#7254](https://github.com/rust-lang/rust-clippy/pull/7254)
+ +- Move [`suspicious_operation_groupings`] to `nursery`
+ +  [#7266](https://github.com/rust-lang/rust-clippy/pull/7266)
+ +- Move [`semicolon_if_nothing_returned`] to `pedantic`
+ +  [#7268](https://github.com/rust-lang/rust-clippy/pull/7268)
+ +
+ +### Enhancements <a name="1-54-enhancements"></a>
+ +
+ +- [`while_let_on_iterator`]: Now also lints in nested loops
+ +  [#6966](https://github.com/rust-lang/rust-clippy/pull/6966)
+ +- [`single_char_pattern`]: Now also lints on `strip_prefix` and `strip_suffix`
+ +  [#7156](https://github.com/rust-lang/rust-clippy/pull/7156)
+ +- [`needless_collect`]: Now also lints on assignments with type annotations
+ +  [#7163](https://github.com/rust-lang/rust-clippy/pull/7163)
+ +- [`if_then_some_else_none`]: Now works with the MSRV config
+ +  [#7177](https://github.com/rust-lang/rust-clippy/pull/7177)
+ +- Add `avoid-breaking-exported-api` config option for the lints
+ +  [`enum_variant_names`], [`large_types_passed_by_value`],
+ +  [`trivially_copy_pass_by_ref`], [`unnecessary_wraps`],
+ +  [`upper_case_acronyms`], and [`wrong_self_convention`]. We recommend to set
+ +  this configuration option to `false` before a major release (1.0/2.0/...) to
+ +  clean up the API [#7187](https://github.com/rust-lang/rust-clippy/pull/7187)
+ +- [`needless_collect`]: Now lints on even more data structures
+ +  [#7188](https://github.com/rust-lang/rust-clippy/pull/7188)
+ +- [`missing_docs_in_private_items`]: No longer sees `#[<name> = "<value>"]` like
+ +  attributes as sufficient documentation
+ +  [#7281](https://github.com/rust-lang/rust-clippy/pull/7281)
+ +- [`needless_collect`], [`short_circuit_statement`], [`unnecessary_operation`]:
+ +  Now work as expected when used with `allow`
+ +  [#7282](https://github.com/rust-lang/rust-clippy/pull/7282)
+ +
+ +### False Positive Fixes
+ +
+ +- [`implicit_return`]: Now takes all diverging functions in account to avoid
+ +  false positives [#6951](https://github.com/rust-lang/rust-clippy/pull/6951)
+ +- [`while_let_on_iterator`]: No longer lints when the iterator is a struct field
+ +  and the struct is used in the loop
+ +  [#6966](https://github.com/rust-lang/rust-clippy/pull/6966)
+ +- [`multiple_inherent_impl`]: No longer lints with generic arguments
+ +  [#7089](https://github.com/rust-lang/rust-clippy/pull/7089)
+ +- [`comparison_chain`]: No longer lints in a `const` context
+ +  [#7118](https://github.com/rust-lang/rust-clippy/pull/7118)
+ +- [`while_immutable_condition`]: Fix false positive where mutation in the loop
+ +  variable wasn't picked up
+ +  [#7144](https://github.com/rust-lang/rust-clippy/pull/7144)
+ +- [`default_trait_access`]: No longer lints in macros
+ +  [#7150](https://github.com/rust-lang/rust-clippy/pull/7150)
+ +- [`needless_question_mark`]: No longer lints when the inner value is implicitly
+ +  dereferenced [#7165](https://github.com/rust-lang/rust-clippy/pull/7165)
+ +- [`unused_unit`]: No longer lints when multiple macro contexts are involved
+ +  [#7167](https://github.com/rust-lang/rust-clippy/pull/7167)
+ +- [`eval_order_dependence`]: Fix false positive in async context
+ +  [#7174](https://github.com/rust-lang/rust-clippy/pull/7174)
+ +- [`unnecessary_filter_map`]: No longer lints if the `filter_map` changes the
+ +  type [#7175](https://github.com/rust-lang/rust-clippy/pull/7175)
+ +- [`wrong_self_convention`]: No longer lints in trait implementations of
+ +  non-`Copy` types [#7182](https://github.com/rust-lang/rust-clippy/pull/7182)
+ +- [`suboptimal_flops`]: No longer lints on `powi(2)`
+ +  [#7201](https://github.com/rust-lang/rust-clippy/pull/7201)
+ +- [`wrong_self_convention`]: No longer lints if there is no implicit `self`
+ +  [#7215](https://github.com/rust-lang/rust-clippy/pull/7215)
+ +- [`option_if_let_else`]: No longer lints on `else if let` pattern
+ +  [#7216](https://github.com/rust-lang/rust-clippy/pull/7216)
+ +- [`use_self`], [`useless_conversion`]: Fix false positives when generic
+ +  arguments are involved
+ +  [#7223](https://github.com/rust-lang/rust-clippy/pull/7223)
+ +- [`manual_unwrap_or`]: Fix false positive with deref coercion
+ +  [#7233](https://github.com/rust-lang/rust-clippy/pull/7233)
+ +- [`similar_names`]: No longer lints on `wparam`/`lparam`
+ +  [#7255](https://github.com/rust-lang/rust-clippy/pull/7255)
+ +- [`redundant_closure`]: No longer lints on using the `vec![]` macro in a
+ +  closure [#7263](https://github.com/rust-lang/rust-clippy/pull/7263)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +- [`implicit_return`]
+ +  [#6951](https://github.com/rust-lang/rust-clippy/pull/6951)
+ +    - Fix suggestion for async functions
+ +    - Improve suggestion with macros
+ +    - Suggest to change `break` to `return` when appropriate
+ +- [`while_let_on_iterator`]: Now suggests `&mut iter` when necessary
+ +  [#6966](https://github.com/rust-lang/rust-clippy/pull/6966)
+ +- [`match_single_binding`]: Improve suggestion when match scrutinee has side
+ +  effects [#7095](https://github.com/rust-lang/rust-clippy/pull/7095)
+ +- [`needless_borrow`]: Now suggests to also change usage sites as needed
+ +  [#7105](https://github.com/rust-lang/rust-clippy/pull/7105)
+ +- [`write_with_newline`]: Improve suggestion when only `\n` is written to the
+ +  buffer [#7183](https://github.com/rust-lang/rust-clippy/pull/7183)
+ +- [`from_iter_instead_of_collect`]: The suggestion is now auto applicable also
+ +  when a `<_ as Trait>::_` is involved
+ +  [#7264](https://github.com/rust-lang/rust-clippy/pull/7264)
+ +- [`not_unsafe_ptr_arg_deref`]: Improved error message
+ +  [#7294](https://github.com/rust-lang/rust-clippy/pull/7294)
+ +
+ +### ICE Fixes
+ +
+ +- Fix ICE when running Clippy on `libstd`
+ +  [#7140](https://github.com/rust-lang/rust-clippy/pull/7140)
+ +- [`implicit_return`]
+ +  [#7242](https://github.com/rust-lang/rust-clippy/pull/7242)
+ +
+ +## Rust 1.53
+ +
+ +Released 2021-06-17
+ +
+ +[6ed6f1e...7c7683c](https://github.com/rust-lang/rust-clippy/compare/6ed6f1e...7c7683c)
+ +
+ +### New Lints
+ +
+ +* [`option_filter_map`]
+ +  [#6342](https://github.com/rust-lang/rust-clippy/pull/6342)
+ +* [`branches_sharing_code`]
+ +  [#6463](https://github.com/rust-lang/rust-clippy/pull/6463)
+ +* [`needless_for_each`]
+ +  [#6706](https://github.com/rust-lang/rust-clippy/pull/6706)
+ +* [`if_then_some_else_none`]
+ +  [#6859](https://github.com/rust-lang/rust-clippy/pull/6859)
+ +* [`non_octal_unix_permissions`]
+ +  [#7001](https://github.com/rust-lang/rust-clippy/pull/7001)
+ +* [`unnecessary_self_imports`]
+ +  [#7072](https://github.com/rust-lang/rust-clippy/pull/7072)
+ +* [`bool_assert_comparison`]
+ +  [#7083](https://github.com/rust-lang/rust-clippy/pull/7083)
+ +* [`cloned_instead_of_copied`]
+ +  [#7098](https://github.com/rust-lang/rust-clippy/pull/7098)
+ +* [`flat_map_option`]
+ +  [#7101](https://github.com/rust-lang/rust-clippy/pull/7101)
+ +
+ +### Moves and Deprecations
+ +
+ +* Deprecate [`filter_map`] lint
+ +  [#7059](https://github.com/rust-lang/rust-clippy/pull/7059)
+ +* Move [`transmute_ptr_to_ptr`] to `pedantic`
+ +  [#7102](https://github.com/rust-lang/rust-clippy/pull/7102)
+ +
+ +### Enhancements
+ +
+ +* [`mem_replace_with_default`]: Also lint on common std constructors
+ +  [#6820](https://github.com/rust-lang/rust-clippy/pull/6820)
+ +* [`wrong_self_convention`]: Also lint on `to_*_mut` methods
+ +  [#6828](https://github.com/rust-lang/rust-clippy/pull/6828)
+ +* [`wildcard_enum_match_arm`], [`match_wildcard_for_single_variants`]:
+ +  [#6863](https://github.com/rust-lang/rust-clippy/pull/6863)
+ +    * Attempt to find a common path prefix in suggestion
+ +    * Don't lint on `Option` and `Result`
+ +    * Consider `Self` prefix
+ +* [`explicit_deref_methods`]: Also lint on chained `deref` calls
+ +  [#6865](https://github.com/rust-lang/rust-clippy/pull/6865)
+ +* [`or_fun_call`]: Also lint on `unsafe` blocks
+ +  [#6928](https://github.com/rust-lang/rust-clippy/pull/6928)
+ +* [`vec_box`], [`linkedlist`], [`option_option`]: Also lint in `const` and
+ +  `static` items [#6938](https://github.com/rust-lang/rust-clippy/pull/6938)
+ +* [`search_is_some`]: Also check for `is_none`
+ +  [#6942](https://github.com/rust-lang/rust-clippy/pull/6942)
+ +* [`string_lit_as_bytes`]: Also lint on `into_bytes`
+ +  [#6959](https://github.com/rust-lang/rust-clippy/pull/6959)
+ +* [`len_without_is_empty`]: Also lint if function signatures of `len` and
+ +  `is_empty` don't match
+ +  [#6980](https://github.com/rust-lang/rust-clippy/pull/6980)
+ +* [`redundant_pattern_matching`]: Also lint if the pattern is a `&` pattern
+ +  [#6991](https://github.com/rust-lang/rust-clippy/pull/6991)
+ +* [`clone_on_copy`]: Also lint on chained method calls taking `self` by value
+ +  [#7000](https://github.com/rust-lang/rust-clippy/pull/7000)
+ +* [`missing_panics_doc`]: Also lint on `assert_eq!` and `assert_ne!`
+ +  [#7029](https://github.com/rust-lang/rust-clippy/pull/7029)
+ +* [`needless_return`]: Also lint in `async` functions
+ +  [#7067](https://github.com/rust-lang/rust-clippy/pull/7067)
+ +* [`unused_io_amount`]: Also lint on expressions like `_.read().ok()?`
+ +  [#7100](https://github.com/rust-lang/rust-clippy/pull/7100)
+ +* [`iter_cloned_collect`]: Also lint on large arrays, since const-generics are
+ +  now stable [#7138](https://github.com/rust-lang/rust-clippy/pull/7138)
+ +
+ +### False Positive Fixes
+ +
+ +* [`upper_case_acronyms`]: No longer lints on public items
+ +  [#6805](https://github.com/rust-lang/rust-clippy/pull/6805)
+ +* [`suspicious_map`]: No longer lints when side effects may occur inside the
+ +  `map` call [#6831](https://github.com/rust-lang/rust-clippy/pull/6831)
+ +* [`manual_map`], [`manual_unwrap_or`]: No longer lints in `const` functions
+ +  [#6917](https://github.com/rust-lang/rust-clippy/pull/6917)
+ +* [`wrong_self_convention`]: Now respects `Copy` types
+ +  [#6924](https://github.com/rust-lang/rust-clippy/pull/6924)
+ +* [`needless_question_mark`]: No longer lints if the `?` and the `Some(..)` come
+ +  from different macro contexts [#6935](https://github.com/rust-lang/rust-clippy/pull/6935)
+ +* [`map_entry`]: Better detect if the entry API can be used
+ +  [#6937](https://github.com/rust-lang/rust-clippy/pull/6937)
+ +* [`or_fun_call`]: No longer lints on some `len` function calls
+ +  [#6950](https://github.com/rust-lang/rust-clippy/pull/6950)
+ +* [`new_ret_no_self`]: No longer lints when `Self` is returned with different
+ +  generic arguments [#6952](https://github.com/rust-lang/rust-clippy/pull/6952)
+ +* [`upper_case_acronyms`]: No longer lints on public items
+ +  [#6981](https://github.com/rust-lang/rust-clippy/pull/6981)
+ +* [`explicit_into_iter_loop`]: Only lint when `into_iter` is an implementation
+ +  of `IntoIterator` [#6982](https://github.com/rust-lang/rust-clippy/pull/6982)
+ +* [`expl_impl_clone_on_copy`]: Take generic constraints into account before
+ +  suggesting to use `derive` instead
+ +  [#6993](https://github.com/rust-lang/rust-clippy/pull/6993)
+ +* [`missing_panics_doc`]: No longer lints when only debug-assertions are used
+ +  [#6996](https://github.com/rust-lang/rust-clippy/pull/6996)
+ +* [`clone_on_copy`]: Only lint when using the `Clone` trait
+ +  [#7000](https://github.com/rust-lang/rust-clippy/pull/7000)
+ +* [`wrong_self_convention`]: No longer lints inside a trait implementation
+ +  [#7002](https://github.com/rust-lang/rust-clippy/pull/7002)
+ +* [`redundant_clone`]: No longer lints when the cloned value is modified while
+ +  the clone is in use
+ +  [#7011](https://github.com/rust-lang/rust-clippy/pull/7011)
+ +* [`same_item_push`]: No longer lints if the `Vec` is used in the loop body
+ +  [#7018](https://github.com/rust-lang/rust-clippy/pull/7018)
+ +* [`cargo_common_metadata`]: Remove author requirement
+ +  [#7026](https://github.com/rust-lang/rust-clippy/pull/7026)
+ +* [`panic_in_result_fn`]: No longer lints on `debug_assert` family
+ +  [#7060](https://github.com/rust-lang/rust-clippy/pull/7060)
+ +* [`panic`]: No longer wrongfully lints on `debug_assert` with message
+ +  [#7063](https://github.com/rust-lang/rust-clippy/pull/7063)
+ +* [`wrong_self_convention`]: No longer lints in trait implementations where no
+ +  `self` is involved [#7064](https://github.com/rust-lang/rust-clippy/pull/7064)
+ +* [`missing_const_for_fn`]: No longer lints when unstable `const` function is
+ +  involved [#7076](https://github.com/rust-lang/rust-clippy/pull/7076)
+ +* [`suspicious_else_formatting`]: Allow Allman style braces
+ +  [#7087](https://github.com/rust-lang/rust-clippy/pull/7087)
+ +* [`inconsistent_struct_constructor`]: No longer lints in macros
+ +  [#7097](https://github.com/rust-lang/rust-clippy/pull/7097)
+ +* [`single_component_path_imports`]: No longer lints on macro re-exports
+ +  [#7120](https://github.com/rust-lang/rust-clippy/pull/7120)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`redundant_pattern_matching`]: Add a note when applying this lint would
+ +  change the drop order
+ +  [#6568](https://github.com/rust-lang/rust-clippy/pull/6568)
+ +* [`write_literal`], [`print_literal`]: Add auto-applicable suggestion
+ +  [#6821](https://github.com/rust-lang/rust-clippy/pull/6821)
+ +* [`manual_map`]: Fix suggestion for complex `if let ... else` chains
+ +  [#6856](https://github.com/rust-lang/rust-clippy/pull/6856)
+ +* [`inconsistent_struct_constructor`]: Make lint description and message clearer
+ +  [#6892](https://github.com/rust-lang/rust-clippy/pull/6892)
+ +* [`map_entry`]: Now suggests `or_insert`, `insert_with` or `match _.entry(_)`
+ +  as appropriate [#6937](https://github.com/rust-lang/rust-clippy/pull/6937)
+ +* [`manual_flatten`]: Suggest to insert `copied` if necessary
+ +  [#6962](https://github.com/rust-lang/rust-clippy/pull/6962)
+ +* [`redundant_slicing`]: Fix suggestion when a re-borrow might be required or
+ +  when the value is from a macro call
+ +  [#6975](https://github.com/rust-lang/rust-clippy/pull/6975)
+ +* [`match_wildcard_for_single_variants`]: Fix suggestion for hidden variant
+ +  [#6988](https://github.com/rust-lang/rust-clippy/pull/6988)
+ +* [`clone_on_copy`]: Correct suggestion when the cloned value is a macro call
+ +  [#7000](https://github.com/rust-lang/rust-clippy/pull/7000)
+ +* [`manual_map`]: Fix suggestion at the end of an if chain
+ +  [#7004](https://github.com/rust-lang/rust-clippy/pull/7004)
+ +* Fix needless parenthesis output in multiple lint suggestions
+ +  [#7013](https://github.com/rust-lang/rust-clippy/pull/7013)
+ +* [`needless_collect`]: Better explanation in the lint message
+ +  [#7020](https://github.com/rust-lang/rust-clippy/pull/7020)
+ +* [`useless_vec`]: Now considers mutability
+ +  [#7036](https://github.com/rust-lang/rust-clippy/pull/7036)
+ +* [`useless_format`]: Wrap the content in braces if necessary
+ +  [#7092](https://github.com/rust-lang/rust-clippy/pull/7092)
+ +* [`single_match`]: Don't suggest an equality check for types which don't
+ +  implement `PartialEq`
+ +  [#7093](https://github.com/rust-lang/rust-clippy/pull/7093)
+ +* [`from_over_into`]: Mention type in help message
+ +  [#7099](https://github.com/rust-lang/rust-clippy/pull/7099)
+ +* [`manual_unwrap_or`]: Fix invalid code suggestion due to a macro call
+ +  [#7136](https://github.com/rust-lang/rust-clippy/pull/7136)
+ +
+ +### ICE Fixes
+ +
+ +* [`macro_use_imports`]
+ +  [#7022](https://github.com/rust-lang/rust-clippy/pull/7022)
+ +* [`missing_panics_doc`]
+ +  [#7034](https://github.com/rust-lang/rust-clippy/pull/7034)
+ +* [`tabs_in_doc_comments`]
+ +  [#7039](https://github.com/rust-lang/rust-clippy/pull/7039)
+ +* [`missing_const_for_fn`]
+ +  [#7128](https://github.com/rust-lang/rust-clippy/pull/7128)
+ +
+ +### Others
+ +
+ +* [Clippy's lint
+ +  list](https://rust-lang.github.io/rust-clippy/master/index.html) now supports
+ +  themes [#7030](https://github.com/rust-lang/rust-clippy/pull/7030)
+ +* Lints that were uplifted to `rustc` now mention the new `rustc` name in the
+ +  deprecation warning
+ +  [#7056](https://github.com/rust-lang/rust-clippy/pull/7056)
+ +
+ +## Rust 1.52
+ +
+ +Released 2021-05-06
+ +
+ +[3e41797...6ed6f1e](https://github.com/rust-lang/rust-clippy/compare/3e41797...6ed6f1e)
+ +
+ +### New Lints
+ +
+ +* [`from_str_radix_10`]
+ +  [#6717](https://github.com/rust-lang/rust-clippy/pull/6717)
+ +* [`implicit_clone`]
+ +  [#6730](https://github.com/rust-lang/rust-clippy/pull/6730)
+ +* [`semicolon_if_nothing_returned`]
+ +  [#6681](https://github.com/rust-lang/rust-clippy/pull/6681)
+ +* [`manual_flatten`]
+ +  [#6646](https://github.com/rust-lang/rust-clippy/pull/6646)
+ +* [`inconsistent_struct_constructor`]
+ +  [#6769](https://github.com/rust-lang/rust-clippy/pull/6769)
+ +* [`iter_count`]
+ +  [#6791](https://github.com/rust-lang/rust-clippy/pull/6791)
+ +* [`default_numeric_fallback`]
+ +  [#6662](https://github.com/rust-lang/rust-clippy/pull/6662)
+ +* [`bytes_nth`]
+ +  [#6695](https://github.com/rust-lang/rust-clippy/pull/6695)
+ +* [`filter_map_identity`]
+ +  [#6685](https://github.com/rust-lang/rust-clippy/pull/6685)
+ +* [`manual_map`]
+ +  [#6573](https://github.com/rust-lang/rust-clippy/pull/6573)
+ +
+ +### Moves and Deprecations
+ +
+ +* Moved [`upper_case_acronyms`] to `pedantic`
+ +  [#6775](https://github.com/rust-lang/rust-clippy/pull/6775)
+ +* Moved [`manual_map`] to `nursery`
+ +  [#6796](https://github.com/rust-lang/rust-clippy/pull/6796)
+ +* Moved [`unnecessary_wraps`] to `pedantic`
+ +  [#6765](https://github.com/rust-lang/rust-clippy/pull/6765)
+ +* Moved [`trivial_regex`] to `nursery`
+ +  [#6696](https://github.com/rust-lang/rust-clippy/pull/6696)
+ +* Moved [`naive_bytecount`] to `pedantic`
+ +  [#6825](https://github.com/rust-lang/rust-clippy/pull/6825)
+ +* Moved [`upper_case_acronyms`] to `style`
+ +  [#6788](https://github.com/rust-lang/rust-clippy/pull/6788)
+ +* Moved [`manual_map`] to `style`
+ +  [#6801](https://github.com/rust-lang/rust-clippy/pull/6801)
+ +
+ +### Enhancements
+ +
+ +* [`disallowed_methods`]: Now supports functions in addition to methods
+ +  [#6674](https://github.com/rust-lang/rust-clippy/pull/6674)
+ +* [`upper_case_acronyms`]: Added a new configuration `upper-case-acronyms-aggressive` to
+ +  trigger the lint if there is more than one uppercase character next to each other
+ +  [#6788](https://github.com/rust-lang/rust-clippy/pull/6788)
+ +* [`collapsible_match`]: Now supports block comparison with different value names
+ +  [#6754](https://github.com/rust-lang/rust-clippy/pull/6754)
+ +* [`unnecessary_wraps`]: Will now suggest removing unnecessary wrapped return unit type, like `Option<()>`
+ +  [#6665](https://github.com/rust-lang/rust-clippy/pull/6665)
+ +* Improved value usage detection in closures
+ +  [#6698](https://github.com/rust-lang/rust-clippy/pull/6698)
+ +
+ +### False Positive Fixes
+ +
+ +* [`use_self`]: No longer lints in macros
+ +  [#6833](https://github.com/rust-lang/rust-clippy/pull/6833)
+ +* [`use_self`]: Fixed multiple false positives for: generics, associated types and derive implementations
+ +  [#6179](https://github.com/rust-lang/rust-clippy/pull/6179)
+ +* [`missing_inline_in_public_items`]: No longer lints for procedural macros
+ +  [#6814](https://github.com/rust-lang/rust-clippy/pull/6814)
+ +* [`inherent_to_string`]: No longer lints on functions with function generics
+ +  [#6771](https://github.com/rust-lang/rust-clippy/pull/6771)
+ +* [`doc_markdown`]: Add `OpenDNS` to the default configuration as an allowed identifier
+ +  [#6783](https://github.com/rust-lang/rust-clippy/pull/6783)
+ +* [`missing_panics_doc`]: No longer lints on [`unreachable!`](https://doc.rust-lang.org/std/macro.unreachable.html)
+ +  [#6700](https://github.com/rust-lang/rust-clippy/pull/6700)
+ +* [`collapsible_if`]: No longer lints on if statements with attributes
+ +  [#6701](https://github.com/rust-lang/rust-clippy/pull/6701)
+ +* [`match_same_arms`]: Only considers empty blocks as equal if the tokens contained are the same
+ +  [#6843](https://github.com/rust-lang/rust-clippy/pull/6843)
+ +* [`redundant_closure`]: Now ignores macros
+ +  [#6871](https://github.com/rust-lang/rust-clippy/pull/6871)
+ +* [`manual_map`]: Fixed false positives when control flow statements like `return`, `break` etc. are used
+ +  [#6801](https://github.com/rust-lang/rust-clippy/pull/6801)
+ +* [`vec_init_then_push`]: Fixed false positives for loops and if statements
+ +  [#6697](https://github.com/rust-lang/rust-clippy/pull/6697)
+ +* [`len_without_is_empty`]: Will now consider multiple impl blocks and `#[allow]` on
+ +  the `len` method as well as the type definition.
+ +  [#6853](https://github.com/rust-lang/rust-clippy/pull/6853)
+ +* [`let_underscore_drop`]: Only lints on types which implement `Drop`
+ +  [#6682](https://github.com/rust-lang/rust-clippy/pull/6682)
+ +* [`unit_arg`]: No longer lints on unit arguments when they come from a path expression.
+ +  [#6601](https://github.com/rust-lang/rust-clippy/pull/6601)
+ +* [`cargo_common_metadata`]: No longer lints if
+ +  [`publish = false`](https://doc.rust-lang.org/cargo/reference/manifest.html#the-publish-field)
+ +  is defined in the manifest
+ +  [#6650](https://github.com/rust-lang/rust-clippy/pull/6650)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`collapsible_match`]: Fixed lint message capitalization
+ +  [#6766](https://github.com/rust-lang/rust-clippy/pull/6766)
+ +* [`or_fun_call`]: Improved suggestions for `or_insert(vec![])`
+ +  [#6790](https://github.com/rust-lang/rust-clippy/pull/6790)
+ +* [`manual_map`]: No longer expands macros in the suggestions
+ +  [#6801](https://github.com/rust-lang/rust-clippy/pull/6801)
+ +* Aligned Clippy's lint messages with the rustc dev guide
+ +  [#6787](https://github.com/rust-lang/rust-clippy/pull/6787)
+ +
+ +### ICE Fixes
+ +
+ +* [`zero_sized_map_values`]
+ +  [#6866](https://github.com/rust-lang/rust-clippy/pull/6866)
+ +
+ +### Documentation Improvements
+ +
+ +* [`useless_format`]: Improved the documentation example
+ +  [#6854](https://github.com/rust-lang/rust-clippy/pull/6854)
+ +* Clippy's [`README.md`]: Includes a new subsection on running Clippy as a rustc wrapper
+ +  [#6782](https://github.com/rust-lang/rust-clippy/pull/6782)
+ +
+ +### Others
+ +* Running `cargo clippy` after `cargo check` now works as expected
+ +  (`cargo clippy` and `cargo check` no longer shares the same build cache)
+ +  [#6687](https://github.com/rust-lang/rust-clippy/pull/6687)
+ +* Cargo now re-runs Clippy if arguments after `--` provided to `cargo clippy` are changed.
+ +  [#6834](https://github.com/rust-lang/rust-clippy/pull/6834)
+ +* Extracted Clippy's `utils` module into the new `clippy_utils` crate
+ +  [#6756](https://github.com/rust-lang/rust-clippy/pull/6756)
+ +* Clippy lintcheck tool improvements
+ +  [#6800](https://github.com/rust-lang/rust-clippy/pull/6800)
+ +  [#6735](https://github.com/rust-lang/rust-clippy/pull/6735)
+ +  [#6764](https://github.com/rust-lang/rust-clippy/pull/6764)
+ +  [#6708](https://github.com/rust-lang/rust-clippy/pull/6708)
+ +  [#6780](https://github.com/rust-lang/rust-clippy/pull/6780)
+ +  [#6686](https://github.com/rust-lang/rust-clippy/pull/6686)
+ +
+ +## Rust 1.51
+ +
+ +Released 2021-03-25
+ +
+ +[4911ab1...3e41797](https://github.com/rust-lang/rust-clippy/compare/4911ab1...3e41797)
+ +
+ +### New Lints
+ +
+ +* [`upper_case_acronyms`]
+ +  [#6475](https://github.com/rust-lang/rust-clippy/pull/6475)
+ +* [`from_over_into`] [#6476](https://github.com/rust-lang/rust-clippy/pull/6476)
+ +* [`case_sensitive_file_extension_comparisons`]
+ +  [#6500](https://github.com/rust-lang/rust-clippy/pull/6500)
+ +* [`needless_question_mark`]
+ +  [#6507](https://github.com/rust-lang/rust-clippy/pull/6507)
+ +* [`missing_panics_doc`]
+ +  [#6523](https://github.com/rust-lang/rust-clippy/pull/6523)
+ +* [`redundant_slicing`]
+ +  [#6528](https://github.com/rust-lang/rust-clippy/pull/6528)
+ +* [`vec_init_then_push`]
+ +  [#6538](https://github.com/rust-lang/rust-clippy/pull/6538)
+ +* [`ptr_as_ptr`] [#6542](https://github.com/rust-lang/rust-clippy/pull/6542)
+ +* [`collapsible_else_if`] (split out from `collapsible_if`)
+ +  [#6544](https://github.com/rust-lang/rust-clippy/pull/6544)
+ +* [`inspect_for_each`] [#6577](https://github.com/rust-lang/rust-clippy/pull/6577)
+ +* [`manual_filter_map`]
+ +  [#6591](https://github.com/rust-lang/rust-clippy/pull/6591)
+ +* [`exhaustive_enums`]
+ +  [#6617](https://github.com/rust-lang/rust-clippy/pull/6617)
+ +* [`exhaustive_structs`]
+ +  [#6617](https://github.com/rust-lang/rust-clippy/pull/6617)
+ +
+ +### Moves and Deprecations
+ +
+ +* Replace [`find_map`] with [`manual_find_map`]
+ +  [#6591](https://github.com/rust-lang/rust-clippy/pull/6591)
+ +* `unknown_clippy_lints` Now integrated in the `unknown_lints` rustc lint
+ +  [#6653](https://github.com/rust-lang/rust-clippy/pull/6653)
+ +
+ +### Enhancements
+ +
+ +* [`ptr_arg`] Now also suggests to use `&Path` instead of `&PathBuf`
+ +  [#6506](https://github.com/rust-lang/rust-clippy/pull/6506)
+ +* [`cast_ptr_alignment`] Also lint when the `pointer::cast` method is used
+ +  [#6557](https://github.com/rust-lang/rust-clippy/pull/6557)
+ +* [`collapsible_match`] Now also deals with `&` and `*` operators in the `match`
+ +  scrutinee [#6619](https://github.com/rust-lang/rust-clippy/pull/6619)
+ +
+ +### False Positive Fixes
+ +
+ +* [`similar_names`] Ignore underscore prefixed names
+ +  [#6403](https://github.com/rust-lang/rust-clippy/pull/6403)
+ +* [`print_literal`] and [`write_literal`] No longer lint numeric literals
+ +  [#6408](https://github.com/rust-lang/rust-clippy/pull/6408)
+ +* [`large_enum_variant`] No longer lints in external macros
+ +  [#6485](https://github.com/rust-lang/rust-clippy/pull/6485)
+ +* [`empty_enum`] Only lint if `never_type` feature is enabled
+ +  [#6513](https://github.com/rust-lang/rust-clippy/pull/6513)
+ +* [`field_reassign_with_default`] No longer lints in macros
+ +  [#6553](https://github.com/rust-lang/rust-clippy/pull/6553)
+ +* [`size_of_in_element_count`] No longer lints when dividing by element size
+ +  [#6578](https://github.com/rust-lang/rust-clippy/pull/6578)
+ +* [`needless_return`] No longer lints in macros
+ +  [#6586](https://github.com/rust-lang/rust-clippy/pull/6586)
+ +* [`match_overlapping_arm`] No longer lint when first arm is completely included
+ +  in second arm [#6603](https://github.com/rust-lang/rust-clippy/pull/6603)
+ +* [`doc_markdown`] Add `WebGL` to the default configuration as an allowed
+ +  identifier [#6605](https://github.com/rust-lang/rust-clippy/pull/6605)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`field_reassign_with_default`] Don't expand macro in lint suggestion
+ +  [#6531](https://github.com/rust-lang/rust-clippy/pull/6531)
+ +* [`match_like_matches_macro`] Strip references in suggestion
+ +  [#6532](https://github.com/rust-lang/rust-clippy/pull/6532)
+ +* [`single_match`] Suggest `if` over `if let` when possible
+ +  [#6574](https://github.com/rust-lang/rust-clippy/pull/6574)
+ +* [`ref_in_deref`] Use parentheses correctly in suggestion
+ +  [#6609](https://github.com/rust-lang/rust-clippy/pull/6609)
+ +* [`stable_sort_primitive`] Clarify error message
+ +  [#6611](https://github.com/rust-lang/rust-clippy/pull/6611)
+ +
+ +### ICE Fixes
+ +
+ +* [`zero_sized_map_values`]
+ +  [#6582](https://github.com/rust-lang/rust-clippy/pull/6582)
+ +
+ +### Documentation Improvements
+ +
+ +* Improve search performance on the Clippy website and make it possible to
+ +  directly search for lints on the GitHub issue tracker
+ +  [#6483](https://github.com/rust-lang/rust-clippy/pull/6483)
+ +* Clean up `README.md` by removing outdated paragraph
+ +  [#6488](https://github.com/rust-lang/rust-clippy/pull/6488)
+ +* [`await_holding_refcell_ref`] and [`await_holding_lock`]
+ +  [#6585](https://github.com/rust-lang/rust-clippy/pull/6585)
+ +* [`as_conversions`] [#6608](https://github.com/rust-lang/rust-clippy/pull/6608)
+ +
+ +### Others
+ +
+ +* Clippy now has a [Roadmap] for 2021. If you like to get involved in a bigger
+ +  project, take a look at the [Roadmap project page]. All issues listed there
+ +  are actively mentored
+ +  [#6462](https://github.com/rust-lang/rust-clippy/pull/6462)
+ +* The Clippy version number now corresponds to the Rust version number
+ +  [#6526](https://github.com/rust-lang/rust-clippy/pull/6526)
+ +* Fix oversight which caused Clippy to lint deps in some environments, where
+ +  `CLIPPY_TESTS=true` was set somewhere
+ +  [#6575](https://github.com/rust-lang/rust-clippy/pull/6575)
+ +* Add `cargo dev-lintcheck` tool to the Clippy Dev Tool
+ +  [#6469](https://github.com/rust-lang/rust-clippy/pull/6469)
+ +
+ +[Roadmap]: https://github.com/rust-lang/rust-clippy/blob/master/doc/roadmap-2021.md
+ +[Roadmap project page]: https://github.com/rust-lang/rust-clippy/projects/3
+ +
+ +## Rust 1.50
+ +
+ +Released 2021-02-11
+ +
+ +[b20d4c1...4bd77a1](https://github.com/rust-lang/rust-clippy/compare/b20d4c1...4bd77a1)
+ +
+ +### New Lints
+ +
+ +* [`suspicious_operation_groupings`] [#6086](https://github.com/rust-lang/rust-clippy/pull/6086)
+ +* [`size_of_in_element_count`] [#6394](https://github.com/rust-lang/rust-clippy/pull/6394)
+ +* [`unnecessary_wraps`] [#6070](https://github.com/rust-lang/rust-clippy/pull/6070)
+ +* [`let_underscore_drop`] [#6305](https://github.com/rust-lang/rust-clippy/pull/6305)
+ +* [`collapsible_match`] [#6402](https://github.com/rust-lang/rust-clippy/pull/6402)
+ +* [`redundant_else`] [#6330](https://github.com/rust-lang/rust-clippy/pull/6330)
+ +* [`zero_sized_map_values`] [#6218](https://github.com/rust-lang/rust-clippy/pull/6218)
+ +* [`print_stderr`] [#6367](https://github.com/rust-lang/rust-clippy/pull/6367)
+ +* [`string_from_utf8_as_bytes`] [#6134](https://github.com/rust-lang/rust-clippy/pull/6134)
+ +
+ +### Moves and Deprecations
+ +
+ +* Previously deprecated [`str_to_string`] and [`string_to_string`] have been un-deprecated
+ +  as `restriction` lints [#6333](https://github.com/rust-lang/rust-clippy/pull/6333)
+ +* Deprecate `panic_params` lint. This is now available in rustc as `non_fmt_panics`
+ +  [#6351](https://github.com/rust-lang/rust-clippy/pull/6351)
+ +* Move [`map_err_ignore`] to `restriction`
+ +  [#6416](https://github.com/rust-lang/rust-clippy/pull/6416)
+ +* Move [`await_holding_refcell_ref`] to `pedantic`
+ +  [#6354](https://github.com/rust-lang/rust-clippy/pull/6354)
+ +* Move [`await_holding_lock`] to `pedantic`
+ +  [#6354](https://github.com/rust-lang/rust-clippy/pull/6354)
+ +
+ +### Enhancements
+ +
+ +* Add the `unreadable-literal-lint-fractions` configuration to disable
+ +  the `unreadable_literal` lint for fractions
+ +  [#6421](https://github.com/rust-lang/rust-clippy/pull/6421)
+ +* [`clone_on_copy`]: Now shows the type in the lint message
+ +  [#6443](https://github.com/rust-lang/rust-clippy/pull/6443)
+ +* [`redundant_pattern_matching`]: Now also lints on `std::task::Poll`
+ +  [#6339](https://github.com/rust-lang/rust-clippy/pull/6339)
+ +* [`redundant_pattern_matching`]: Additionally also lints on `std::net::IpAddr`
+ +  [#6377](https://github.com/rust-lang/rust-clippy/pull/6377)
+ +* [`search_is_some`]: Now suggests `contains` instead of `find(foo).is_some()`
+ +  [#6119](https://github.com/rust-lang/rust-clippy/pull/6119)
+ +* [`clone_double_ref`]: Now prints the reference type in the lint message
+ +  [#6442](https://github.com/rust-lang/rust-clippy/pull/6442)
+ +* [`modulo_one`]: Now also lints on -1.
+ +  [#6360](https://github.com/rust-lang/rust-clippy/pull/6360)
+ +* [`empty_loop`]: Now lints no_std crates, too
+ +  [#6205](https://github.com/rust-lang/rust-clippy/pull/6205)
+ +* [`or_fun_call`]: Now also lints when indexing `HashMap` or `BTreeMap`
+ +  [#6267](https://github.com/rust-lang/rust-clippy/pull/6267)
+ +* [`wrong_self_convention`]: Now also lints in trait definitions
+ +  [#6316](https://github.com/rust-lang/rust-clippy/pull/6316)
+ +* [`needless_borrow`]: Print the type in the lint message
+ +  [#6449](https://github.com/rust-lang/rust-clippy/pull/6449)
+ +
+ +[msrv_readme]: https://github.com/rust-lang/rust-clippy#specifying-the-minimum-supported-rust-version
+ +
+ +### False Positive Fixes
+ +
+ +* [`manual_range_contains`]: No longer lints in `const fn`
+ +  [#6382](https://github.com/rust-lang/rust-clippy/pull/6382)
+ +* [`unnecessary_lazy_evaluations`]: No longer lints if closure argument is used
+ +  [#6370](https://github.com/rust-lang/rust-clippy/pull/6370)
+ +* [`match_single_binding`]: Now ignores cases with `#[cfg()]` macros
+ +  [#6435](https://github.com/rust-lang/rust-clippy/pull/6435)
+ +* [`match_like_matches_macro`]: No longer lints on arms with attributes
+ +  [#6290](https://github.com/rust-lang/rust-clippy/pull/6290)
+ +* [`map_clone`]: No longer lints with deref and clone
+ +  [#6269](https://github.com/rust-lang/rust-clippy/pull/6269)
+ +* [`map_clone`]: No longer lints in the case of &mut
+ +  [#6301](https://github.com/rust-lang/rust-clippy/pull/6301)
+ +* [`needless_update`]: Now ignores `non_exhaustive` structs
+ +  [#6464](https://github.com/rust-lang/rust-clippy/pull/6464)
+ +* [`needless_collect`]: No longer lints when a collect is needed multiple times
+ +  [#6313](https://github.com/rust-lang/rust-clippy/pull/6313)
+ +* [`unnecessary_cast`] No longer lints cfg-dependent types
+ +  [#6369](https://github.com/rust-lang/rust-clippy/pull/6369)
+ +* [`declare_interior_mutable_const`] and [`borrow_interior_mutable_const`]:
+ +  Both now ignore enums with frozen variants
+ +  [#6110](https://github.com/rust-lang/rust-clippy/pull/6110)
+ +* [`field_reassign_with_default`] No longer lint for private fields
+ +  [#6537](https://github.com/rust-lang/rust-clippy/pull/6537)
+ +
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`vec_box`]: Provide correct type scope suggestion
+ +  [#6271](https://github.com/rust-lang/rust-clippy/pull/6271)
+ +* [`manual_range_contains`]: Give correct suggestion when using floats
+ +  [#6320](https://github.com/rust-lang/rust-clippy/pull/6320)
+ +* [`unnecessary_lazy_evaluations`]: Don't always mark suggestion as MachineApplicable
+ +  [#6272](https://github.com/rust-lang/rust-clippy/pull/6272)
+ +* [`manual_async_fn`]: Improve suggestion formatting
+ +  [#6294](https://github.com/rust-lang/rust-clippy/pull/6294)
+ +* [`unnecessary_cast`]: Fix incorrectly formatted float literal suggestion
+ +  [#6362](https://github.com/rust-lang/rust-clippy/pull/6362)
+ +
+ +### ICE Fixes
+ +
+ +* Fix a crash in [`from_iter_instead_of_collect`]
+ +  [#6304](https://github.com/rust-lang/rust-clippy/pull/6304)
+ +* Fix a silent crash when parsing doc comments in [`needless_doctest_main`]
+ +  [#6458](https://github.com/rust-lang/rust-clippy/pull/6458)
+ +
+ +### Documentation Improvements
+ +
+ +* The lint website search has been improved ([#6477](https://github.com/rust-lang/rust-clippy/pull/6477)):
+ +  * Searching for lints with dashes and spaces is possible now. For example
+ +    `missing-errors-doc` and `missing errors doc` are now valid aliases for lint names
+ +  * Improved fuzzy search in lint descriptions
+ +* Various README improvements
+ +  [#6287](https://github.com/rust-lang/rust-clippy/pull/6287)
+ +* Add known problems to [`comparison_chain`] documentation
+ +  [#6390](https://github.com/rust-lang/rust-clippy/pull/6390)
+ +* Fix example used in [`cargo_common_metadata`]
+ +  [#6293](https://github.com/rust-lang/rust-clippy/pull/6293)
+ +* Improve [`map_clone`] documentation
+ +  [#6340](https://github.com/rust-lang/rust-clippy/pull/6340)
+ +
+ +### Others
+ +
+ +* You can now tell Clippy about the MSRV your project supports. Please refer to
+ +  the specific README section to learn more about MSRV support [here][msrv_readme]
+ +  [#6201](https://github.com/rust-lang/rust-clippy/pull/6201)
+ +* Add `--no-deps` option to avoid running on path dependencies in workspaces
+ +  [#6188](https://github.com/rust-lang/rust-clippy/pull/6188)
+ +
+ +## Rust 1.49
+ +
+ +Released 2020-12-31
+ +
+ +[e636b88...b20d4c1](https://github.com/rust-lang/rust-clippy/compare/e636b88...b20d4c1)
+ +
+ +### New Lints
+ +
+ +* [`field_reassign_with_default`] [#5911](https://github.com/rust-lang/rust-clippy/pull/5911)
+ +* [`await_holding_refcell_ref`] [#6029](https://github.com/rust-lang/rust-clippy/pull/6029)
+ +* [`disallowed_methods`] [#6081](https://github.com/rust-lang/rust-clippy/pull/6081)
+ +* [`inline_asm_x86_att_syntax`] [#6092](https://github.com/rust-lang/rust-clippy/pull/6092)
+ +* [`inline_asm_x86_intel_syntax`] [#6092](https://github.com/rust-lang/rust-clippy/pull/6092)
+ +* [`from_iter_instead_of_collect`] [#6101](https://github.com/rust-lang/rust-clippy/pull/6101)
+ +* [`mut_mutex_lock`] [#6103](https://github.com/rust-lang/rust-clippy/pull/6103)
+ +* [`single_element_loop`] [#6109](https://github.com/rust-lang/rust-clippy/pull/6109)
+ +* [`manual_unwrap_or`] [#6123](https://github.com/rust-lang/rust-clippy/pull/6123)
+ +* [`large_types_passed_by_value`] [#6135](https://github.com/rust-lang/rust-clippy/pull/6135)
+ +* [`result_unit_err`] [#6157](https://github.com/rust-lang/rust-clippy/pull/6157)
+ +* [`ref_option_ref`] [#6165](https://github.com/rust-lang/rust-clippy/pull/6165)
+ +* [`manual_range_contains`] [#6177](https://github.com/rust-lang/rust-clippy/pull/6177)
+ +* [`unusual_byte_groupings`] [#6183](https://github.com/rust-lang/rust-clippy/pull/6183)
+ +* [`comparison_to_empty`] [#6226](https://github.com/rust-lang/rust-clippy/pull/6226)
+ +* [`map_collect_result_unit`] [#6227](https://github.com/rust-lang/rust-clippy/pull/6227)
+ +* [`manual_ok_or`] [#6233](https://github.com/rust-lang/rust-clippy/pull/6233)
+ +
+ +### Moves and Deprecations
+ +
+ +* Rename `single_char_push_str` to [`single_char_add_str`]
+ +  [#6037](https://github.com/rust-lang/rust-clippy/pull/6037)
+ +* Rename `zero_width_space` to [`invisible_characters`]
+ +  [#6105](https://github.com/rust-lang/rust-clippy/pull/6105)
+ +* Deprecate `drop_bounds` (uplifted)
+ +  [#6111](https://github.com/rust-lang/rust-clippy/pull/6111)
+ +* Move [`string_lit_as_bytes`] to `nursery`
+ +  [#6117](https://github.com/rust-lang/rust-clippy/pull/6117)
+ +* Move [`rc_buffer`] to `restriction`
+ +  [#6128](https://github.com/rust-lang/rust-clippy/pull/6128)
+ +
+ +### Enhancements
+ +
+ +* [`manual_memcpy`]: Also lint when there are loop counters (and produce a
+ +  reliable suggestion)
+ +  [#5727](https://github.com/rust-lang/rust-clippy/pull/5727)
+ +* [`single_char_add_str`]: Also lint on `String::insert_str`
+ +  [#6037](https://github.com/rust-lang/rust-clippy/pull/6037)
+ +* [`invisible_characters`]: Also lint the characters `\u{AD}` and `\u{2060}`
+ +  [#6105](https://github.com/rust-lang/rust-clippy/pull/6105)
+ +* [`eq_op`]: Also lint on the `assert_*!` macro family
+ +  [#6167](https://github.com/rust-lang/rust-clippy/pull/6167)
+ +* [`items_after_statements`]: Also lint in local macro expansions
+ +  [#6176](https://github.com/rust-lang/rust-clippy/pull/6176)
+ +* [`unnecessary_cast`]: Also lint casts on integer and float literals
+ +  [#6187](https://github.com/rust-lang/rust-clippy/pull/6187)
+ +* [`manual_unwrap_or`]: Also lint `Result::unwrap_or`
+ +  [#6190](https://github.com/rust-lang/rust-clippy/pull/6190)
+ +* [`match_like_matches_macro`]: Also lint when `match` has more than two arms
+ +  [#6216](https://github.com/rust-lang/rust-clippy/pull/6216)
+ +* [`integer_arithmetic`]: Better handle `/` an `%` operators
+ +  [#6229](https://github.com/rust-lang/rust-clippy/pull/6229)
+ +
+ +### False Positive Fixes
+ +
+ +* [`needless_lifetimes`]: Bail out if the function has a `where` clause with the
+ +  lifetime [#5978](https://github.com/rust-lang/rust-clippy/pull/5978)
+ +* [`explicit_counter_loop`]: No longer lints, when loop counter is used after it
+ +  is incremented [#6076](https://github.com/rust-lang/rust-clippy/pull/6076)
+ +* [`or_fun_call`]: Revert changes addressing the handling of `const fn`
+ +  [#6077](https://github.com/rust-lang/rust-clippy/pull/6077)
+ +* [`needless_range_loop`]: No longer lints, when the iterable is used in the
+ +  range [#6102](https://github.com/rust-lang/rust-clippy/pull/6102)
+ +* [`inconsistent_digit_grouping`]: Fix bug when using floating point exponent
+ +  [#6104](https://github.com/rust-lang/rust-clippy/pull/6104)
+ +* [`mistyped_literal_suffixes`]: No longer lints on the fractional part of a
+ +  float (e.g. `713.32_64`)
+ +  [#6114](https://github.com/rust-lang/rust-clippy/pull/6114)
+ +* [`invalid_regex`]: No longer lint on unicode characters within `bytes::Regex`
+ +  [#6132](https://github.com/rust-lang/rust-clippy/pull/6132)
+ +* [`boxed_local`]: No longer lints on `extern fn` arguments
+ +  [#6133](https://github.com/rust-lang/rust-clippy/pull/6133)
+ +* [`needless_lifetimes`]: Fix regression, where lifetime is used in `where`
+ +  clause [#6198](https://github.com/rust-lang/rust-clippy/pull/6198)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`unnecessary_sort_by`]: Avoid dereferencing the suggested closure parameter
+ +  [#6078](https://github.com/rust-lang/rust-clippy/pull/6078)
+ +* [`needless_arbitrary_self_type`]: Correctly handle expanded code
+ +  [#6093](https://github.com/rust-lang/rust-clippy/pull/6093)
+ +* [`useless_format`]: Preserve raw strings in suggestion
+ +  [#6151](https://github.com/rust-lang/rust-clippy/pull/6151)
+ +* [`empty_loop`]: Suggest alternatives
+ +  [#6162](https://github.com/rust-lang/rust-clippy/pull/6162)
+ +* [`borrowed_box`]: Correctly add parentheses in suggestion
+ +  [#6200](https://github.com/rust-lang/rust-clippy/pull/6200)
+ +* [`unused_unit`]: Improve suggestion formatting
+ +  [#6247](https://github.com/rust-lang/rust-clippy/pull/6247)
+ +
+ +### Documentation Improvements
+ +
+ +* Some doc improvements:
+ +    * [`rc_buffer`] [#6090](https://github.com/rust-lang/rust-clippy/pull/6090)
+ +    * [`empty_loop`] [#6162](https://github.com/rust-lang/rust-clippy/pull/6162)
+ +* [`doc_markdown`]: Document problematic link text style
+ +  [#6107](https://github.com/rust-lang/rust-clippy/pull/6107)
+ +
+ +## Rust 1.48
+ +
+ +Released 2020-11-19
+ +
+ +[09bd400...e636b88](https://github.com/rust-lang/rust-clippy/compare/09bd400...e636b88)
+ +
+ +### New lints
+ +
+ +* [`self_assignment`] [#5894](https://github.com/rust-lang/rust-clippy/pull/5894)
+ +* [`unnecessary_lazy_evaluations`] [#5720](https://github.com/rust-lang/rust-clippy/pull/5720)
+ +* [`manual_strip`] [#6038](https://github.com/rust-lang/rust-clippy/pull/6038)
+ +* [`map_err_ignore`] [#5998](https://github.com/rust-lang/rust-clippy/pull/5998)
+ +* [`rc_buffer`] [#6044](https://github.com/rust-lang/rust-clippy/pull/6044)
+ +* [`to_string_in_display`] [#5831](https://github.com/rust-lang/rust-clippy/pull/5831)
+ +* `single_char_push_str` [#5881](https://github.com/rust-lang/rust-clippy/pull/5881)
+ +
+ +### Moves and Deprecations
+ +
+ +* Downgrade [`verbose_bit_mask`] to pedantic
+ +  [#6036](https://github.com/rust-lang/rust-clippy/pull/6036)
+ +
+ +### Enhancements
+ +
+ +* Extend [`precedence`] to handle chains of methods combined with unary negation
+ +  [#5928](https://github.com/rust-lang/rust-clippy/pull/5928)
+ +* [`useless_vec`]: add a configuration value for the maximum allowed size on the stack
+ +  [#5907](https://github.com/rust-lang/rust-clippy/pull/5907)
+ +* [`suspicious_arithmetic_impl`]: extend to implementations of `BitAnd`, `BitOr`, `BitXor`, `Rem`, `Shl`, and `Shr`
+ +  [#5884](https://github.com/rust-lang/rust-clippy/pull/5884)
+ +* `invalid_atomic_ordering`: detect misuse of `compare_exchange`, `compare_exchange_weak`, and `fetch_update`
+ +  [#6025](https://github.com/rust-lang/rust-clippy/pull/6025)
+ +* Avoid [`redundant_pattern_matching`] triggering in macros
+ +  [#6069](https://github.com/rust-lang/rust-clippy/pull/6069)
+ +* [`option_if_let_else`]: distinguish pure from impure `else` expressions
+ +  [#5937](https://github.com/rust-lang/rust-clippy/pull/5937)
+ +* [`needless_doctest_main`]: parse doctests instead of using textual search
+ +  [#5912](https://github.com/rust-lang/rust-clippy/pull/5912)
+ +* [`wildcard_imports`]: allow `prelude` to appear in any segment of an import
+ +  [#5929](https://github.com/rust-lang/rust-clippy/pull/5929)
+ +* Re-enable [`len_zero`] for ranges now that `range_is_empty` is stable
+ +  [#5961](https://github.com/rust-lang/rust-clippy/pull/5961)
+ +* [`option_as_ref_deref`]: catch fully-qualified calls to `Deref::deref` and `DerefMut::deref_mut`
+ +  [#5933](https://github.com/rust-lang/rust-clippy/pull/5933)
+ +
+ +### False Positive Fixes
+ +
+ +* [`useless_attribute`]: permit allowing [`wildcard_imports`] and [`enum_glob_use`]
+ +  [#5994](https://github.com/rust-lang/rust-clippy/pull/5994)
+ +* [`transmute_ptr_to_ptr`]: avoid suggesting dereferencing raw pointers in const contexts
+ +  [#5999](https://github.com/rust-lang/rust-clippy/pull/5999)
+ +* [`redundant_closure_call`]: take into account usages of the closure in nested functions and closures
+ +  [#5920](https://github.com/rust-lang/rust-clippy/pull/5920)
+ +* Fix false positive in [`borrow_interior_mutable_const`] when referencing a field behind a pointer
+ +  [#5949](https://github.com/rust-lang/rust-clippy/pull/5949)
+ +* [`doc_markdown`]: allow using "GraphQL" without backticks
+ +  [#5996](https://github.com/rust-lang/rust-clippy/pull/5996)
+ +* [`to_string_in_display`]: avoid linting when calling `to_string()` on anything that is not `self`
+ +  [#5971](https://github.com/rust-lang/rust-clippy/pull/5971)
+ +* [`indexing_slicing`] and [`out_of_bounds_indexing`] treat references to arrays as arrays
+ +  [#6034](https://github.com/rust-lang/rust-clippy/pull/6034)
+ +* [`should_implement_trait`]: ignore methods with lifetime parameters
+ +  [#5725](https://github.com/rust-lang/rust-clippy/pull/5725)
+ +* [`needless_return`]: avoid linting if a temporary borrows a local variable
+ +  [#5903](https://github.com/rust-lang/rust-clippy/pull/5903)
+ +* Restrict [`unnecessary_sort_by`] to non-reference, Copy types
+ +  [#6006](https://github.com/rust-lang/rust-clippy/pull/6006)
+ +* Avoid suggesting `from_bits`/`to_bits` in const contexts in [`transmute_int_to_float`]
+ +  [#5919](https://github.com/rust-lang/rust-clippy/pull/5919)
+ +* [`declare_interior_mutable_const`] and [`borrow_interior_mutable_const`]: improve detection of interior mutable types
+ +  [#6046](https://github.com/rust-lang/rust-clippy/pull/6046)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* [`let_and_return`]: add a cast to the suggestion when the return expression has adjustments
+ +  [#5946](https://github.com/rust-lang/rust-clippy/pull/5946)
+ +* [`useless_conversion`]: show the type in the error message
+ +  [#6035](https://github.com/rust-lang/rust-clippy/pull/6035)
+ +* [`unnecessary_mut_passed`]: discriminate between functions and methods in the error message
+ +  [#5892](https://github.com/rust-lang/rust-clippy/pull/5892)
+ +* [`float_cmp`] and [`float_cmp_const`]: change wording to make margin of error less ambiguous
+ +  [#6043](https://github.com/rust-lang/rust-clippy/pull/6043)
+ +* [`default_trait_access`]: do not use unnecessary type parameters in the suggestion
+ +  [#5993](https://github.com/rust-lang/rust-clippy/pull/5993)
+ +* [`collapsible_if`]: don't use expanded code in the suggestion
+ +  [#5992](https://github.com/rust-lang/rust-clippy/pull/5992)
+ +* Do not suggest empty format strings in [`print_with_newline`] and [`write_with_newline`]
+ +  [#6042](https://github.com/rust-lang/rust-clippy/pull/6042)
+ +* [`unit_arg`]: improve the readability of the suggestion
+ +  [#5931](https://github.com/rust-lang/rust-clippy/pull/5931)
+ +* [`stable_sort_primitive`]: print the type that is being sorted in the lint message
+ +  [#5935](https://github.com/rust-lang/rust-clippy/pull/5935)
+ +* Show line count and max lines in [`too_many_lines`] lint message
+ +  [#6009](https://github.com/rust-lang/rust-clippy/pull/6009)
+ +* Keep parentheses in the suggestion of [`useless_conversion`] where applicable
+ +  [#5900](https://github.com/rust-lang/rust-clippy/pull/5900)
+ +* [`option_map_unit_fn`] and [`result_map_unit_fn`]: print the unit type `()` explicitly
+ +  [#6024](https://github.com/rust-lang/rust-clippy/pull/6024)
+ +* [`redundant_allocation`]: suggest replacing `Rc<Box<T>>` with `Rc<T>`
+ +  [#5899](https://github.com/rust-lang/rust-clippy/pull/5899)
+ +* Make lint messages adhere to rustc dev guide conventions
+ +  [#5893](https://github.com/rust-lang/rust-clippy/pull/5893)
+ +
+ +### ICE Fixes
+ +
+ +* Fix ICE in [`repeat_once`]
+ +  [#5948](https://github.com/rust-lang/rust-clippy/pull/5948)
+ +
+ +### Documentation Improvements
+ +
+ +* [`mutable_key_type`]: explain potential for false positives when the interior mutable type is not accessed in the `Hash` implementation
+ +  [#6019](https://github.com/rust-lang/rust-clippy/pull/6019)
+ +* [`unnecessary_mut_passed`]: fix typo
+ +  [#5913](https://github.com/rust-lang/rust-clippy/pull/5913)
+ +* Add example of false positive to [`ptr_arg`] docs.
+ +  [#5885](https://github.com/rust-lang/rust-clippy/pull/5885)
+ +* [`box_vec`](https://rust-lang.github.io/rust-clippy/master/index.html#box_collection), [`vec_box`] and [`borrowed_box`]: add link to the documentation of `Box`
+ +  [#6023](https://github.com/rust-lang/rust-clippy/pull/6023)
+ +
+ +## Rust 1.47
+ +
+ +Released 2020-10-08
+ +
+ +[c2c07fa...09bd400](https://github.com/rust-lang/rust-clippy/compare/c2c07fa...09bd400)
+ +
+ +### New lints
+ +
+ +* [`derive_ord_xor_partial_ord`] [#5848](https://github.com/rust-lang/rust-clippy/pull/5848)
+ +* [`trait_duplication_in_bounds`] [#5852](https://github.com/rust-lang/rust-clippy/pull/5852)
+ +* [`map_identity`] [#5694](https://github.com/rust-lang/rust-clippy/pull/5694)
+ +* [`unit_return_expecting_ord`] [#5737](https://github.com/rust-lang/rust-clippy/pull/5737)
+ +* [`pattern_type_mismatch`] [#4841](https://github.com/rust-lang/rust-clippy/pull/4841)
+ +* [`repeat_once`] [#5773](https://github.com/rust-lang/rust-clippy/pull/5773)
+ +* [`same_item_push`] [#5825](https://github.com/rust-lang/rust-clippy/pull/5825)
+ +* [`needless_arbitrary_self_type`] [#5869](https://github.com/rust-lang/rust-clippy/pull/5869)
+ +* [`match_like_matches_macro`] [#5769](https://github.com/rust-lang/rust-clippy/pull/5769)
+ +* [`stable_sort_primitive`] [#5809](https://github.com/rust-lang/rust-clippy/pull/5809)
+ +* [`blanket_clippy_restriction_lints`] [#5750](https://github.com/rust-lang/rust-clippy/pull/5750)
+ +* [`option_if_let_else`] [#5301](https://github.com/rust-lang/rust-clippy/pull/5301)
+ +
+ +### Moves and Deprecations
+ +
+ +* Deprecate [`regex_macro`] lint
+ +  [#5760](https://github.com/rust-lang/rust-clippy/pull/5760)
+ +* Move [`range_minus_one`] to `pedantic`
+ +  [#5752](https://github.com/rust-lang/rust-clippy/pull/5752)
+ +
+ +### Enhancements
+ +
+ +* Improve [`needless_collect`] by catching `collect` calls followed by `iter` or `into_iter` calls
+ +  [#5837](https://github.com/rust-lang/rust-clippy/pull/5837)
+ +* [`panic`], [`todo`], [`unimplemented`] and [`unreachable`] now detect calls with formatting
+ +  [#5811](https://github.com/rust-lang/rust-clippy/pull/5811)
+ +* Detect more cases of [`suboptimal_flops`] and [`imprecise_flops`]
+ +  [#5443](https://github.com/rust-lang/rust-clippy/pull/5443)
+ +* Handle asymmetrical implementations of `PartialEq` in [`cmp_owned`]
+ +  [#5701](https://github.com/rust-lang/rust-clippy/pull/5701)
+ +* Make it possible to allow [`unsafe_derive_deserialize`]
+ +  [#5870](https://github.com/rust-lang/rust-clippy/pull/5870)
+ +* Catch `ord.min(a).max(b)` where a < b in [`min_max`]
+ +  [#5871](https://github.com/rust-lang/rust-clippy/pull/5871)
+ +* Make [`clone_on_copy`] suggestion machine applicable
+ +  [#5745](https://github.com/rust-lang/rust-clippy/pull/5745)
+ +* Enable [`len_zero`] on ranges now that `is_empty` is stable on them
+ +  [#5961](https://github.com/rust-lang/rust-clippy/pull/5961)
+ +
+ +### False Positive Fixes
+ +
+ +* Avoid triggering [`or_fun_call`] with const fns that take no arguments
+ +  [#5889](https://github.com/rust-lang/rust-clippy/pull/5889)
+ +* Fix [`redundant_closure_call`] false positive for closures that have multiple calls
+ +  [#5800](https://github.com/rust-lang/rust-clippy/pull/5800)
+ +* Don't lint cases involving `ManuallyDrop` in [`redundant_clone`]
+ +  [#5824](https://github.com/rust-lang/rust-clippy/pull/5824)
+ +* Treat a single expression the same as a single statement in the 2nd arm of a match in [`single_match_else`]
+ +  [#5771](https://github.com/rust-lang/rust-clippy/pull/5771)
+ +* Don't trigger [`unnested_or_patterns`] if the feature `or_patterns` is not enabled
+ +  [#5758](https://github.com/rust-lang/rust-clippy/pull/5758)
+ +* Avoid linting if key borrows in [`unnecessary_sort_by`]
+ +  [#5756](https://github.com/rust-lang/rust-clippy/pull/5756)
+ +* Consider `Try` impl for `Poll` when generating suggestions in [`try_err`]
+ +  [#5857](https://github.com/rust-lang/rust-clippy/pull/5857)
+ +* Take input lifetimes into account in `manual_async_fn`
+ +  [#5859](https://github.com/rust-lang/rust-clippy/pull/5859)
+ +* Fix multiple false positives in [`type_repetition_in_bounds`] and add a configuration option
+ +  [#5761](https://github.com/rust-lang/rust-clippy/pull/5761)
+ +* Limit the [`suspicious_arithmetic_impl`] lint to one binary operation
+ +  [#5820](https://github.com/rust-lang/rust-clippy/pull/5820)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* Improve readability of [`shadow_unrelated`] suggestion by truncating the RHS snippet
+ +  [#5788](https://github.com/rust-lang/rust-clippy/pull/5788)
+ +* Suggest `filter_map` instead of `flat_map` when mapping to `Option` in [`map_flatten`]
+ +  [#5846](https://github.com/rust-lang/rust-clippy/pull/5846)
+ +* Ensure suggestion is shown correctly for long method call chains in [`iter_nth_zero`]
+ +  [#5793](https://github.com/rust-lang/rust-clippy/pull/5793)
+ +* Drop borrow operator in suggestions of [`redundant_pattern_matching`]
+ +  [#5815](https://github.com/rust-lang/rust-clippy/pull/5815)
+ +* Add suggestion for [`iter_skip_next`]
+ +  [#5843](https://github.com/rust-lang/rust-clippy/pull/5843)
+ +* Improve [`collapsible_if`] fix suggestion
+ +  [#5732](https://github.com/rust-lang/rust-clippy/pull/5732)
+ +
+ +### ICE Fixes
+ +
+ +* Fix ICE caused by [`needless_collect`]
+ +  [#5877](https://github.com/rust-lang/rust-clippy/pull/5877)
+ +* Fix ICE caused by [`unnested_or_patterns`]
+ +  [#5784](https://github.com/rust-lang/rust-clippy/pull/5784)
+ +
+ +### Documentation Improvements
+ +
+ +* Fix grammar of [`await_holding_lock`] documentation
+ +  [#5748](https://github.com/rust-lang/rust-clippy/pull/5748)
+ +
+ +### Others
+ +
+ +* Make lints adhere to the rustc dev guide
+ +  [#5888](https://github.com/rust-lang/rust-clippy/pull/5888)
+ +
+ +## Rust 1.46
+ +
+ +Released 2020-08-27
+ +
+ +[7ea7cd1...c2c07fa](https://github.com/rust-lang/rust-clippy/compare/7ea7cd1...c2c07fa)
+ +
+ +### New lints
+ +
+ +* [`unnested_or_patterns`] [#5378](https://github.com/rust-lang/rust-clippy/pull/5378)
+ +* [`iter_next_slice`] [#5597](https://github.com/rust-lang/rust-clippy/pull/5597)
+ +* [`unnecessary_sort_by`] [#5623](https://github.com/rust-lang/rust-clippy/pull/5623)
+ +* [`vec_resize_to_zero`] [#5637](https://github.com/rust-lang/rust-clippy/pull/5637)
+ +
+ +### Moves and Deprecations
+ +
+ +* Move [`cast_ptr_alignment`] to pedantic [#5667](https://github.com/rust-lang/rust-clippy/pull/5667)
+ +
+ +### Enhancements
+ +
+ +* Improve [`mem_replace_with_uninit`] lint [#5695](https://github.com/rust-lang/rust-clippy/pull/5695)
+ +
+ +### False Positive Fixes
+ +
+ +* [`len_zero`]: Avoid linting ranges when the `range_is_empty` feature is not enabled
+ +  [#5656](https://github.com/rust-lang/rust-clippy/pull/5656)
+ +* [`let_and_return`]: Don't lint if a temporary borrow is involved
+ +  [#5680](https://github.com/rust-lang/rust-clippy/pull/5680)
+ +* [`reversed_empty_ranges`]: Avoid linting `N..N` in for loop arguments in
+ +  [#5692](https://github.com/rust-lang/rust-clippy/pull/5692)
+ +* [`if_same_then_else`]: Don't assume multiplication is always commutative
+ +  [#5702](https://github.com/rust-lang/rust-clippy/pull/5702)
+ +* [`blacklisted_name`]: Remove `bar` from the default configuration
+ +  [#5712](https://github.com/rust-lang/rust-clippy/pull/5712)
+ +* [`redundant_pattern_matching`]: Avoid suggesting non-`const fn` calls in const contexts
+ +  [#5724](https://github.com/rust-lang/rust-clippy/pull/5724)
+ +
+ +### Suggestion Fixes/Improvements
+ +
+ +* Fix suggestion of [`unit_arg`] lint, so that it suggest semantic equivalent code
+ +  [#4455](https://github.com/rust-lang/rust-clippy/pull/4455)
+ +* Add auto applicable suggestion to [`macro_use_imports`]
+ +  [#5279](https://github.com/rust-lang/rust-clippy/pull/5279)
+ +
+ +### ICE Fixes
+ +
+ +* Fix ICE in the `consts` module of Clippy [#5709](https://github.com/rust-lang/rust-clippy/pull/5709)
+ +
+ +### Documentation Improvements
+ +
+ +* Improve code examples across multiple lints [#5664](https://github.com/rust-lang/rust-clippy/pull/5664)
+ +
+ +### Others
+ +
+ +* Introduce a `--rustc` flag to `clippy-driver`, which turns `clippy-driver`
+ +  into `rustc` and passes all the given arguments to `rustc`. This is especially
+ +  useful for tools that need the `rustc` version Clippy was compiled with,
+ +  instead of the Clippy version. E.g. `clippy-driver --rustc --version` will
+ +  print the output of `rustc --version`.
+ +  [#5178](https://github.com/rust-lang/rust-clippy/pull/5178)
+ +* New issue templates now make it easier to complain if Clippy is too annoying
+ +  or not annoying enough! [#5735](https://github.com/rust-lang/rust-clippy/pull/5735)
+ +
+ +## Rust 1.45
+ +
+ +Released 2020-07-16
+ +
+ +[891e1a8...7ea7cd1](https://github.com/rust-lang/rust-clippy/compare/891e1a8...7ea7cd1)
+ +
+ +### New lints
+ +
+ +* [`match_wildcard_for_single_variants`] [#5582](https://github.com/rust-lang/rust-clippy/pull/5582)
+ +* [`unsafe_derive_deserialize`] [#5493](https://github.com/rust-lang/rust-clippy/pull/5493)
+ +* [`if_let_mutex`] [#5332](https://github.com/rust-lang/rust-clippy/pull/5332)
+ +* [`mismatched_target_os`] [#5506](https://github.com/rust-lang/rust-clippy/pull/5506)
+ +* [`await_holding_lock`] [#5439](https://github.com/rust-lang/rust-clippy/pull/5439)
+ +* [`match_on_vec_items`] [#5522](https://github.com/rust-lang/rust-clippy/pull/5522)
+ +* [`manual_async_fn`] [#5576](https://github.com/rust-lang/rust-clippy/pull/5576)
+ +* [`reversed_empty_ranges`] [#5583](https://github.com/rust-lang/rust-clippy/pull/5583)
+ +* [`manual_non_exhaustive`] [#5550](https://github.com/rust-lang/rust-clippy/pull/5550)
+ +
+ +### Moves and Deprecations
+ +
+ +* Downgrade [`match_bool`] to pedantic [#5408](https://github.com/rust-lang/rust-clippy/pull/5408)
+ +* Downgrade [`match_wild_err_arm`] to pedantic and update help messages. [#5622](https://github.com/rust-lang/rust-clippy/pull/5622)
+ +* Downgrade [`useless_let_if_seq`] to nursery. [#5599](https://github.com/rust-lang/rust-clippy/pull/5599)
+ +* Generalize `option_and_then_some` and rename to [`bind_instead_of_map`]. [#5529](https://github.com/rust-lang/rust-clippy/pull/5529)
+ +* Rename `identity_conversion` to [`useless_conversion`]. [#5568](https://github.com/rust-lang/rust-clippy/pull/5568)
+ +* Merge `block_in_if_condition_expr` and `block_in_if_condition_stmt` into [`blocks_in_if_conditions`].
+ +[#5563](https://github.com/rust-lang/rust-clippy/pull/5563)
+ +* Merge `option_map_unwrap_or`, `option_map_unwrap_or_else` and `result_map_unwrap_or_else` into [`map_unwrap_or`].
+ +[#5563](https://github.com/rust-lang/rust-clippy/pull/5563)
+ +* Merge `option_unwrap_used` and `result_unwrap_used` into [`unwrap_used`].
+ +[#5563](https://github.com/rust-lang/rust-clippy/pull/5563)
+ +* Merge `option_expect_used` and `result_expect_used` into [`expect_used`].
+ +[#5563](https://github.com/rust-lang/rust-clippy/pull/5563)
+ +* Merge `for_loop_over_option` and `for_loop_over_result` into [`for_loops_over_fallibles`].
+ +[#5563](https://github.com/rust-lang/rust-clippy/pull/5563)
+ +
+ +### Enhancements
+ +
+ +* Avoid running cargo lints when not enabled to improve performance. [#5505](https://github.com/rust-lang/rust-clippy/pull/5505)
+ +* Extend [`useless_conversion`] with `TryFrom` and `TryInto`. [#5631](https://github.com/rust-lang/rust-clippy/pull/5631)
+ +* Lint also in type parameters and where clauses in [`unused_unit`]. [#5592](https://github.com/rust-lang/rust-clippy/pull/5592)
+ +* Do not suggest deriving `Default` in [`new_without_default`]. [#5616](https://github.com/rust-lang/rust-clippy/pull/5616)
+ +
+ +### False Positive Fixes
+ +
+ +* [`while_let_on_iterator`] [#5525](https://github.com/rust-lang/rust-clippy/pull/5525)
+ +* [`empty_line_after_outer_attr`] [#5609](https://github.com/rust-lang/rust-clippy/pull/5609)
+ +* [`unnecessary_unwrap`] [#5558](https://github.com/rust-lang/rust-clippy/pull/5558)
+ +* [`comparison_chain`] [#5596](https://github.com/rust-lang/rust-clippy/pull/5596)
+ +* Don't trigger [`used_underscore_binding`] in await desugaring. [#5535](https://github.com/rust-lang/rust-clippy/pull/5535)
+ +* Don't trigger [`borrowed_box`] on mutable references. [#5491](https://github.com/rust-lang/rust-clippy/pull/5491)
+ +* Allow `1 << 0` in [`identity_op`]. [#5602](https://github.com/rust-lang/rust-clippy/pull/5602)
+ +* Allow `use super::*;` glob imports in [`wildcard_imports`]. [#5564](https://github.com/rust-lang/rust-clippy/pull/5564)
+ +* Whitelist more words in [`doc_markdown`]. [#5611](https://github.com/rust-lang/rust-clippy/pull/5611)
+ +* Skip dev and build deps in [`multiple_crate_versions`]. [#5636](https://github.com/rust-lang/rust-clippy/pull/5636)
+ +* Honor `allow` attribute on arguments in [`ptr_arg`]. [#5647](https://github.com/rust-lang/rust-clippy/pull/5647)
+ +* Honor lint level attributes for [`redundant_field_names`], [`just_underscores_and_digits`], [`many_single_char_names`]
+ +and [`similar_names`]. [#5651](https://github.com/rust-lang/rust-clippy/pull/5651)
+ +* Ignore calls to `len` in [`or_fun_call`]. [#4429](https://github.com/rust-lang/rust-clippy/pull/4429)
+ +
+ +### Suggestion Improvements
+ +
+ +* Simplify suggestions in [`manual_memcpy`]. [#5536](https://github.com/rust-lang/rust-clippy/pull/5536)
+ +* Fix suggestion in [`redundant_pattern_matching`] for macros. [#5511](https://github.com/rust-lang/rust-clippy/pull/5511)
+ +* Avoid suggesting `copied()` for mutable references in [`map_clone`]. [#5530](https://github.com/rust-lang/rust-clippy/pull/5530)
+ +* Improve help message for [`clone_double_ref`]. [#5547](https://github.com/rust-lang/rust-clippy/pull/5547)
+ +
+ +### ICE Fixes
+ +
+ +* Fix ICE caused in unwrap module. [#5590](https://github.com/rust-lang/rust-clippy/pull/5590)
+ +* Fix ICE on rustc test issue-69020-assoc-const-arith-overflow.rs [#5499](https://github.com/rust-lang/rust-clippy/pull/5499)
+ +
+ +### Documentation
+ +
+ +* Clarify the documentation of [`unnecessary_mut_passed`]. [#5639](https://github.com/rust-lang/rust-clippy/pull/5639)
+ +* Extend example for [`unneeded_field_pattern`]. [#5541](https://github.com/rust-lang/rust-clippy/pull/5541)
+ +
+ +## Rust 1.44
+ +
+ +Released 2020-06-04
+ +
+ +[204bb9b...891e1a8](https://github.com/rust-lang/rust-clippy/compare/204bb9b...891e1a8)
+ +
+ +### New lints
+ +
+ +* [`explicit_deref_methods`] [#5226](https://github.com/rust-lang/rust-clippy/pull/5226)
+ +* [`implicit_saturating_sub`] [#5427](https://github.com/rust-lang/rust-clippy/pull/5427)
+ +* [`macro_use_imports`] [#5230](https://github.com/rust-lang/rust-clippy/pull/5230)
+ +* [`verbose_file_reads`] [#5272](https://github.com/rust-lang/rust-clippy/pull/5272)
+ +* [`future_not_send`] [#5423](https://github.com/rust-lang/rust-clippy/pull/5423)
+ +* [`redundant_pub_crate`] [#5319](https://github.com/rust-lang/rust-clippy/pull/5319)
+ +* [`large_const_arrays`] [#5248](https://github.com/rust-lang/rust-clippy/pull/5248)
+ +* [`result_map_or_into_option`] [#5415](https://github.com/rust-lang/rust-clippy/pull/5415)
+ +* [`redundant_allocation`] [#5349](https://github.com/rust-lang/rust-clippy/pull/5349)
+ +* [`fn_address_comparisons`] [#5294](https://github.com/rust-lang/rust-clippy/pull/5294)
+ +* [`vtable_address_comparisons`] [#5294](https://github.com/rust-lang/rust-clippy/pull/5294)
+ +
+ +
+ +### Moves and Deprecations
+ +
+ +* Deprecate [`replace_consts`] lint [#5380](https://github.com/rust-lang/rust-clippy/pull/5380)
+ +* Move [`cognitive_complexity`] to nursery [#5428](https://github.com/rust-lang/rust-clippy/pull/5428)
+ +* Move [`useless_transmute`] to nursery [#5364](https://github.com/rust-lang/rust-clippy/pull/5364)
+ +* Downgrade [`inefficient_to_string`] to pedantic [#5412](https://github.com/rust-lang/rust-clippy/pull/5412)
+ +* Downgrade [`option_option`] to pedantic [#5401](https://github.com/rust-lang/rust-clippy/pull/5401)
+ +* Downgrade [`unreadable_literal`] to pedantic [#5419](https://github.com/rust-lang/rust-clippy/pull/5419)
+ +* Downgrade [`let_unit_value`] to pedantic [#5409](https://github.com/rust-lang/rust-clippy/pull/5409)
+ +* Downgrade [`trivially_copy_pass_by_ref`] to pedantic [#5410](https://github.com/rust-lang/rust-clippy/pull/5410)
+ +* Downgrade [`implicit_hasher`] to pedantic [#5411](https://github.com/rust-lang/rust-clippy/pull/5411)
+ +
+ +### Enhancements
+ +
+ +* On _nightly_ you can now use `cargo clippy --fix -Z unstable-options` to
+ +  auto-fix lints that support this [#5363](https://github.com/rust-lang/rust-clippy/pull/5363)
+ +* Make [`redundant_clone`] also trigger on cases where the cloned value is not
+ +  consumed. [#5304](https://github.com/rust-lang/rust-clippy/pull/5304)
+ +* Expand [`integer_arithmetic`] to also disallow bit-shifting [#5430](https://github.com/rust-lang/rust-clippy/pull/5430)
+ +* [`option_as_ref_deref`] now detects more deref cases [#5425](https://github.com/rust-lang/rust-clippy/pull/5425)
+ +* [`large_enum_variant`] now report the sizes of the largest and second-largest variants [#5466](https://github.com/rust-lang/rust-clippy/pull/5466)
+ +* [`bool_comparison`] now also checks for inequality comparisons that can be
+ +  written more concisely [#5365](https://github.com/rust-lang/rust-clippy/pull/5365)
+ +* Expand [`clone_on_copy`] to work in method call arguments as well [#5441](https://github.com/rust-lang/rust-clippy/pull/5441)
+ +* [`redundant_pattern_matching`] now also handles `while let` [#5483](https://github.com/rust-lang/rust-clippy/pull/5483)
+ +* [`integer_arithmetic`] now also lints references of integers [#5329](https://github.com/rust-lang/rust-clippy/pull/5329)
+ +* Expand [`float_cmp_const`] to also work on arrays [#5345](https://github.com/rust-lang/rust-clippy/pull/5345)
+ +* Trigger [`map_flatten`] when map is called on an `Option` [#5473](https://github.com/rust-lang/rust-clippy/pull/5473)
+ +
+ +### False Positive Fixes
+ +
+ +* [`many_single_char_names`] [#5468](https://github.com/rust-lang/rust-clippy/pull/5468)
+ +* [`should_implement_trait`] [#5437](https://github.com/rust-lang/rust-clippy/pull/5437)
+ +* [`unused_self`] [#5387](https://github.com/rust-lang/rust-clippy/pull/5387)
+ +* [`redundant_clone`] [#5453](https://github.com/rust-lang/rust-clippy/pull/5453)
+ +* [`precedence`] [#5445](https://github.com/rust-lang/rust-clippy/pull/5445)
+ +* [`suspicious_op_assign_impl`] [#5424](https://github.com/rust-lang/rust-clippy/pull/5424)
+ +* [`needless_lifetimes`] [#5293](https://github.com/rust-lang/rust-clippy/pull/5293)
+ +* [`redundant_pattern`] [#5287](https://github.com/rust-lang/rust-clippy/pull/5287)
+ +* [`inconsistent_digit_grouping`] [#5451](https://github.com/rust-lang/rust-clippy/pull/5451)
+ +
+ +
+ +### Suggestion Improvements
+ +
+ +* Improved [`question_mark`] lint suggestion so that it doesn't add redundant `as_ref()` [#5481](https://github.com/rust-lang/rust-clippy/pull/5481)
+ +* Improve the suggested placeholder in [`option_map_unit_fn`] [#5292](https://github.com/rust-lang/rust-clippy/pull/5292)
+ +* Improve suggestion for [`match_single_binding`] when triggered inside a closure [#5350](https://github.com/rust-lang/rust-clippy/pull/5350)
+ +
+ +### ICE Fixes
+ +
+ +* Handle the unstable `trivial_bounds` feature [#5296](https://github.com/rust-lang/rust-clippy/pull/5296)
+ +* `shadow_*` lints [#5297](https://github.com/rust-lang/rust-clippy/pull/5297)
+ +
+ +### Documentation
+ +
+ +* Fix documentation generation for configurable lints [#5353](https://github.com/rust-lang/rust-clippy/pull/5353)
+ +* Update documentation for [`new_ret_no_self`] [#5448](https://github.com/rust-lang/rust-clippy/pull/5448)
+ +* The documentation for [`option_option`] now suggest using a tri-state enum [#5403](https://github.com/rust-lang/rust-clippy/pull/5403)
+ +* Fix bit mask example in [`verbose_bit_mask`] documentation [#5454](https://github.com/rust-lang/rust-clippy/pull/5454)
+ +* [`wildcard_imports`] documentation now mentions that `use ...::prelude::*` is
+ +  not linted [#5312](https://github.com/rust-lang/rust-clippy/pull/5312)
+ +
+ +## Rust 1.43
+ +
+ +Released 2020-04-23
+ +
+ +[4ee1206...204bb9b](https://github.com/rust-lang/rust-clippy/compare/4ee1206...204bb9b)
+ +
+ +### New lints
+ +
+ +* [`imprecise_flops`] [#4897](https://github.com/rust-lang/rust-clippy/pull/4897)
+ +* [`suboptimal_flops`] [#4897](https://github.com/rust-lang/rust-clippy/pull/4897)
+ +* [`wildcard_imports`] [#5029](https://github.com/rust-lang/rust-clippy/pull/5029)
+ +* [`single_component_path_imports`] [#5058](https://github.com/rust-lang/rust-clippy/pull/5058)
+ +* [`match_single_binding`] [#5061](https://github.com/rust-lang/rust-clippy/pull/5061)
+ +* [`let_underscore_lock`] [#5101](https://github.com/rust-lang/rust-clippy/pull/5101)
+ +* [`struct_excessive_bools`] [#5125](https://github.com/rust-lang/rust-clippy/pull/5125)
+ +* [`fn_params_excessive_bools`] [#5125](https://github.com/rust-lang/rust-clippy/pull/5125)
+ +* [`option_env_unwrap`] [#5148](https://github.com/rust-lang/rust-clippy/pull/5148)
+ +* [`lossy_float_literal`] [#5202](https://github.com/rust-lang/rust-clippy/pull/5202)
+ +* [`rest_pat_in_fully_bound_structs`] [#5258](https://github.com/rust-lang/rust-clippy/pull/5258)
+ +
+ +### Moves and Deprecations
+ +
+ +* Move [`unneeded_field_pattern`] to pedantic group [#5200](https://github.com/rust-lang/rust-clippy/pull/5200)
+ +
+ +### Enhancements
+ +
+ +* Make [`missing_errors_doc`] lint also trigger on `async` functions
+ +  [#5181](https://github.com/rust-lang/rust-clippy/pull/5181)
+ +* Add more constants to [`approx_constant`] [#5193](https://github.com/rust-lang/rust-clippy/pull/5193)
+ +* Extend [`question_mark`] lint [#5266](https://github.com/rust-lang/rust-clippy/pull/5266)
+ +
+ +### False Positive Fixes
+ +
+ +* [`use_debug`] [#5047](https://github.com/rust-lang/rust-clippy/pull/5047)
+ +* [`unnecessary_unwrap`] [#5132](https://github.com/rust-lang/rust-clippy/pull/5132)
+ +* [`zero_prefixed_literal`] [#5170](https://github.com/rust-lang/rust-clippy/pull/5170)
+ +* [`missing_const_for_fn`] [#5216](https://github.com/rust-lang/rust-clippy/pull/5216)
+ +
+ +### Suggestion Improvements
+ +
+ +* Improve suggestion when blocks of code are suggested [#5134](https://github.com/rust-lang/rust-clippy/pull/5134)
+ +
+ +### ICE Fixes
+ +
+ +* `misc_early` lints [#5129](https://github.com/rust-lang/rust-clippy/pull/5129)
+ +* [`missing_errors_doc`] [#5213](https://github.com/rust-lang/rust-clippy/pull/5213)
+ +* Fix ICE when evaluating `usize`s [#5256](https://github.com/rust-lang/rust-clippy/pull/5256)
+ +
+ +### Documentation
+ +
+ +* Improve documentation of [`iter_nth_zero`]
+ +* Add documentation pages for stable releases [#5171](https://github.com/rust-lang/rust-clippy/pull/5171)
+ +
+ +### Others
+ +
+ +* Clippy now completely runs on GitHub Actions [#5190](https://github.com/rust-lang/rust-clippy/pull/5190)
+ +
+ +
+ +## Rust 1.42
+ +
+ +Released 2020-03-12
+ +
+ +[69f99e7...4ee1206](https://github.com/rust-lang/rust-clippy/compare/69f99e7...4ee1206)
+ +
+ +### New lints
+ +
+ +* [`filetype_is_file`] [#4543](https://github.com/rust-lang/rust-clippy/pull/4543)
+ +* [`let_underscore_must_use`] [#4823](https://github.com/rust-lang/rust-clippy/pull/4823)
+ +* [`modulo_arithmetic`] [#4867](https://github.com/rust-lang/rust-clippy/pull/4867)
+ +* [`mem_replace_with_default`] [#4881](https://github.com/rust-lang/rust-clippy/pull/4881)
+ +* [`mutable_key_type`] [#4885](https://github.com/rust-lang/rust-clippy/pull/4885)
+ +* [`option_as_ref_deref`] [#4945](https://github.com/rust-lang/rust-clippy/pull/4945)
+ +* [`wildcard_in_or_patterns`] [#4960](https://github.com/rust-lang/rust-clippy/pull/4960)
+ +* [`iter_nth_zero`] [#4966](https://github.com/rust-lang/rust-clippy/pull/4966)
+ +* `invalid_atomic_ordering` [#4999](https://github.com/rust-lang/rust-clippy/pull/4999)
+ +* [`skip_while_next`] [#5067](https://github.com/rust-lang/rust-clippy/pull/5067)
+ +
+ +### Moves and Deprecations
+ +
+ +* Move [`transmute_float_to_int`] from nursery to complexity group
+ +  [#5015](https://github.com/rust-lang/rust-clippy/pull/5015)
+ +* Move [`range_plus_one`] to pedantic group [#5057](https://github.com/rust-lang/rust-clippy/pull/5057)
+ +* Move [`debug_assert_with_mut_call`] to nursery group [#5106](https://github.com/rust-lang/rust-clippy/pull/5106)
+ +* Deprecate `unused_label` [#4930](https://github.com/rust-lang/rust-clippy/pull/4930)
+ +
+ +### Enhancements
+ +
+ +* Lint vectored IO in [`unused_io_amount`] [#5027](https://github.com/rust-lang/rust-clippy/pull/5027)
+ +* Make [`vec_box`] configurable by adding a size threshold [#5081](https://github.com/rust-lang/rust-clippy/pull/5081)
+ +* Also lint constants in [`cmp_nan`] [#4910](https://github.com/rust-lang/rust-clippy/pull/4910)
+ +* Fix false negative in [`expect_fun_call`] [#4915](https://github.com/rust-lang/rust-clippy/pull/4915)
+ +* Fix false negative in [`redundant_clone`] [#5017](https://github.com/rust-lang/rust-clippy/pull/5017)
+ +
+ +### False Positive Fixes
+ +
+ +* [`map_clone`] [#4937](https://github.com/rust-lang/rust-clippy/pull/4937)
+ +* [`replace_consts`] [#4977](https://github.com/rust-lang/rust-clippy/pull/4977)
+ +* [`let_and_return`] [#5008](https://github.com/rust-lang/rust-clippy/pull/5008)
+ +* [`eq_op`] [#5079](https://github.com/rust-lang/rust-clippy/pull/5079)
+ +* [`possible_missing_comma`] [#5083](https://github.com/rust-lang/rust-clippy/pull/5083)
+ +* [`debug_assert_with_mut_call`] [#5106](https://github.com/rust-lang/rust-clippy/pull/5106)
+ +* Don't trigger [`let_underscore_must_use`] in external macros
+ +  [#5082](https://github.com/rust-lang/rust-clippy/pull/5082)
+ +* Don't trigger [`empty_loop`] in `no_std` crates [#5086](https://github.com/rust-lang/rust-clippy/pull/5086)
+ +
+ +### Suggestion Improvements
+ +
+ +* `option_map_unwrap_or` [#4634](https://github.com/rust-lang/rust-clippy/pull/4634)
+ +* [`wildcard_enum_match_arm`] [#4934](https://github.com/rust-lang/rust-clippy/pull/4934)
+ +* [`cognitive_complexity`] [#4935](https://github.com/rust-lang/rust-clippy/pull/4935)
+ +* [`decimal_literal_representation`] [#4956](https://github.com/rust-lang/rust-clippy/pull/4956)
+ +* `unknown_clippy_lints` [#4963](https://github.com/rust-lang/rust-clippy/pull/4963)
+ +* [`explicit_into_iter_loop`] [#4978](https://github.com/rust-lang/rust-clippy/pull/4978)
+ +* [`useless_attribute`] [#5022](https://github.com/rust-lang/rust-clippy/pull/5022)
+ +* `if_let_some_result` [#5032](https://github.com/rust-lang/rust-clippy/pull/5032)
+ +
+ +### ICE fixes
+ +
+ +* [`unsound_collection_transmute`] [#4975](https://github.com/rust-lang/rust-clippy/pull/4975)
+ +
+ +### Documentation
+ +
+ +* Improve documentation of [`empty_enum`], [`replace_consts`], [`redundant_clone`], and [`iterator_step_by_zero`]
+ +
+ +
+ +## Rust 1.41
+ +
+ +Released 2020-01-30
+ +
+ +[c8e3cfb...69f99e7](https://github.com/rust-lang/rust-clippy/compare/c8e3cfb...69f99e7)
+ +
+ +* New Lints:
+ +  * [`exit`] [#4697](https://github.com/rust-lang/rust-clippy/pull/4697)
+ +  * [`to_digit_is_some`] [#4801](https://github.com/rust-lang/rust-clippy/pull/4801)
+ +  * [`tabs_in_doc_comments`] [#4806](https://github.com/rust-lang/rust-clippy/pull/4806)
+ +  * [`large_stack_arrays`] [#4807](https://github.com/rust-lang/rust-clippy/pull/4807)
+ +  * [`same_functions_in_if_condition`] [#4814](https://github.com/rust-lang/rust-clippy/pull/4814)
+ +  * [`zst_offset`] [#4816](https://github.com/rust-lang/rust-clippy/pull/4816)
+ +  * [`as_conversions`] [#4821](https://github.com/rust-lang/rust-clippy/pull/4821)
+ +  * [`missing_errors_doc`] [#4884](https://github.com/rust-lang/rust-clippy/pull/4884)
+ +  * [`transmute_float_to_int`] [#4889](https://github.com/rust-lang/rust-clippy/pull/4889)
+ +* Remove plugin interface, see
+ +  [Inside Rust Blog](https://blog.rust-lang.org/inside-rust/2019/11/04/Clippy-removes-plugin-interface.html) for
+ +  details [#4714](https://github.com/rust-lang/rust-clippy/pull/4714)
+ +* Move [`use_self`] to nursery group [#4863](https://github.com/rust-lang/rust-clippy/pull/4863)
+ +* Deprecate `into_iter_on_array` [#4788](https://github.com/rust-lang/rust-clippy/pull/4788)
+ +* Expand [`string_lit_as_bytes`] to also trigger when literal has escapes
+ +  [#4808](https://github.com/rust-lang/rust-clippy/pull/4808)
+ +* Fix false positive in `comparison_chain` [#4842](https://github.com/rust-lang/rust-clippy/pull/4842)
+ +* Fix false positive in `while_immutable_condition` [#4730](https://github.com/rust-lang/rust-clippy/pull/4730)
+ +* Fix false positive in `explicit_counter_loop` [#4803](https://github.com/rust-lang/rust-clippy/pull/4803)
+ +* Fix false positive in `must_use_candidate` [#4794](https://github.com/rust-lang/rust-clippy/pull/4794)
+ +* Fix false positive in `print_with_newline` and `write_with_newline`
+ +  [#4769](https://github.com/rust-lang/rust-clippy/pull/4769)
+ +* Fix false positive in `derive_hash_xor_eq` [#4766](https://github.com/rust-lang/rust-clippy/pull/4766)
+ +* Fix false positive in `missing_inline_in_public_items` [#4870](https://github.com/rust-lang/rust-clippy/pull/4870)
+ +* Fix false positive in `string_add` [#4880](https://github.com/rust-lang/rust-clippy/pull/4880)
+ +* Fix false positive in `float_arithmetic` [#4851](https://github.com/rust-lang/rust-clippy/pull/4851)
+ +* Fix false positive in `cast_sign_loss` [#4883](https://github.com/rust-lang/rust-clippy/pull/4883)
+ +* Fix false positive in `manual_swap` [#4877](https://github.com/rust-lang/rust-clippy/pull/4877)
+ +* Fix ICEs occurring while checking some block expressions [#4772](https://github.com/rust-lang/rust-clippy/pull/4772)
+ +* Fix ICE in `use_self` [#4776](https://github.com/rust-lang/rust-clippy/pull/4776)
+ +* Fix ICEs related to `const_generics` [#4780](https://github.com/rust-lang/rust-clippy/pull/4780)
+ +* Display help when running `clippy-driver` without arguments, instead of ICEing
+ +  [#4810](https://github.com/rust-lang/rust-clippy/pull/4810)
+ +* Clippy has its own ICE message now [#4588](https://github.com/rust-lang/rust-clippy/pull/4588)
+ +* Show deprecated lints in the documentation again [#4757](https://github.com/rust-lang/rust-clippy/pull/4757)
+ +* Improve Documentation by adding positive examples to some lints
+ +  [#4832](https://github.com/rust-lang/rust-clippy/pull/4832)
+ +
+ +## Rust 1.40
+ +
+ +Released 2019-12-19
+ +
+ +[4e7e71b...c8e3cfb](https://github.com/rust-lang/rust-clippy/compare/4e7e71b...c8e3cfb)
+ +
+ +* New Lints:
+ +  * [`unneeded_wildcard_pattern`] [#4537](https://github.com/rust-lang/rust-clippy/pull/4537)
+ +  * [`needless_doctest_main`] [#4603](https://github.com/rust-lang/rust-clippy/pull/4603)
+ +  * [`suspicious_unary_op_formatting`] [#4615](https://github.com/rust-lang/rust-clippy/pull/4615)
+ +  * [`debug_assert_with_mut_call`] [#4680](https://github.com/rust-lang/rust-clippy/pull/4680)
+ +  * [`unused_self`] [#4619](https://github.com/rust-lang/rust-clippy/pull/4619)
+ +  * [`inefficient_to_string`] [#4683](https://github.com/rust-lang/rust-clippy/pull/4683)
+ +  * [`must_use_unit`] [#4560](https://github.com/rust-lang/rust-clippy/pull/4560)
+ +  * [`must_use_candidate`] [#4560](https://github.com/rust-lang/rust-clippy/pull/4560)
+ +  * [`double_must_use`] [#4560](https://github.com/rust-lang/rust-clippy/pull/4560)
+ +  * [`comparison_chain`] [#4569](https://github.com/rust-lang/rust-clippy/pull/4569)
+ +  * [`unsound_collection_transmute`] [#4592](https://github.com/rust-lang/rust-clippy/pull/4592)
+ +  * [`panic`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
+ +  * [`unreachable`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
+ +  * [`todo`] [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
+ +  * `option_expect_used` [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
+ +  * `result_expect_used` [#4657](https://github.com/rust-lang/rust-clippy/pull/4657)
+ +* Move `redundant_clone` to perf group [#4509](https://github.com/rust-lang/rust-clippy/pull/4509)
+ +* Move `manual_mul_add` to nursery group [#4736](https://github.com/rust-lang/rust-clippy/pull/4736)
+ +* Expand `unit_cmp` to also work with `assert_eq!`, `debug_assert_eq!`, `assert_ne!` and `debug_assert_ne!` [#4613](https://github.com/rust-lang/rust-clippy/pull/4613)
+ +* Expand `integer_arithmetic` to also detect mutating arithmetic like `+=` [#4585](https://github.com/rust-lang/rust-clippy/pull/4585)
+ +* Fix false positive in `nonminimal_bool` [#4568](https://github.com/rust-lang/rust-clippy/pull/4568)
+ +* Fix false positive in `missing_safety_doc` [#4611](https://github.com/rust-lang/rust-clippy/pull/4611)
+ +* Fix false positive in `cast_sign_loss` [#4614](https://github.com/rust-lang/rust-clippy/pull/4614)
+ +* Fix false positive in `redundant_clone` [#4509](https://github.com/rust-lang/rust-clippy/pull/4509)
+ +* Fix false positive in `try_err` [#4721](https://github.com/rust-lang/rust-clippy/pull/4721)
+ +* Fix false positive in `toplevel_ref_arg` [#4570](https://github.com/rust-lang/rust-clippy/pull/4570)
+ +* Fix false positive in `multiple_inherent_impl` [#4593](https://github.com/rust-lang/rust-clippy/pull/4593)
+ +* Improve more suggestions and tests in preparation for the unstable `cargo fix --clippy` [#4575](https://github.com/rust-lang/rust-clippy/pull/4575)
+ +* Improve suggestion for `zero_ptr` [#4599](https://github.com/rust-lang/rust-clippy/pull/4599)
+ +* Improve suggestion for `explicit_counter_loop` [#4691](https://github.com/rust-lang/rust-clippy/pull/4691)
+ +* Improve suggestion for `mul_add` [#4602](https://github.com/rust-lang/rust-clippy/pull/4602)
+ +* Improve suggestion for `assertions_on_constants` [#4635](https://github.com/rust-lang/rust-clippy/pull/4635)
+ +* Fix ICE in `use_self` [#4671](https://github.com/rust-lang/rust-clippy/pull/4671)
+ +* Fix ICE when encountering const casts [#4590](https://github.com/rust-lang/rust-clippy/pull/4590)
+ +
+ +## Rust 1.39
+ +
+ +Released 2019-11-07
+ +
+ +[3aea860...4e7e71b](https://github.com/rust-lang/rust-clippy/compare/3aea860...4e7e71b)
+ +
+ +* New Lints:
+ +  * [`uninit_assumed_init`] [#4479](https://github.com/rust-lang/rust-clippy/pull/4479)
+ +  * [`flat_map_identity`] [#4231](https://github.com/rust-lang/rust-clippy/pull/4231)
+ +  * [`missing_safety_doc`] [#4535](https://github.com/rust-lang/rust-clippy/pull/4535)
+ +  * [`mem_replace_with_uninit`] [#4511](https://github.com/rust-lang/rust-clippy/pull/4511)
+ +  * [`suspicious_map`] [#4394](https://github.com/rust-lang/rust-clippy/pull/4394)
+ +  * `option_and_then_some` [#4386](https://github.com/rust-lang/rust-clippy/pull/4386)
+ +  * [`manual_saturating_arithmetic`] [#4498](https://github.com/rust-lang/rust-clippy/pull/4498)
+ +* Deprecate `unused_collect` lint. This is fully covered by rustc's `#[must_use]` on `collect` [#4348](https://github.com/rust-lang/rust-clippy/pull/4348)
+ +* Move `type_repetition_in_bounds` to pedantic group [#4403](https://github.com/rust-lang/rust-clippy/pull/4403)
+ +* Move `cast_lossless` to pedantic group [#4539](https://github.com/rust-lang/rust-clippy/pull/4539)
+ +* `temporary_cstring_as_ptr` now catches more cases [#4425](https://github.com/rust-lang/rust-clippy/pull/4425)
+ +* `use_self` now works in constructors, too [#4525](https://github.com/rust-lang/rust-clippy/pull/4525)
+ +* `cargo_common_metadata` now checks for license files [#4518](https://github.com/rust-lang/rust-clippy/pull/4518)
+ +* `cognitive_complexity` now includes the measured complexity in the warning message [#4469](https://github.com/rust-lang/rust-clippy/pull/4469)
+ +* Fix false positives in `block_in_if_*` lints [#4458](https://github.com/rust-lang/rust-clippy/pull/4458)
+ +* Fix false positive in `cast_lossless` [#4473](https://github.com/rust-lang/rust-clippy/pull/4473)
+ +* Fix false positive in `clone_on_copy` [#4411](https://github.com/rust-lang/rust-clippy/pull/4411)
+ +* Fix false positive in `deref_addrof` [#4487](https://github.com/rust-lang/rust-clippy/pull/4487)
+ +* Fix false positive in `too_many_lines` [#4490](https://github.com/rust-lang/rust-clippy/pull/4490)
+ +* Fix false positive in `new_ret_no_self` [#4365](https://github.com/rust-lang/rust-clippy/pull/4365)
+ +* Fix false positive in `manual_swap` [#4478](https://github.com/rust-lang/rust-clippy/pull/4478)
+ +* Fix false positive in `missing_const_for_fn` [#4450](https://github.com/rust-lang/rust-clippy/pull/4450)
+ +* Fix false positive in `extra_unused_lifetimes` [#4477](https://github.com/rust-lang/rust-clippy/pull/4477)
+ +* Fix false positive in `inherent_to_string` [#4460](https://github.com/rust-lang/rust-clippy/pull/4460)
+ +* Fix false positive in `map_entry` [#4495](https://github.com/rust-lang/rust-clippy/pull/4495)
+ +* Fix false positive in `unused_unit` [#4445](https://github.com/rust-lang/rust-clippy/pull/4445)
+ +* Fix false positive in `redundant_pattern` [#4489](https://github.com/rust-lang/rust-clippy/pull/4489)
+ +* Fix false positive in `wrong_self_convention` [#4369](https://github.com/rust-lang/rust-clippy/pull/4369)
+ +* Improve various suggestions and tests in preparation for the unstable `cargo fix --clippy` [#4558](https://github.com/rust-lang/rust-clippy/pull/4558)
+ +* Improve suggestions for `redundant_pattern_matching` [#4352](https://github.com/rust-lang/rust-clippy/pull/4352)
+ +* Improve suggestions for `explicit_write` [#4544](https://github.com/rust-lang/rust-clippy/pull/4544)
+ +* Improve suggestion for `or_fun_call` [#4522](https://github.com/rust-lang/rust-clippy/pull/4522)
+ +* Improve suggestion for `match_as_ref` [#4446](https://github.com/rust-lang/rust-clippy/pull/4446)
+ +* Improve suggestion for `unnecessary_fold_span` [#4382](https://github.com/rust-lang/rust-clippy/pull/4382)
+ +* Add suggestions for `unseparated_literal_suffix` [#4401](https://github.com/rust-lang/rust-clippy/pull/4401)
+ +* Add suggestions for `char_lit_as_u8` [#4418](https://github.com/rust-lang/rust-clippy/pull/4418)
+ +
+ +## Rust 1.38
+ +
+ +Released 2019-09-26
+ +
+ +[e3cb40e...3aea860](https://github.com/rust-lang/rust-clippy/compare/e3cb40e...3aea860)
+ +
+ +* New Lints:
+ +  * [`main_recursion`] [#4203](https://github.com/rust-lang/rust-clippy/pull/4203)
+ +  * [`inherent_to_string`] [#4259](https://github.com/rust-lang/rust-clippy/pull/4259)
+ +  * [`inherent_to_string_shadow_display`] [#4259](https://github.com/rust-lang/rust-clippy/pull/4259)
+ +  * [`type_repetition_in_bounds`] [#3766](https://github.com/rust-lang/rust-clippy/pull/3766)
+ +  * [`try_err`] [#4222](https://github.com/rust-lang/rust-clippy/pull/4222)
+ +* Move `{unnnecessary,panicking}_unwrap` out of nursery [#4307](https://github.com/rust-lang/rust-clippy/pull/4307)
+ +* Extend the `use_self` lint to suggest uses of `Self::Variant` [#4308](https://github.com/rust-lang/rust-clippy/pull/4308)
+ +* Improve suggestion for needless return [#4262](https://github.com/rust-lang/rust-clippy/pull/4262)
+ +* Add auto-fixable suggestion for `let_unit` [#4337](https://github.com/rust-lang/rust-clippy/pull/4337)
+ +* Fix false positive in `pub_enum_variant_names` and `enum_variant_names` [#4345](https://github.com/rust-lang/rust-clippy/pull/4345)
+ +* Fix false positive in `cast_ptr_alignment` [#4257](https://github.com/rust-lang/rust-clippy/pull/4257)
+ +* Fix false positive in `string_lit_as_bytes` [#4233](https://github.com/rust-lang/rust-clippy/pull/4233)
+ +* Fix false positive in `needless_lifetimes` [#4266](https://github.com/rust-lang/rust-clippy/pull/4266)
+ +* Fix false positive in `float_cmp` [#4275](https://github.com/rust-lang/rust-clippy/pull/4275)
+ +* Fix false positives in `needless_return` [#4274](https://github.com/rust-lang/rust-clippy/pull/4274)
+ +* Fix false negative in `match_same_arms` [#4246](https://github.com/rust-lang/rust-clippy/pull/4246)
+ +* Fix incorrect suggestion for `needless_bool` [#4335](https://github.com/rust-lang/rust-clippy/pull/4335)
+ +* Improve suggestion for `cast_ptr_alignment` [#4257](https://github.com/rust-lang/rust-clippy/pull/4257)
+ +* Improve suggestion for `single_char_literal` [#4361](https://github.com/rust-lang/rust-clippy/pull/4361)
+ +* Improve suggestion for `len_zero` [#4314](https://github.com/rust-lang/rust-clippy/pull/4314)
+ +* Fix ICE in `implicit_hasher` [#4268](https://github.com/rust-lang/rust-clippy/pull/4268)
+ +* Fix allow bug in `trivially_copy_pass_by_ref` [#4250](https://github.com/rust-lang/rust-clippy/pull/4250)
+ +
+ +## Rust 1.37
+ +
+ +Released 2019-08-15
+ +
+ +[082cfa7...e3cb40e](https://github.com/rust-lang/rust-clippy/compare/082cfa7...e3cb40e)
+ +
+ +* New Lints:
+ +  * [`checked_conversions`] [#4088](https://github.com/rust-lang/rust-clippy/pull/4088)
+ +  * [`get_last_with_len`] [#3832](https://github.com/rust-lang/rust-clippy/pull/3832)
+ +  * [`integer_division`] [#4195](https://github.com/rust-lang/rust-clippy/pull/4195)
+ +* Renamed Lint: `const_static_lifetime` is now called [`redundant_static_lifetimes`].
+ +  The lint now covers statics in addition to consts [#4162](https://github.com/rust-lang/rust-clippy/pull/4162)
+ +* [`match_same_arms`] now warns for all identical arms, instead of only the first one [#4102](https://github.com/rust-lang/rust-clippy/pull/4102)
+ +* [`needless_return`] now works with void functions [#4220](https://github.com/rust-lang/rust-clippy/pull/4220)
+ +* Fix false positive in [`redundant_closure`] [#4190](https://github.com/rust-lang/rust-clippy/pull/4190)
+ +* Fix false positive in [`useless_attribute`] [#4107](https://github.com/rust-lang/rust-clippy/pull/4107)
+ +* Fix incorrect suggestion for [`float_cmp`] [#4214](https://github.com/rust-lang/rust-clippy/pull/4214)
+ +* Add suggestions for [`print_with_newline`] and [`write_with_newline`] [#4136](https://github.com/rust-lang/rust-clippy/pull/4136)
+ +* Improve suggestions for `option_map_unwrap_or_else` and `result_map_unwrap_or_else` [#4164](https://github.com/rust-lang/rust-clippy/pull/4164)
+ +* Improve suggestions for [`non_ascii_literal`] [#4119](https://github.com/rust-lang/rust-clippy/pull/4119)
+ +* Improve diagnostics for [`let_and_return`] [#4137](https://github.com/rust-lang/rust-clippy/pull/4137)
+ +* Improve diagnostics for [`trivially_copy_pass_by_ref`] [#4071](https://github.com/rust-lang/rust-clippy/pull/4071)
+ +* Add macro check for [`unreadable_literal`] [#4099](https://github.com/rust-lang/rust-clippy/pull/4099)
+ +
+ +## Rust 1.36
+ +
+ +Released 2019-07-04
+ +
+ +[eb9f9b1...082cfa7](https://github.com/rust-lang/rust-clippy/compare/eb9f9b1...082cfa7)
+ +
+ +* New lints: [`find_map`], [`filter_map_next`] [#4039](https://github.com/rust-lang/rust-clippy/pull/4039)
+ +* New lint: [`path_buf_push_overwrite`] [#3954](https://github.com/rust-lang/rust-clippy/pull/3954)
+ +* Move `path_buf_push_overwrite` to the nursery [#4013](https://github.com/rust-lang/rust-clippy/pull/4013)
+ +* Split [`redundant_closure`] into [`redundant_closure`] and [`redundant_closure_for_method_calls`] [#4110](https://github.com/rust-lang/rust-clippy/pull/4101)
+ +* Allow allowing of [`toplevel_ref_arg`] lint [#4007](https://github.com/rust-lang/rust-clippy/pull/4007)
+ +* Fix false negative in [`or_fun_call`] pertaining to nested constructors [#4084](https://github.com/rust-lang/rust-clippy/pull/4084)
+ +* Fix false positive in [`or_fun_call`] pertaining to enum variant constructors [#4018](https://github.com/rust-lang/rust-clippy/pull/4018)
+ +* Fix false positive in [`useless_let_if_seq`] pertaining to interior mutability [#4035](https://github.com/rust-lang/rust-clippy/pull/4035)
+ +* Fix false positive in [`redundant_closure`] pertaining to non-function types [#4008](https://github.com/rust-lang/rust-clippy/pull/4008)
+ +* Fix false positive in [`let_and_return`] pertaining to attributes on `let`s [#4024](https://github.com/rust-lang/rust-clippy/pull/4024)
+ +* Fix false positive in [`module_name_repetitions`] lint pertaining to attributes [#4006](https://github.com/rust-lang/rust-clippy/pull/4006)
+ +* Fix false positive on [`assertions_on_constants`] pertaining to `debug_assert!` [#3989](https://github.com/rust-lang/rust-clippy/pull/3989)
+ +* Improve suggestion in [`map_clone`] to suggest `.copied()` where applicable  [#3970](https://github.com/rust-lang/rust-clippy/pull/3970) [#4043](https://github.com/rust-lang/rust-clippy/pull/4043)
+ +* Improve suggestion for [`search_is_some`] [#4049](https://github.com/rust-lang/rust-clippy/pull/4049)
+ +* Improve suggestion applicability for [`naive_bytecount`] [#3984](https://github.com/rust-lang/rust-clippy/pull/3984)
+ +* Improve suggestion applicability for [`while_let_loop`] [#3975](https://github.com/rust-lang/rust-clippy/pull/3975)
+ +* Improve diagnostics for [`too_many_arguments`] [#4053](https://github.com/rust-lang/rust-clippy/pull/4053)
+ +* Improve diagnostics for [`cast_lossless`] [#4021](https://github.com/rust-lang/rust-clippy/pull/4021)
+ +* Deal with macro checks in desugarings better [#4082](https://github.com/rust-lang/rust-clippy/pull/4082)
+ +* Add macro check for [`unnecessary_cast`]  [#4026](https://github.com/rust-lang/rust-clippy/pull/4026)
+ +* Remove [`approx_constant`]'s documentation's "Known problems" section. [#4027](https://github.com/rust-lang/rust-clippy/pull/4027)
+ +* Fix ICE in [`suspicious_else_formatting`] [#3960](https://github.com/rust-lang/rust-clippy/pull/3960)
+ +* Fix ICE in [`decimal_literal_representation`] [#3931](https://github.com/rust-lang/rust-clippy/pull/3931)
+ +
+ +
+ +## Rust 1.35
+ +
+ +Released 2019-05-20
+ +
+ +[1fac380..37f5c1e](https://github.com/rust-lang/rust-clippy/compare/1fac380...37f5c1e)
+ +
+ +* New lint: `drop_bounds` to detect `T: Drop` bounds
+ +* Split [`redundant_closure`] into [`redundant_closure`] and [`redundant_closure_for_method_calls`] [#4110](https://github.com/rust-lang/rust-clippy/pull/4101)
+ +* Rename `cyclomatic_complexity` to [`cognitive_complexity`], start work on making lint more practical for Rust code
+ +* Move [`get_unwrap`] to the restriction category
+ +* Improve suggestions for [`iter_cloned_collect`]
+ +* Improve suggestions for [`cast_lossless`] to suggest suffixed literals
+ +* Fix false positives in [`print_with_newline`] and [`write_with_newline`] pertaining to raw strings
+ +* Fix false positive in [`needless_range_loop`] pertaining to structs without a `.iter()`
+ +* Fix false positive in [`bool_comparison`] pertaining to non-bool types
+ +* Fix false positive in [`redundant_closure`] pertaining to differences in borrows
+ +* Fix false positive in `option_map_unwrap_or` on non-copy types
+ +* Fix false positives in [`missing_const_for_fn`] pertaining to macros and trait method impls
+ +* Fix false positive in [`needless_pass_by_value`] pertaining to procedural macros
+ +* Fix false positive in [`needless_continue`] pertaining to loop labels
+ +* Fix false positive for [`boxed_local`] pertaining to arguments moved into closures
+ +* Fix false positive for [`use_self`] in nested functions
+ +* Fix suggestion for [`expect_fun_call`] (https://github.com/rust-lang/rust-clippy/pull/3846)
+ +* Fix suggestion for [`explicit_counter_loop`] to deal with parenthesizing range variables
+ +* Fix suggestion for [`single_char_pattern`] to correctly escape single quotes
+ +* Avoid triggering [`redundant_closure`] in macros
+ +* ICE fixes: [#3805](https://github.com/rust-lang/rust-clippy/pull/3805), [#3772](https://github.com/rust-lang/rust-clippy/pull/3772), [#3741](https://github.com/rust-lang/rust-clippy/pull/3741)
+ +
+ +## Rust 1.34
+ +
+ +Released 2019-04-10
+ +
+ +[1b89724...1fac380](https://github.com/rust-lang/rust-clippy/compare/1b89724...1fac380)
+ +
+ +* New lint: [`assertions_on_constants`] to detect for example `assert!(true)`
+ +* New lint: [`dbg_macro`] to detect uses of the `dbg!` macro
+ +* New lint: [`missing_const_for_fn`] that can suggest functions to be made `const`
+ +* New lint: [`too_many_lines`] to detect functions with excessive LOC. It can be
+ +  configured using the `too-many-lines-threshold` configuration.
+ +* New lint: [`wildcard_enum_match_arm`] to check for wildcard enum matches using `_`
+ +* Expand `redundant_closure` to also work for methods (not only functions)
+ +* Fix ICEs in `vec_box`, `needless_pass_by_value` and `implicit_hasher`
+ +* Fix false positive in `cast_sign_loss`
+ +* Fix false positive in `integer_arithmetic`
+ +* Fix false positive in `unit_arg`
+ +* Fix false positives in `implicit_return`
+ +* Add suggestion to `explicit_write`
+ +* Improve suggestions for `question_mark` lint
+ +* Fix incorrect suggestion for `cast_lossless`
+ +* Fix incorrect suggestion for `expect_fun_call`
+ +* Fix incorrect suggestion for `needless_bool`
+ +* Fix incorrect suggestion for `needless_range_loop`
+ +* Fix incorrect suggestion for `use_self`
+ +* Fix incorrect suggestion for `while_let_on_iterator`
+ +* Clippy is now slightly easier to invoke in non-cargo contexts. See
+ +  [#3665][pull3665] for more details.
+ +* We now have [improved documentation][adding_lints] on how to add new lints
+ +
+ +## Rust 1.33
+ +
+ +Released 2019-02-26
+ +
+ +[b2601be...1b89724](https://github.com/rust-lang/rust-clippy/compare/b2601be...1b89724)
+ +
+ +* New lints: [`implicit_return`], [`vec_box`], [`cast_ref_to_mut`]
+ +* The `rust-clippy` repository is now part of the `rust-lang` org.
+ +* Rename `stutter` to `module_name_repetitions`
+ +* Merge `new_without_default_derive` into `new_without_default` lint
+ +* Move `large_digit_groups` from `style` group to `pedantic`
+ +* Expand `bool_comparison` to check for `<`, `<=`, `>`, `>=`, and `!=`
+ +  comparisons against booleans
+ +* Expand `no_effect` to detect writes to constants such as `A_CONST.field = 2`
+ +* Expand `redundant_clone` to work on struct fields
+ +* Expand `suspicious_else_formatting` to detect `if .. {..} {..}`
+ +* Expand `use_self` to work on tuple structs and also in local macros
+ +* Fix ICE in `result_map_unit_fn` and `option_map_unit_fn`
+ +* Fix false positives in `implicit_return`
+ +* Fix false positives in `use_self`
+ +* Fix false negative in `clone_on_copy`
+ +* Fix false positive in `doc_markdown`
+ +* Fix false positive in `empty_loop`
+ +* Fix false positive in `if_same_then_else`
+ +* Fix false positive in `infinite_iter`
+ +* Fix false positive in `question_mark`
+ +* Fix false positive in `useless_asref`
+ +* Fix false positive in `wildcard_dependencies`
+ +* Fix false positive in `write_with_newline`
+ +* Add suggestion to `explicit_write`
+ +* Improve suggestions for `question_mark` lint
+ +* Fix incorrect suggestion for `get_unwrap`
+ +
+ +## Rust 1.32
+ +
+ +Released 2019-01-17
+ +
+ +[2e26fdc2...b2601be](https://github.com/rust-lang/rust-clippy/compare/2e26fdc2...b2601be)
+ +
+ +* New lints: [`slow_vector_initialization`], `mem_discriminant_non_enum`,
+ +  [`redundant_clone`], [`wildcard_dependencies`],
+ +  [`into_iter_on_ref`], `into_iter_on_array`, [`deprecated_cfg_attr`],
+ +  [`cargo_common_metadata`]
+ +* Add support for `u128` and `i128` to integer related lints
+ +* Add float support to `mistyped_literal_suffixes`
+ +* Fix false positives in `use_self`
+ +* Fix false positives in `missing_comma`
+ +* Fix false positives in `new_ret_no_self`
+ +* Fix false positives in `possible_missing_comma`
+ +* Fix false positive in `integer_arithmetic` in constant items
+ +* Fix false positive in `needless_borrow`
+ +* Fix false positive in `out_of_bounds_indexing`
+ +* Fix false positive in `new_without_default_derive`
+ +* Fix false positive in `string_lit_as_bytes`
+ +* Fix false negative in `out_of_bounds_indexing`
+ +* Fix false negative in `use_self`. It will now also check existential types
+ +* Fix incorrect suggestion for `redundant_closure_call`
+ +* Fix various suggestions that contained expanded macros
+ +* Fix `bool_comparison` triggering 3 times on on on the same code
+ +* Expand `trivially_copy_pass_by_ref` to work on trait methods
+ +* Improve suggestion for `needless_range_loop`
+ +* Move `needless_pass_by_value` from `pedantic` group to `style`
+ +
+ +## Rust 1.31
+ +
+ +Released 2018-12-06
+ +
+ +[125907ad..2e26fdc2](https://github.com/rust-lang/rust-clippy/compare/125907ad..2e26fdc2)
+ +
+ +* Clippy has been relicensed under a dual MIT / Apache license.
+ +  See [#3093](https://github.com/rust-lang/rust-clippy/issues/3093) for more
+ +  information.
+ +* With Rust 1.31, Clippy is no longer available via crates.io. The recommended
+ +  installation method is via `rustup component add clippy`.
+ +* New lints: [`redundant_pattern_matching`], [`unnecessary_filter_map`],
+ +  [`unused_unit`], [`map_flatten`], [`mem_replace_option_with_none`]
+ +* Fix ICE in `if_let_redundant_pattern_matching`
+ +* Fix ICE in `needless_pass_by_value` when encountering a generic function
+ +  argument with a lifetime parameter
+ +* Fix ICE in `needless_range_loop`
+ +* Fix ICE in `single_char_pattern` when encountering a constant value
+ +* Fix false positive in `assign_op_pattern`
+ +* Fix false positive in `boxed_local` on trait implementations
+ +* Fix false positive in `cmp_owned`
+ +* Fix false positive in `collapsible_if` when conditionals have comments
+ +* Fix false positive in `double_parens`
+ +* Fix false positive in `excessive_precision`
+ +* Fix false positive in `explicit_counter_loop`
+ +* Fix false positive in `fn_to_numeric_cast_with_truncation`
+ +* Fix false positive in `map_clone`
+ +* Fix false positive in `new_ret_no_self`
+ +* Fix false positive in `new_without_default` when `new` is unsafe
+ +* Fix false positive in `type_complexity` when using extern types
+ +* Fix false positive in `useless_format`
+ +* Fix false positive in `wrong_self_convention`
+ +* Fix incorrect suggestion for `excessive_precision`
+ +* Fix incorrect suggestion for `expect_fun_call`
+ +* Fix incorrect suggestion for `get_unwrap`
+ +* Fix incorrect suggestion for `useless_format`
+ +* `fn_to_numeric_cast_with_truncation` lint can be disabled again
+ +* Improve suggestions for `manual_memcpy`
+ +* Improve help message for `needless_lifetimes`
+ +
+ +## Rust 1.30
+ +
+ +Released 2018-10-25
+ +
+ +[14207503...125907ad](https://github.com/rust-lang/rust-clippy/compare/14207503...125907ad)
+ +
+ +* Deprecate `assign_ops` lint
+ +* New lints: [`mistyped_literal_suffixes`], [`ptr_offset_with_cast`],
+ +  [`needless_collect`], [`copy_iterator`]
+ +* `cargo clippy -V` now includes the Clippy commit hash of the Rust
+ +  Clippy component
+ +* Fix ICE in `implicit_hasher`
+ +* Fix ICE when encountering `println!("{}" a);`
+ +* Fix ICE when encountering a macro call in match statements
+ +* Fix false positive in `default_trait_access`
+ +* Fix false positive in `trivially_copy_pass_by_ref`
+ +* Fix false positive in `similar_names`
+ +* Fix false positive in `redundant_field_name`
+ +* Fix false positive in `expect_fun_call`
+ +* Fix false negative in `identity_conversion`
+ +* Fix false negative in `explicit_counter_loop`
+ +* Fix `range_plus_one` suggestion and false negative
+ +* `print_with_newline` / `write_with_newline`: don't warn about string with several `\n`s in them
+ +* Fix `useless_attribute` to also whitelist `unused_extern_crates`
+ +* Fix incorrect suggestion for `single_char_pattern`
+ +* Improve suggestion for `identity_conversion` lint
+ +* Move `explicit_iter_loop` and `explicit_into_iter_loop` from `style` group to `pedantic`
+ +* Move `range_plus_one` and `range_minus_one` from `nursery` group to `complexity`
+ +* Move `shadow_unrelated` from `restriction` group to `pedantic`
+ +* Move `indexing_slicing` from `pedantic` group to `restriction`
+ +
+ +## Rust 1.29
+ +
+ +Released 2018-09-13
+ +
+ +[v0.0.212...14207503](https://github.com/rust-lang/rust-clippy/compare/v0.0.212...14207503)
+ +
+ +* :tada: :tada: **Rust 1.29 is the first stable Rust that includes a bundled Clippy** :tada:
+ +  :tada:
+ +  You can now run `rustup component add clippy-preview` and then `cargo
+ +  clippy` to run Clippy. This should put an end to the continuous nightly
+ +  upgrades for Clippy users.
+ +* Clippy now follows the Rust versioning scheme instead of its own
+ +* Fix ICE when encountering a `while let (..) = x.iter()` construct
+ +* Fix false positives in `use_self`
+ +* Fix false positive in `trivially_copy_pass_by_ref`
+ +* Fix false positive in `useless_attribute` lint
+ +* Fix false positive in `print_literal`
+ +* Fix `use_self` regressions
+ +* Improve lint message for `neg_cmp_op_on_partial_ord`
+ +* Improve suggestion highlight for `single_char_pattern`
+ +* Improve suggestions for various print/write macro lints
+ +* Improve website header
+ +
+ +## 0.0.212 (2018-07-10)
+ +* Rustup to *rustc 1.29.0-nightly (e06c87544 2018-07-06)*
+ +
+ +## 0.0.211
+ +* Rustup to *rustc 1.28.0-nightly (e3bf634e0 2018-06-28)*
+ +
+ +## 0.0.210
+ +* Rustup to *rustc 1.28.0-nightly (01cc982e9 2018-06-24)*
+ +
+ +## 0.0.209
+ +* Rustup to *rustc 1.28.0-nightly (523097979 2018-06-18)*
+ +
+ +## 0.0.208
+ +* Rustup to *rustc 1.28.0-nightly (86a8f1a63 2018-06-17)*
+ +
+ +## 0.0.207
+ +* Rustup to *rustc 1.28.0-nightly (2a0062974 2018-06-09)*
+ +
+ +## 0.0.206
+ +* Rustup to *rustc 1.28.0-nightly (5bf68db6e 2018-05-28)*
+ +
+ +## 0.0.205
+ +* Rustup to *rustc 1.28.0-nightly (990d8aa74 2018-05-25)*
+ +* Rename `unused_lifetimes` to `extra_unused_lifetimes` because of naming conflict with new rustc lint
+ +
+ +## 0.0.204
+ +* Rustup to *rustc 1.28.0-nightly (71e87be38 2018-05-22)*
+ +
+ +## 0.0.203
+ +* Rustup to *rustc 1.28.0-nightly (a3085756e 2018-05-19)*
+ +* Clippy attributes are now of the form `clippy::cyclomatic_complexity` instead of `clippy(cyclomatic_complexity)`
+ +
+ +## 0.0.202
+ +* Rustup to *rustc 1.28.0-nightly (952f344cd 2018-05-18)*
+ +
+ +## 0.0.201
+ +* Rustup to *rustc 1.27.0-nightly (2f2a11dfc 2018-05-16)*
+ +
+ +## 0.0.200
+ +* Rustup to *rustc 1.27.0-nightly (9fae15374 2018-05-13)*
+ +
+ +## 0.0.199
+ +* Rustup to *rustc 1.27.0-nightly (ff2ac35db 2018-05-12)*
+ +
+ +## 0.0.198
+ +* Rustup to *rustc 1.27.0-nightly (acd3871ba 2018-05-10)*
+ +
+ +## 0.0.197
+ +* Rustup to *rustc 1.27.0-nightly (428ea5f6b 2018-05-06)*
+ +
+ +## 0.0.196
+ +* Rustup to *rustc 1.27.0-nightly (e82261dfb 2018-05-03)*
+ +
+ +## 0.0.195
+ +* Rustup to *rustc 1.27.0-nightly (ac3c2288f 2018-04-18)*
+ +
+ +## 0.0.194
+ +* Rustup to *rustc 1.27.0-nightly (bd40cbbe1 2018-04-14)*
+ +* New lints: [`cast_ptr_alignment`], [`transmute_ptr_to_ptr`], [`write_literal`], [`write_with_newline`], [`writeln_empty_string`]
+ +
+ +## 0.0.193
+ +* Rustup to *rustc 1.27.0-nightly (eeea94c11 2018-04-06)*
+ +
+ +## 0.0.192
+ +* Rustup to *rustc 1.27.0-nightly (fb44b4c0e 2018-04-04)*
+ +* New lint: [`print_literal`]
+ +
+ +## 0.0.191
+ +* Rustup to *rustc 1.26.0-nightly (ae544ee1c 2018-03-29)*
+ +* Lint audit; categorize lints as style, correctness, complexity, pedantic, nursery, restriction.
+ +
+ +## 0.0.190
+ +* Fix a bunch of intermittent cargo bugs
+ +
+ +## 0.0.189
+ +* Rustup to *rustc 1.26.0-nightly (5508b2714 2018-03-18)*
+ +
+ +## 0.0.188
+ +* Rustup to *rustc 1.26.0-nightly (392645394 2018-03-15)*
+ +* New lint: [`while_immutable_condition`]
+ +
+ +## 0.0.187
+ +* Rustup to *rustc 1.26.0-nightly (322d7f7b9 2018-02-25)*
+ +* New lints: [`redundant_field_names`], [`suspicious_arithmetic_impl`], [`suspicious_op_assign_impl`]
+ +
+ +## 0.0.186
+ +* Rustup to *rustc 1.25.0-nightly (0c6091fbd 2018-02-04)*
+ +* Various false positive fixes
+ +
+ +## 0.0.185
+ +* Rustup to *rustc 1.25.0-nightly (56733bc9f 2018-02-01)*
+ +* New lint: [`question_mark`]
+ +
+ +## 0.0.184
+ +* Rustup to *rustc 1.25.0-nightly (90eb44a58 2018-01-29)*
+ +* New lints: [`double_comparisons`], [`empty_line_after_outer_attr`]
+ +
+ +## 0.0.183
+ +* Rustup to *rustc 1.25.0-nightly (21882aad7 2018-01-28)*
+ +* New lint: [`misaligned_transmute`]
+ +
+ +## 0.0.182
+ +* Rustup to *rustc 1.25.0-nightly (a0dcecff9 2018-01-24)*
+ +* New lint: [`decimal_literal_representation`]
+ +
+ +## 0.0.181
+ +* Rustup to *rustc 1.25.0-nightly (97520ccb1 2018-01-21)*
+ +* New lints: [`else_if_without_else`], [`option_option`], [`unit_arg`], [`unnecessary_fold`]
+ +* Removed `unit_expr`
+ +* Various false positive fixes for [`needless_pass_by_value`]
+ +
+ +## 0.0.180
+ +* Rustup to *rustc 1.25.0-nightly (3f92e8d89 2018-01-14)*
+ +
+ +## 0.0.179
+ +* Rustup to *rustc 1.25.0-nightly (61452e506 2018-01-09)*
+ +
+ +## 0.0.178
+ +* Rustup to *rustc 1.25.0-nightly (ee220daca 2018-01-07)*
+ +
+ +## 0.0.177
+ +* Rustup to *rustc 1.24.0-nightly (250b49205 2017-12-21)*
+ +* New lint: [`match_as_ref`]
+ +
+ +## 0.0.176
+ +* Rustup to *rustc 1.24.0-nightly (0077d128d 2017-12-14)*
+ +
+ +## 0.0.175
+ +* Rustup to *rustc 1.24.0-nightly (bb42071f6 2017-12-01)*
+ +
+ +## 0.0.174
+ +* Rustup to *rustc 1.23.0-nightly (63739ab7b 2017-11-21)*
+ +
+ +## 0.0.173
+ +* Rustup to *rustc 1.23.0-nightly (33374fa9d 2017-11-20)*
+ +
+ +## 0.0.172
+ +* Rustup to *rustc 1.23.0-nightly (d0f8e2913 2017-11-16)*
+ +
+ +## 0.0.171
+ +* Rustup to *rustc 1.23.0-nightly (ff0f5de3b 2017-11-14)*
+ +
+ +## 0.0.170
+ +* Rustup to *rustc 1.23.0-nightly (d6b06c63a 2017-11-09)*
+ +
+ +## 0.0.169
+ +* Rustup to *rustc 1.23.0-nightly (3b82e4c74 2017-11-05)*
+ +* New lints: [`just_underscores_and_digits`], `result_map_unwrap_or_else`, [`transmute_bytes_to_str`]
+ +
+ +## 0.0.168
+ +* Rustup to *rustc 1.23.0-nightly (f0fe716db 2017-10-30)*
+ +
+ +## 0.0.167
+ +* Rustup to *rustc 1.23.0-nightly (90ef3372e 2017-10-29)*
+ +* New lints: `const_static_lifetime`, [`erasing_op`], [`fallible_impl_from`], [`println_empty_string`], [`useless_asref`]
+ +
+ +## 0.0.166
+ +* Rustup to *rustc 1.22.0-nightly (b7960878b 2017-10-18)*
+ +* New lints: [`explicit_write`], `identity_conversion`, [`implicit_hasher`], `invalid_ref`, [`option_map_or_none`],
+ +  [`range_minus_one`], [`range_plus_one`], [`transmute_int_to_bool`], [`transmute_int_to_char`],
+ +  [`transmute_int_to_float`]
+ +
+ +## 0.0.165
+ +* Rust upgrade to rustc 1.22.0-nightly (0e6f4cf51 2017-09-27)
+ +* New lint: [`mut_range_bound`]
+ +
+ +## 0.0.164
+ +* Update to *rustc 1.22.0-nightly (6c476ce46 2017-09-25)*
+ +* New lint: [`int_plus_one`]
+ +
+ +## 0.0.163
+ +* Update to *rustc 1.22.0-nightly (14039a42a 2017-09-22)*
+ +
+ +## 0.0.162
+ +* Update to *rustc 1.22.0-nightly (0701b37d9 2017-09-18)*
+ +* New lint: [`chars_last_cmp`]
+ +* Improved suggestions for [`needless_borrow`], [`ptr_arg`],
+ +
+ +## 0.0.161
+ +* Update to *rustc 1.22.0-nightly (539f2083d 2017-09-13)*
+ +
+ +## 0.0.160
+ +* Update to *rustc 1.22.0-nightly (dd08c3070 2017-09-12)*
+ +
+ +## 0.0.159
+ +* Update to *rustc 1.22.0-nightly (eba374fb2 2017-09-11)*
+ +* New lint: [`clone_on_ref_ptr`]
+ +
+ +## 0.0.158
+ +* New lint: [`manual_memcpy`]
+ +* [`cast_lossless`] no longer has redundant parentheses in its suggestions
+ +* Update to *rustc 1.22.0-nightly (dead08cb3 2017-09-08)*
+ +
+ +## 0.0.157 - 2017-09-04
+ +* Update to *rustc 1.22.0-nightly (981ce7d8d 2017-09-03)*
+ +* New lint: `unit_expr`
+ +
+ +## 0.0.156 - 2017-09-03
+ +* Update to *rustc 1.22.0-nightly (744dd6c1d 2017-09-02)*
+ +
+ +## 0.0.155
+ +* Update to *rustc 1.21.0-nightly (c11f689d2 2017-08-29)*
+ +* New lint: [`infinite_iter`], [`maybe_infinite_iter`], [`cast_lossless`]
+ +
+ +## 0.0.154
+ +* Update to *rustc 1.21.0-nightly (2c0558f63 2017-08-24)*
+ +* Fix [`use_self`] triggering inside derives
+ +* Add support for linting an entire workspace with `cargo clippy --all`
+ +* New lint: [`naive_bytecount`]
+ +
+ +## 0.0.153
+ +* Update to *rustc 1.21.0-nightly (8c303ed87 2017-08-20)*
+ +* New lint: [`use_self`]
+ +
+ +## 0.0.152
+ +* Update to *rustc 1.21.0-nightly (df511d554 2017-08-14)*
+ +
+ +## 0.0.151
+ +* Update to *rustc 1.21.0-nightly (13d94d5fa 2017-08-10)*
+ +
+ +## 0.0.150
+ +* Update to *rustc 1.21.0-nightly (215e0b10e 2017-08-08)*
+ +
+ +## 0.0.148
+ +* Update to *rustc 1.21.0-nightly (37c7d0ebb 2017-07-31)*
+ +* New lints: [`unreadable_literal`], [`inconsistent_digit_grouping`], [`large_digit_groups`]
+ +
+ +## 0.0.147
+ +* Update to *rustc 1.21.0-nightly (aac223f4f 2017-07-30)*
+ +
+ +## 0.0.146
+ +* Update to *rustc 1.21.0-nightly (52a330969 2017-07-27)*
+ +* Fixes false positives in `inline_always`
+ +* Fixes false negatives in `panic_params`
+ +
+ +## 0.0.145
+ +* Update to *rustc 1.20.0-nightly (afe145d22 2017-07-23)*
+ +
+ +## 0.0.144
+ +* Update to *rustc 1.20.0-nightly (086eaa78e 2017-07-15)*
+ +
+ +## 0.0.143
+ +* Update to *rustc 1.20.0-nightly (d84693b93 2017-07-09)*
+ +* Fix `cargo clippy` crashing on `dylib` projects
+ +* Fix false positives around `nested_while_let` and `never_loop`
+ +
+ +## 0.0.142
+ +* Update to *rustc 1.20.0-nightly (067971139 2017-07-02)*
+ +
+ +## 0.0.141
+ +* Rewrite of the `doc_markdown` lint.
+ +* Deprecated [`range_step_by_zero`]
+ +* New lint: [`iterator_step_by_zero`]
+ +* New lint: [`needless_borrowed_reference`]
+ +* Update to *rustc 1.20.0-nightly (69c65d296 2017-06-28)*
+ +
+ +## 0.0.140 - 2017-06-16
+ +* Update to *rustc 1.19.0-nightly (258ae6dd9 2017-06-15)*
+ +
+ +## 0.0.139 — 2017-06-10
+ +* Update to *rustc 1.19.0-nightly (4bf5c99af 2017-06-10)*
+ +* Fix bugs with for loop desugaring
+ +* Check for [`AsRef`]/[`AsMut`] arguments in [`wrong_self_convention`]
+ +
+ +## 0.0.138 — 2017-06-05
+ +* Update to *rustc 1.19.0-nightly (0418fa9d3 2017-06-04)*
+ +
+ +## 0.0.137 — 2017-06-05
+ +* Update to *rustc 1.19.0-nightly (6684d176c 2017-06-03)*
+ +
+ +## 0.0.136 — 2017—05—26
+ +* Update to *rustc 1.19.0-nightly (557967766 2017-05-26)*
+ +
+ +## 0.0.135 — 2017—05—24
+ +* Update to *rustc 1.19.0-nightly (5b13bff52 2017-05-23)*
+ +
+ +## 0.0.134 — 2017—05—19
+ +* Update to *rustc 1.19.0-nightly (0ed1ec9f9 2017-05-18)*
+ +
+ +## 0.0.133 — 2017—05—14
+ +* Update to *rustc 1.19.0-nightly (826d8f385 2017-05-13)*
+ +
+ +## 0.0.132 — 2017—05—05
+ +* Fix various bugs and some ices
+ +
+ +## 0.0.131 — 2017—05—04
+ +* Update to *rustc 1.19.0-nightly (2d4ed8e0c 2017-05-03)*
+ +
+ +## 0.0.130 — 2017—05—03
+ +* Update to *rustc 1.19.0-nightly (6a5fc9eec 2017-05-02)*
+ +
+ +## 0.0.129 — 2017-05-01
+ +* Update to *rustc 1.19.0-nightly (06fb4d256 2017-04-30)*
+ +
+ +## 0.0.128 — 2017-04-28
+ +* Update to *rustc 1.18.0-nightly (94e884b63 2017-04-27)*
+ +
+ +## 0.0.127 — 2017-04-27
+ +* Update to *rustc 1.18.0-nightly (036983201 2017-04-26)*
+ +* New lint: [`needless_continue`]
+ +
+ +## 0.0.126 — 2017-04-24
+ +* Update to *rustc 1.18.0-nightly (2bd4b5c6d 2017-04-23)*
+ +
+ +## 0.0.125 — 2017-04-19
+ +* Update to *rustc 1.18.0-nightly (9f2abadca 2017-04-18)*
+ +
+ +## 0.0.124 — 2017-04-16
+ +* Update to *rustc 1.18.0-nightly (d5cf1cb64 2017-04-15)*
+ +
+ +## 0.0.123 — 2017-04-07
+ +* Fix various false positives
+ +
+ +## 0.0.122 — 2017-04-07
+ +* Rustup to *rustc 1.18.0-nightly (91ae22a01 2017-04-05)*
+ +* New lint: [`op_ref`]
+ +
+ +## 0.0.121 — 2017-03-21
+ +* Rustup to *rustc 1.17.0-nightly (134c4a0f0 2017-03-20)*
+ +
+ +## 0.0.120 — 2017-03-17
+ +* Rustup to *rustc 1.17.0-nightly (0aeb9c129 2017-03-15)*
+ +
+ +## 0.0.119 — 2017-03-13
+ +* Rustup to *rustc 1.17.0-nightly (824c9ebbd 2017-03-12)*
+ +
+ +## 0.0.118 — 2017-03-05
+ +* Rustup to *rustc 1.17.0-nightly (b1e31766d 2017-03-03)*
+ +
+ +## 0.0.117 — 2017-03-01
+ +* Rustup to *rustc 1.17.0-nightly (be760566c 2017-02-28)*
+ +
+ +## 0.0.116 — 2017-02-28
+ +* Fix `cargo clippy` on 64 bit windows systems
+ +
+ +## 0.0.115 — 2017-02-27
+ +* Rustup to *rustc 1.17.0-nightly (60a0edc6c 2017-02-26)*
+ +* New lints: [`zero_ptr`], [`never_loop`], [`mut_from_ref`]
+ +
+ +## 0.0.114 — 2017-02-08
+ +* Rustup to *rustc 1.17.0-nightly (c49d10207 2017-02-07)*
+ +* Tests are now ui tests (testing the exact output of rustc)
+ +
+ +## 0.0.113 — 2017-02-04
+ +* Rustup to *rustc 1.16.0-nightly (eedaa94e3 2017-02-02)*
+ +* New lint: [`large_enum_variant`]
+ +* `explicit_into_iter_loop` provides suggestions
+ +
+ +## 0.0.112 — 2017-01-27
+ +* Rustup to *rustc 1.16.0-nightly (df8debf6d 2017-01-25)*
+ +
+ +## 0.0.111 — 2017-01-21
+ +* Rustup to *rustc 1.16.0-nightly (a52da95ce 2017-01-20)*
+ +
+ +## 0.0.110 — 2017-01-20
+ +* Add badges and categories to `Cargo.toml`
+ +
+ +## 0.0.109 — 2017-01-19
+ +* Update to *rustc 1.16.0-nightly (c07a6ae77 2017-01-17)*
+ +
+ +## 0.0.108 — 2017-01-12
+ +* Update to *rustc 1.16.0-nightly (2782e8f8f 2017-01-12)*
+ +
+ +## 0.0.107 — 2017-01-11
+ +* Update regex dependency
+ +* Fix FP when matching `&&mut` by `&ref`
+ +* Reintroduce `for (_, x) in &mut hash_map` -> `for x in hash_map.values_mut()`
+ +* New lints: [`unused_io_amount`], [`forget_ref`], [`short_circuit_statement`]
+ +
+ +## 0.0.106 — 2017-01-04
+ +* Fix FP introduced by rustup in [`wrong_self_convention`]
+ +
+ +## 0.0.105 — 2017-01-04
+ +* Update to *rustc 1.16.0-nightly (468227129 2017-01-03)*
+ +* New lints: [`deref_addrof`], [`double_parens`], [`pub_enum_variant_names`]
+ +* Fix suggestion in [`new_without_default`]
+ +* FP fix in [`absurd_extreme_comparisons`]
+ +
+ +## 0.0.104 — 2016-12-15
+ +* Update to *rustc 1.15.0-nightly (8f02c429a 2016-12-15)*
+ +
+ +## 0.0.103 — 2016-11-25
+ +* Update to *rustc 1.15.0-nightly (d5814b03e 2016-11-23)*
+ +
+ +## 0.0.102 — 2016-11-24
+ +* Update to *rustc 1.15.0-nightly (3bf2be9ce 2016-11-22)*
+ +
+ +## 0.0.101 — 2016-11-23
+ +* Update to *rustc 1.15.0-nightly (7b3eeea22 2016-11-21)*
+ +* New lint: [`string_extend_chars`]
+ +
+ +## 0.0.100 — 2016-11-20
+ +* Update to *rustc 1.15.0-nightly (ac635aa95 2016-11-18)*
+ +
+ +## 0.0.99 — 2016-11-18
+ +* Update to rustc 1.15.0-nightly (0ed951993 2016-11-14)
+ +* New lint: [`get_unwrap`]
+ +
+ +## 0.0.98 — 2016-11-08
+ +* Fixes an issue due to a change in how cargo handles `--sysroot`, which broke `cargo clippy`
+ +
+ +## 0.0.97 — 2016-11-03
+ +* For convenience, `cargo clippy` defines a `cargo-clippy` feature. This was
+ +  previously added for a short time under the name `clippy` but removed for
+ +  compatibility.
+ +* `cargo clippy --help` is more helping (and less helpful :smile:)
+ +* Rustup to *rustc 1.14.0-nightly (5665bdf3e 2016-11-02)*
+ +* New lints: [`if_let_redundant_pattern_matching`], [`partialeq_ne_impl`]
+ +
+ +## 0.0.96 — 2016-10-22
+ +* Rustup to *rustc 1.14.0-nightly (f09420685 2016-10-20)*
+ +* New lint: [`iter_skip_next`]
+ +
+ +## 0.0.95 — 2016-10-06
+ +* Rustup to *rustc 1.14.0-nightly (3210fd5c2 2016-10-05)*
+ +
+ +## 0.0.94 — 2016-10-04
+ +* Fixes bustage on Windows due to forbidden directory name
+ +
+ +## 0.0.93 — 2016-10-03
+ +* Rustup to *rustc 1.14.0-nightly (144af3e97 2016-10-02)*
+ +* `option_map_unwrap_or` and `option_map_unwrap_or_else` are now
+ +  allowed by default.
+ +* New lint: [`explicit_into_iter_loop`]
+ +
+ +## 0.0.92 — 2016-09-30
+ +* Rustup to *rustc 1.14.0-nightly (289f3a4ca 2016-09-29)*
+ +
+ +## 0.0.91 — 2016-09-28
+ +* Rustup to *rustc 1.13.0-nightly (d0623cf7b 2016-09-26)*
+ +
+ +## 0.0.90 — 2016-09-09
+ +* Rustup to *rustc 1.13.0-nightly (f1f40f850 2016-09-09)*
+ +
+ +## 0.0.89 — 2016-09-06
+ +* Rustup to *rustc 1.13.0-nightly (cbe4de78e 2016-09-05)*
+ +
+ +## 0.0.88 — 2016-09-04
+ +* Rustup to *rustc 1.13.0-nightly (70598e04f 2016-09-03)*
+ +* The following lints are not new but were only usable through the `clippy`
+ +  lint groups: [`filter_next`], `for_loop_over_option`,
+ +  `for_loop_over_result` and [`match_overlapping_arm`]. You should now be
+ +  able to `#[allow/deny]` them individually and they are available directly
+ +  through `cargo clippy`.
+ +
+ +## 0.0.87 — 2016-08-31
+ +* Rustup to *rustc 1.13.0-nightly (eac41469d 2016-08-30)*
+ +* New lints: [`builtin_type_shadow`]
+ +* Fix FP in [`zero_prefixed_literal`] and `0b`/`0o`
+ +
+ +## 0.0.86 — 2016-08-28
+ +* Rustup to *rustc 1.13.0-nightly (a23064af5 2016-08-27)*
+ +* New lints: [`missing_docs_in_private_items`], [`zero_prefixed_literal`]
+ +
+ +## 0.0.85 — 2016-08-19
+ +* Fix ICE with [`useless_attribute`]
+ +* [`useless_attribute`] ignores `unused_imports` on `use` statements
+ +
+ +## 0.0.84 — 2016-08-18
+ +* Rustup to *rustc 1.13.0-nightly (aef6971ca 2016-08-17)*
+ +
+ +## 0.0.83 — 2016-08-17
+ +* Rustup to *rustc 1.12.0-nightly (1bf5fa326 2016-08-16)*
+ +* New lints: [`print_with_newline`], [`useless_attribute`]
+ +
+ +## 0.0.82 — 2016-08-17
+ +* Rustup to *rustc 1.12.0-nightly (197be89f3 2016-08-15)*
+ +* New lint: [`module_inception`]
+ +
+ +## 0.0.81 — 2016-08-14
+ +* Rustup to *rustc 1.12.0-nightly (1deb02ea6 2016-08-12)*
+ +* New lints: [`eval_order_dependence`], [`mixed_case_hex_literals`], [`unseparated_literal_suffix`]
+ +* False positive fix in [`too_many_arguments`]
+ +* Addition of functionality to [`needless_borrow`]
+ +* Suggestions for [`clone_on_copy`]
+ +* Bug fix in [`wrong_self_convention`]
+ +* Doc improvements
+ +
+ +## 0.0.80 — 2016-07-31
+ +* Rustup to *rustc 1.12.0-nightly (1225e122f 2016-07-30)*
+ +* New lints: [`misrefactored_assign_op`], [`serde_api_misuse`]
+ +
+ +## 0.0.79 — 2016-07-10
+ +* Rustup to *rustc 1.12.0-nightly (f93aaf84c 2016-07-09)*
+ +* Major suggestions refactoring
+ +
+ +## 0.0.78 — 2016-07-02
+ +* Rustup to *rustc 1.11.0-nightly (01411937f 2016-07-01)*
+ +* New lints: [`wrong_transmute`], [`double_neg`], [`filter_map`]
+ +* For compatibility, `cargo clippy` does not defines the `clippy` feature
+ +  introduced in 0.0.76 anymore
+ +* [`collapsible_if`] now considers `if let`
+ +
+ +## 0.0.77 — 2016-06-21
+ +* Rustup to *rustc 1.11.0-nightly (5522e678b 2016-06-20)*
+ +* New lints: `stutter` and [`iter_nth`]
+ +
+ +## 0.0.76 — 2016-06-10
+ +* Rustup to *rustc 1.11.0-nightly (7d2f75a95 2016-06-09)*
+ +* `cargo clippy` now automatically defines the `clippy` feature
+ +* New lint: [`not_unsafe_ptr_arg_deref`]
+ +
+ +## 0.0.75 — 2016-06-08
+ +* Rustup to *rustc 1.11.0-nightly (763f9234b 2016-06-06)*
+ +
+ +## 0.0.74 — 2016-06-07
+ +* Fix bug with `cargo-clippy` JSON parsing
+ +* Add the `CLIPPY_DISABLE_DOCS_LINKS` environment variable to deactivate the
+ +  “for further information visit *lint-link*” message.
+ +
+ +## 0.0.73 — 2016-06-05
+ +* Fix false positives in [`useless_let_if_seq`]
+ +
+ +## 0.0.72 — 2016-06-04
+ +* Fix false positives in [`useless_let_if_seq`]
+ +
+ +## 0.0.71 — 2016-05-31
+ +* Rustup to *rustc 1.11.0-nightly (a967611d8 2016-05-30)*
+ +* New lint: [`useless_let_if_seq`]
+ +
+ +## 0.0.70 — 2016-05-28
+ +* Rustup to *rustc 1.10.0-nightly (7bddce693 2016-05-27)*
+ +* [`invalid_regex`] and [`trivial_regex`] can now warn on `RegexSet::new`,
+ +  `RegexBuilder::new` and byte regexes
+ +
+ +## 0.0.69 — 2016-05-20
+ +* Rustup to *rustc 1.10.0-nightly (476fe6eef 2016-05-21)*
+ +* [`used_underscore_binding`] has been made `Allow` temporarily
+ +
+ +## 0.0.68 — 2016-05-17
+ +* Rustup to *rustc 1.10.0-nightly (cd6a40017 2016-05-16)*
+ +* New lint: [`unnecessary_operation`]
+ +
+ +## 0.0.67 — 2016-05-12
+ +* Rustup to *rustc 1.10.0-nightly (22ac88f1a 2016-05-11)*
+ +
+ +## 0.0.66 — 2016-05-11
+ +* New `cargo clippy` subcommand
+ +* New lints: [`assign_op_pattern`], [`assign_ops`], [`needless_borrow`]
+ +
+ +## 0.0.65 — 2016-05-08
+ +* Rustup to *rustc 1.10.0-nightly (62e2b2fb7 2016-05-06)*
+ +* New lints: [`float_arithmetic`], [`integer_arithmetic`]
+ +
+ +## 0.0.64 — 2016-04-26
+ +* Rustup to *rustc 1.10.0-nightly (645dd013a 2016-04-24)*
+ +* New lints: `temporary_cstring_as_ptr`, [`unsafe_removed_from_name`], and [`mem_forget`]
+ +
+ +## 0.0.63 — 2016-04-08
+ +* Rustup to *rustc 1.9.0-nightly (7979dd608 2016-04-07)*
+ +
+ +## 0.0.62 — 2016-04-07
+ +* Rustup to *rustc 1.9.0-nightly (bf5da36f1 2016-04-06)*
+ +
+ +## 0.0.61 — 2016-04-03
+ +* Rustup to *rustc 1.9.0-nightly (5ab11d72c 2016-04-02)*
+ +* New lint: [`invalid_upcast_comparisons`]
+ +
+ +## 0.0.60 — 2016-04-01
+ +* Rustup to *rustc 1.9.0-nightly (e1195c24b 2016-03-31)*
+ +
+ +## 0.0.59 — 2016-03-31
+ +* Rustup to *rustc 1.9.0-nightly (30a3849f2 2016-03-30)*
+ +* New lints: [`logic_bug`], [`nonminimal_bool`]
+ +* Fixed: [`match_same_arms`] now ignores arms with guards
+ +* Improved: [`useless_vec`] now warns on `for … in vec![…]`
+ +
+ +## 0.0.58 — 2016-03-27
+ +* Rustup to *rustc 1.9.0-nightly (d5a91e695 2016-03-26)*
+ +* New lint: [`doc_markdown`]
+ +
+ +## 0.0.57 — 2016-03-27
+ +* Update to *rustc 1.9.0-nightly (a1e29daf1 2016-03-25)*
+ +* Deprecated lints: [`str_to_string`], [`string_to_string`], [`unstable_as_slice`], [`unstable_as_mut_slice`]
+ +* New lint: [`crosspointer_transmute`]
+ +
+ +## 0.0.56 — 2016-03-23
+ +* Update to *rustc 1.9.0-nightly (0dcc413e4 2016-03-22)*
+ +* New lints: [`many_single_char_names`] and [`similar_names`]
+ +
+ +## 0.0.55 — 2016-03-21
+ +* Update to *rustc 1.9.0-nightly (02310fd31 2016-03-19)*
+ +
+ +## 0.0.54 — 2016-03-16
+ +* Update to *rustc 1.9.0-nightly (c66d2380a 2016-03-15)*
+ +
+ +## 0.0.53 — 2016-03-15
+ +* Add a [configuration file]
+ +
+ +## ~~0.0.52~~
+ +
+ +## 0.0.51 — 2016-03-13
+ +* Add `str` to types considered by [`len_zero`]
+ +* New lints: [`indexing_slicing`]
+ +
+ +## 0.0.50 — 2016-03-11
+ +* Update to *rustc 1.9.0-nightly (c9629d61c 2016-03-10)*
+ +
+ +## 0.0.49 — 2016-03-09
+ +* Update to *rustc 1.9.0-nightly (eabfc160f 2016-03-08)*
+ +* New lints: [`overflow_check_conditional`], `unused_label`, [`new_without_default`]
+ +
+ +## 0.0.48 — 2016-03-07
+ +* Fixed: ICE in [`needless_range_loop`] with globals
+ +
+ +## 0.0.47 — 2016-03-07
+ +* Update to *rustc 1.9.0-nightly (998a6720b 2016-03-07)*
+ +* New lint: [`redundant_closure_call`]
+ +
+ +[`AsMut`]: https://doc.rust-lang.org/std/convert/trait.AsMut.html
+ +[`AsRef`]: https://doc.rust-lang.org/std/convert/trait.AsRef.html
+ +[configuration file]: ./rust-clippy#configuration
+ +[pull3665]: https://github.com/rust-lang/rust-clippy/pull/3665
+ +[adding_lints]: https://github.com/rust-lang/rust-clippy/blob/master/doc/adding_lints.md
+ +[`README.md`]: https://github.com/rust-lang/rust-clippy/blob/master/README.md
+ +
+ +<!-- lint disable no-unused-definitions -->
+ +<!-- begin autogenerated links to lint list -->
+ +[`absurd_extreme_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#absurd_extreme_comparisons
+ +[`almost_swapped`]: https://rust-lang.github.io/rust-clippy/master/index.html#almost_swapped
+ +[`approx_constant`]: https://rust-lang.github.io/rust-clippy/master/index.html#approx_constant
+ +[`as_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#as_conversions
+ +[`assertions_on_constants`]: https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants
+ +[`assign_op_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_op_pattern
+ +[`assign_ops`]: https://rust-lang.github.io/rust-clippy/master/index.html#assign_ops
+ +[`async_yields_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#async_yields_async
+ +[`await_holding_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_lock
+ +[`await_holding_refcell_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#await_holding_refcell_ref
+ +[`bad_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#bad_bit_mask
+ +[`bind_instead_of_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#bind_instead_of_map
+ +[`blacklisted_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#blacklisted_name
+ +[`blanket_clippy_restriction_lints`]: https://rust-lang.github.io/rust-clippy/master/index.html#blanket_clippy_restriction_lints
+ +[`blocks_in_if_conditions`]: https://rust-lang.github.io/rust-clippy/master/index.html#blocks_in_if_conditions
+ +[`bool_assert_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_assert_comparison
+ +[`bool_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#bool_comparison
+ +[`borrow_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_as_ptr
+ +[`borrow_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrow_interior_mutable_const
+ +[`borrowed_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#borrowed_box
+ +[`box_collection`]: https://rust-lang.github.io/rust-clippy/master/index.html#box_collection
+ +[`boxed_local`]: https://rust-lang.github.io/rust-clippy/master/index.html#boxed_local
+ +[`branches_sharing_code`]: https://rust-lang.github.io/rust-clippy/master/index.html#branches_sharing_code
+ +[`builtin_type_shadow`]: https://rust-lang.github.io/rust-clippy/master/index.html#builtin_type_shadow
+ +[`bytes_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#bytes_nth
+ +[`cargo_common_metadata`]: https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata
+ +[`case_sensitive_file_extension_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#case_sensitive_file_extension_comparisons
+ +[`cast_lossless`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
+ +[`cast_possible_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_truncation
+ +[`cast_possible_wrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_possible_wrap
+ +[`cast_precision_loss`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_precision_loss
+ +[`cast_ptr_alignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_ptr_alignment
+ +[`cast_ref_to_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_ref_to_mut
+ +[`cast_sign_loss`]: https://rust-lang.github.io/rust-clippy/master/index.html#cast_sign_loss
+ +[`char_lit_as_u8`]: https://rust-lang.github.io/rust-clippy/master/index.html#char_lit_as_u8
+ +[`chars_last_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_last_cmp
+ +[`chars_next_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#chars_next_cmp
+ +[`checked_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#checked_conversions
+ +[`clone_double_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_double_ref
+ +[`clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_copy
+ +[`clone_on_ref_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#clone_on_ref_ptr
+ +[`cloned_instead_of_copied`]: https://rust-lang.github.io/rust-clippy/master/index.html#cloned_instead_of_copied
+ +[`cmp_nan`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_nan
+ +[`cmp_null`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_null
+ +[`cmp_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#cmp_owned
+ +[`cognitive_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#cognitive_complexity
+ +[`collapsible_else_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_else_if
+ +[`collapsible_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_if
+ +[`collapsible_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#collapsible_match
+ +[`comparison_chain`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_chain
+ +[`comparison_to_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#comparison_to_empty
+ +[`copy_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#copy_iterator
+ +[`create_dir`]: https://rust-lang.github.io/rust-clippy/master/index.html#create_dir
+ +[`crosspointer_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#crosspointer_transmute
+ +[`dbg_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro
+ +[`debug_assert_with_mut_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#debug_assert_with_mut_call
+ +[`decimal_literal_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#decimal_literal_representation
+ +[`declare_interior_mutable_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#declare_interior_mutable_const
+ +[`default_numeric_fallback`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_numeric_fallback
+ +[`default_trait_access`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_trait_access
+ +[`deprecated_cfg_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_cfg_attr
+ +[`deprecated_semver`]: https://rust-lang.github.io/rust-clippy/master/index.html#deprecated_semver
+ +[`deref_addrof`]: https://rust-lang.github.io/rust-clippy/master/index.html#deref_addrof
+ +[`derivable_impls`]: https://rust-lang.github.io/rust-clippy/master/index.html#derivable_impls
+ +[`derive_hash_xor_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_hash_xor_eq
+ +[`derive_ord_xor_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#derive_ord_xor_partial_ord
+ +[`disallowed_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_methods
+ +[`disallowed_script_idents`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_script_idents
+ +[`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
+ +[`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
+ +[`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
+ +[`double_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_comparisons
+ +[`double_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_must_use
+ +[`double_neg`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_neg
+ +[`double_parens`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_parens
+ +[`drop_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_copy
+ +[`drop_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#drop_ref
+ +[`duplicate_underscore_argument`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicate_underscore_argument
+ +[`duration_subsec`]: https://rust-lang.github.io/rust-clippy/master/index.html#duration_subsec
+ +[`else_if_without_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#else_if_without_else
+ +[`empty_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_enum
+ +[`empty_line_after_outer_attr`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_line_after_outer_attr
+ +[`empty_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_loop
+ +[`enum_clike_unportable_variant`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_clike_unportable_variant
+ +[`enum_glob_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_glob_use
+ +[`enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#enum_variant_names
+ +[`eq_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#eq_op
+ +[`equatable_if_let`]: https://rust-lang.github.io/rust-clippy/master/index.html#equatable_if_let
+ +[`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
+ +[`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
+ +[`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
+ +[`exhaustive_enums`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_enums
+ +[`exhaustive_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#exhaustive_structs
+ +[`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
+ +[`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
+ +[`expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_used
+ +[`expl_impl_clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#expl_impl_clone_on_copy
+ +[`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
+ +[`explicit_deref_methods`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_deref_methods
+ +[`explicit_into_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_into_iter_loop
+ +[`explicit_iter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_iter_loop
+ +[`explicit_write`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_write
+ +[`extend_from_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_from_slice
+ +[`extend_with_drain`]: https://rust-lang.github.io/rust-clippy/master/index.html#extend_with_drain
+ +[`extra_unused_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#extra_unused_lifetimes
+ +[`fallible_impl_from`]: https://rust-lang.github.io/rust-clippy/master/index.html#fallible_impl_from
+ +[`field_reassign_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#field_reassign_with_default
+ +[`filetype_is_file`]: https://rust-lang.github.io/rust-clippy/master/index.html#filetype_is_file
+ +[`filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map
+ +[`filter_map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_identity
+ +[`filter_map_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_map_next
+ +[`filter_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#filter_next
+ +[`find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#find_map
+ +[`flat_map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#flat_map_identity
+ +[`flat_map_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#flat_map_option
+ +[`float_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_arithmetic
+ +[`float_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp
+ +[`float_cmp_const`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp_const
+ +[`float_equality_without_abs`]: https://rust-lang.github.io/rust-clippy/master/index.html#float_equality_without_abs
+ +[`fn_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_address_comparisons
+ +[`fn_params_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_params_excessive_bools
+ +[`fn_to_numeric_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast
+ +[`fn_to_numeric_cast_any`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_any
+ +[`fn_to_numeric_cast_with_truncation`]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
+ +[`for_kv_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_kv_map
+ +[`for_loops_over_fallibles`]: https://rust-lang.github.io/rust-clippy/master/index.html#for_loops_over_fallibles
+ +[`forget_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_copy
+ +[`forget_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#forget_ref
+ +[`format_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#format_in_format_args
+ +[`from_iter_instead_of_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_iter_instead_of_collect
+ +[`from_over_into`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into
+ +[`from_str_radix_10`]: https://rust-lang.github.io/rust-clippy/master/index.html#from_str_radix_10
+ +[`future_not_send`]: https://rust-lang.github.io/rust-clippy/master/index.html#future_not_send
+ +[`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
+ +[`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
+ +[`identity_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_op
+ +[`if_let_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_mutex
+ +[`if_let_redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_let_redundant_pattern_matching
+ +[`if_not_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_not_else
+ +[`if_same_then_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_same_then_else
+ +[`if_then_some_else_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none
+ +[`ifs_same_cond`]: https://rust-lang.github.io/rust-clippy/master/index.html#ifs_same_cond
+ +[`implicit_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_clone
+ +[`implicit_hasher`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_hasher
+ +[`implicit_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_return
+ +[`implicit_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#implicit_saturating_sub
+ +[`imprecise_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#imprecise_flops
+ +[`inconsistent_digit_grouping`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_digit_grouping
+ +[`inconsistent_struct_constructor`]: https://rust-lang.github.io/rust-clippy/master/index.html#inconsistent_struct_constructor
+ +[`index_refutable_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice
+ +[`indexing_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing
+ +[`ineffective_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#ineffective_bit_mask
+ +[`inefficient_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inefficient_to_string
+ +[`infallible_destructuring_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#infallible_destructuring_match
+ +[`infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#infinite_iter
+ +[`inherent_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string
+ +[`inherent_to_string_shadow_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#inherent_to_string_shadow_display
+ +[`init_numbered_fields`]: https://rust-lang.github.io/rust-clippy/master/index.html#init_numbered_fields
+ +[`inline_always`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_always
+ +[`inline_asm_x86_att_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_att_syntax
+ +[`inline_asm_x86_intel_syntax`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_asm_x86_intel_syntax
+ +[`inline_fn_without_body`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_fn_without_body
+ +[`inspect_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#inspect_for_each
+ +[`int_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#int_plus_one
+ +[`integer_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_arithmetic
+ +[`integer_division`]: https://rust-lang.github.io/rust-clippy/master/index.html#integer_division
+ +[`into_iter_on_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#into_iter_on_ref
+ +[`invalid_null_ptr_usage`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_null_ptr_usage
+ +[`invalid_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_regex
+ +[`invalid_upcast_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_upcast_comparisons
+ +[`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
+ +[`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
+ +[`iter_cloned_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_cloned_collect
+ +[`iter_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_count
+ +[`iter_next_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_loop
+ +[`iter_next_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_next_slice
+ +[`iter_not_returning_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_not_returning_iterator
+ +[`iter_nth`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth
+ +[`iter_nth_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_nth_zero
++[`iter_overeager_cloned`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_overeager_cloned
+ +[`iter_skip_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#iter_skip_next
+ +[`iterator_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#iterator_step_by_zero
+ +[`just_underscores_and_digits`]: https://rust-lang.github.io/rust-clippy/master/index.html#just_underscores_and_digits
+ +[`large_const_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_const_arrays
+ +[`large_digit_groups`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_digit_groups
+ +[`large_enum_variant`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant
+ +[`large_stack_arrays`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_stack_arrays
+ +[`large_types_passed_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#large_types_passed_by_value
+ +[`len_without_is_empty`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_without_is_empty
+ +[`len_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#len_zero
+ +[`let_and_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_and_return
+ +[`let_underscore_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_drop
+ +[`let_underscore_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_lock
+ +[`let_underscore_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_underscore_must_use
+ +[`let_unit_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#let_unit_value
+ +[`linkedlist`]: https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist
+ +[`logic_bug`]: https://rust-lang.github.io/rust-clippy/master/index.html#logic_bug
+ +[`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
+ +[`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
+ +[`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
+ +[`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
+ +[`manual_async_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_async_fn
+ +[`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
+ +[`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
+ +[`manual_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_find_map
+ +[`manual_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten
+ +[`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
+ +[`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
+ +[`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
+ +[`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
+ +[`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains
+ +[`manual_saturating_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_saturating_arithmetic
+ +[`manual_split_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_split_once
+ +[`manual_str_repeat`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_str_repeat
+ +[`manual_strip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_strip
+ +[`manual_swap`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_swap
+ +[`manual_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_unwrap_or
+ +[`many_single_char_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#many_single_char_names
+ +[`map_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_clone
+ +[`map_collect_result_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_collect_result_unit
+ +[`map_entry`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_entry
+ +[`map_err_ignore`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_err_ignore
+ +[`map_flatten`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_flatten
+ +[`map_identity`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_identity
+ +[`map_unwrap_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or
+ +[`match_as_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_as_ref
+ +[`match_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_bool
+ +[`match_like_matches_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro
+ +[`match_on_vec_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_on_vec_items
+ +[`match_overlapping_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_overlapping_arm
+ +[`match_ref_pats`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_ref_pats
+ +[`match_result_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_result_ok
+ +[`match_same_arms`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_same_arms
+ +[`match_single_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_single_binding
+ +[`match_str_case_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_str_case_mismatch
+ +[`match_wild_err_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wild_err_arm
+ +[`match_wildcard_for_single_variants`]: https://rust-lang.github.io/rust-clippy/master/index.html#match_wildcard_for_single_variants
+ +[`maybe_infinite_iter`]: https://rust-lang.github.io/rust-clippy/master/index.html#maybe_infinite_iter
+ +[`mem_forget`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_forget
+ +[`mem_replace_option_with_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_option_with_none
+ +[`mem_replace_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default
+ +[`mem_replace_with_uninit`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_uninit
+ +[`min_max`]: https://rust-lang.github.io/rust-clippy/master/index.html#min_max
+ +[`misaligned_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#misaligned_transmute
+ +[`mismatched_target_os`]: https://rust-lang.github.io/rust-clippy/master/index.html#mismatched_target_os
+ +[`misrefactored_assign_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#misrefactored_assign_op
+ +[`missing_const_for_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn
+ +[`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
+ +[`missing_enforced_import_renames`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_enforced_import_renames
+ +[`missing_errors_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc
+ +[`missing_inline_in_public_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_inline_in_public_items
+ +[`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
+ +[`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
+ +[`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
+ +[`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals
+ +[`mod_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#mod_module_files
+ +[`module_inception`]: https://rust-lang.github.io/rust-clippy/master/index.html#module_inception
+ +[`module_name_repetitions`]: https://rust-lang.github.io/rust-clippy/master/index.html#module_name_repetitions
+ +[`modulo_arithmetic`]: https://rust-lang.github.io/rust-clippy/master/index.html#modulo_arithmetic
+ +[`modulo_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#modulo_one
+ +[`multiple_crate_versions`]: https://rust-lang.github.io/rust-clippy/master/index.html#multiple_crate_versions
+ +[`multiple_inherent_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#multiple_inherent_impl
+ +[`must_use_candidate`]: https://rust-lang.github.io/rust-clippy/master/index.html#must_use_candidate
+ +[`must_use_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#must_use_unit
+ +[`mut_from_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_from_ref
+ +[`mut_mut`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_mut
+ +[`mut_mutex_lock`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_mutex_lock
+ +[`mut_range_bound`]: https://rust-lang.github.io/rust-clippy/master/index.html#mut_range_bound
+ +[`mutable_key_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutable_key_type
+ +[`mutex_atomic`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_atomic
+ +[`mutex_integer`]: https://rust-lang.github.io/rust-clippy/master/index.html#mutex_integer
+ +[`naive_bytecount`]: https://rust-lang.github.io/rust-clippy/master/index.html#naive_bytecount
+ +[`needless_arbitrary_self_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_arbitrary_self_type
+ +[`needless_bitwise_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bitwise_bool
+ +[`needless_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_bool
+ +[`needless_borrow`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow
+ +[`needless_borrowed_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrowed_reference
+ +[`needless_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_collect
+ +[`needless_continue`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_continue
+ +[`needless_doctest_main`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_doctest_main
+ +[`needless_for_each`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_for_each
+ +[`needless_late_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_late_init
+ +[`needless_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_lifetimes
+ +[`needless_option_as_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_option_as_deref
+ +[`needless_pass_by_value`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_value
+ +[`needless_question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_question_mark
+ +[`needless_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_range_loop
+ +[`needless_return`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_return
+ +[`needless_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_splitn
+ +[`needless_update`]: https://rust-lang.github.io/rust-clippy/master/index.html#needless_update
+ +[`neg_cmp_op_on_partial_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_cmp_op_on_partial_ord
+ +[`neg_multiply`]: https://rust-lang.github.io/rust-clippy/master/index.html#neg_multiply
+ +[`negative_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#negative_feature_names
+ +[`never_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#never_loop
+ +[`new_ret_no_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_ret_no_self
+ +[`new_without_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default
+ +[`no_effect`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect
+ +[`no_effect_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#no_effect_underscore_binding
+ +[`non_ascii_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_ascii_literal
+ +[`non_octal_unix_permissions`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_octal_unix_permissions
+ +[`non_send_fields_in_send_ty`]: https://rust-lang.github.io/rust-clippy/master/index.html#non_send_fields_in_send_ty
+ +[`nonminimal_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonminimal_bool
+ +[`nonsensical_open_options`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonsensical_open_options
+ +[`nonstandard_macro_braces`]: https://rust-lang.github.io/rust-clippy/master/index.html#nonstandard_macro_braces
+ +[`not_unsafe_ptr_arg_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#not_unsafe_ptr_arg_deref
+ +[`octal_escapes`]: https://rust-lang.github.io/rust-clippy/master/index.html#octal_escapes
+ +[`ok_expect`]: https://rust-lang.github.io/rust-clippy/master/index.html#ok_expect
+ +[`op_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#op_ref
+ +[`option_as_ref_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_as_ref_deref
+ +[`option_env_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_env_unwrap
+ +[`option_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_filter_map
+ +[`option_if_let_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_if_let_else
+ +[`option_map_or_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_or_none
+ +[`option_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_map_unit_fn
+ +[`option_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#option_option
+ +[`or_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#or_fun_call
+ +[`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
+ +[`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
+ +[`panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic
+ +[`panic_in_result_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result_fn
+ +[`panicking_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#panicking_unwrap
+ +[`partialeq_ne_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#partialeq_ne_impl
+ +[`path_buf_push_overwrite`]: https://rust-lang.github.io/rust-clippy/master/index.html#path_buf_push_overwrite
+ +[`pattern_type_mismatch`]: https://rust-lang.github.io/rust-clippy/master/index.html#pattern_type_mismatch
+ +[`possible_missing_comma`]: https://rust-lang.github.io/rust-clippy/master/index.html#possible_missing_comma
+ +[`precedence`]: https://rust-lang.github.io/rust-clippy/master/index.html#precedence
+ +[`print_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_literal
+ +[`print_stderr`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_stderr
+ +[`print_stdout`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_stdout
+ +[`print_with_newline`]: https://rust-lang.github.io/rust-clippy/master/index.html#print_with_newline
+ +[`println_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#println_empty_string
+ +[`ptr_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_arg
+ +[`ptr_as_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr
+ +[`ptr_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_eq
+ +[`ptr_offset_with_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#ptr_offset_with_cast
+ +[`pub_enum_variant_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#pub_enum_variant_names
+ +[`question_mark`]: https://rust-lang.github.io/rust-clippy/master/index.html#question_mark
+ +[`range_minus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_minus_one
+ +[`range_plus_one`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_plus_one
+ +[`range_step_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_step_by_zero
+ +[`range_zip_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#range_zip_with_len
+ +[`rc_buffer`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer
+ +[`rc_mutex`]: https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex
+ +[`redundant_allocation`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation
+ +[`redundant_clone`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_clone
+ +[`redundant_closure`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure
+ +[`redundant_closure_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_call
+ +[`redundant_closure_for_method_calls`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_closure_for_method_calls
+ +[`redundant_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_else
+ +[`redundant_feature_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_feature_names
+ +[`redundant_field_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names
+ +[`redundant_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern
+ +[`redundant_pattern_matching`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pattern_matching
+ +[`redundant_pub_crate`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_pub_crate
+ +[`redundant_slicing`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_slicing
+ +[`redundant_static_lifetimes`]: https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes
+ +[`ref_binding_to_reference`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_binding_to_reference
+ +[`ref_in_deref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_in_deref
+ +[`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
+ +[`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
+ +[`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
+ +[`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
+ +[`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
+ +[`result_map_or_into_option`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_or_into_option
+ +[`result_map_unit_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_map_unit_fn
+ +[`result_unit_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unit_err
+ +[`return_self_not_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#return_self_not_must_use
+ +[`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
+ +[`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
+ +[`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
+ +[`same_name_method`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_name_method
+ +[`search_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#search_is_some
+ +[`self_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_assignment
+ +[`self_named_constructors`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_constructors
+ +[`self_named_module_files`]: https://rust-lang.github.io/rust-clippy/master/index.html#self_named_module_files
+ +[`semicolon_if_nothing_returned`]: https://rust-lang.github.io/rust-clippy/master/index.html#semicolon_if_nothing_returned
+ +[`separated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#separated_literal_suffix
+ +[`serde_api_misuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#serde_api_misuse
+ +[`shadow_reuse`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_reuse
+ +[`shadow_same`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_same
+ +[`shadow_unrelated`]: https://rust-lang.github.io/rust-clippy/master/index.html#shadow_unrelated
+ +[`short_circuit_statement`]: https://rust-lang.github.io/rust-clippy/master/index.html#short_circuit_statement
+ +[`should_assert_eq`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_assert_eq
+ +[`should_implement_trait`]: https://rust-lang.github.io/rust-clippy/master/index.html#should_implement_trait
+ +[`similar_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#similar_names
+ +[`single_char_add_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_add_str
+ +[`single_char_lifetime_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_lifetime_names
+ +[`single_char_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_char_pattern
+ +[`single_component_path_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_component_path_imports
+ +[`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
+ +[`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
+ +[`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
+ +[`size_of_in_element_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_in_element_count
+ +[`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
+ +[`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
+ +[`stable_sort_primitive`]: https://rust-lang.github.io/rust-clippy/master/index.html#stable_sort_primitive
+ +[`str_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#str_to_string
+ +[`string_add`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add
+ +[`string_add_assign`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_add_assign
+ +[`string_extend_chars`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_extend_chars
+ +[`string_from_utf8_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_from_utf8_as_bytes
+ +[`string_lit_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_lit_as_bytes
+ +[`string_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_slice
+ +[`string_to_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#string_to_string
+ +[`strlen_on_c_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#strlen_on_c_strings
+ +[`struct_excessive_bools`]: https://rust-lang.github.io/rust-clippy/master/index.html#struct_excessive_bools
+ +[`suboptimal_flops`]: https://rust-lang.github.io/rust-clippy/master/index.html#suboptimal_flops
+ +[`suspicious_arithmetic_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_arithmetic_impl
+ +[`suspicious_assignment_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_assignment_formatting
+ +[`suspicious_else_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_else_formatting
+ +[`suspicious_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_map
+ +[`suspicious_op_assign_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_op_assign_impl
+ +[`suspicious_operation_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_operation_groupings
+ +[`suspicious_splitn`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_splitn
+ +[`suspicious_unary_op_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#suspicious_unary_op_formatting
+ +[`tabs_in_doc_comments`]: https://rust-lang.github.io/rust-clippy/master/index.html#tabs_in_doc_comments
+ +[`temporary_assignment`]: https://rust-lang.github.io/rust-clippy/master/index.html#temporary_assignment
+ +[`to_digit_is_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_digit_is_some
+ +[`to_string_in_display`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_display
+ +[`to_string_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args
+ +[`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
+ +[`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
+ +[`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
+ +[`toplevel_ref_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#toplevel_ref_arg
+ +[`trailing_empty_array`]: https://rust-lang.github.io/rust-clippy/master/index.html#trailing_empty_array
+ +[`trait_duplication_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#trait_duplication_in_bounds
+ +[`transmute_bytes_to_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_bytes_to_str
+ +[`transmute_float_to_int`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_float_to_int
+ +[`transmute_int_to_bool`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_bool
+ +[`transmute_int_to_char`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_char
+ +[`transmute_int_to_float`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_int_to_float
+ +[`transmute_num_to_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_num_to_bytes
+ +[`transmute_ptr_to_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ptr
+ +[`transmute_ptr_to_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_ptr_to_ref
+ +[`transmutes_expressible_as_ptr_casts`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmutes_expressible_as_ptr_casts
+ +[`transmuting_null`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmuting_null
+ +[`trivial_regex`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivial_regex
+ +[`trivially_copy_pass_by_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref
+ +[`try_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#try_err
+ +[`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
+ +[`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
+ +[`undocumented_unsafe_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks
+ +[`undropped_manually_drops`]: https://rust-lang.github.io/rust-clippy/master/index.html#undropped_manually_drops
+ +[`unicode_not_nfc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unicode_not_nfc
+ +[`unimplemented`]: https://rust-lang.github.io/rust-clippy/master/index.html#unimplemented
+ +[`uninit_assumed_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_assumed_init
+ +[`uninit_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#uninit_vec
+ +[`unit_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_arg
+ +[`unit_cmp`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_cmp
+ +[`unit_hash`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_hash
+ +[`unit_return_expecting_ord`]: https://rust-lang.github.io/rust-clippy/master/index.html#unit_return_expecting_ord
+ +[`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
+ +[`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
+ +[`unnecessary_fold`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fold
+ +[`unnecessary_lazy_evaluations`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_lazy_evaluations
+ +[`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed
+ +[`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation
+ +[`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports
+ +[`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by
+ +[`unnecessary_to_owned`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_to_owned
+ +[`unnecessary_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_unwrap
+ +[`unnecessary_wraps`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_wraps
+ +[`unneeded_field_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_field_pattern
+ +[`unneeded_wildcard_pattern`]: https://rust-lang.github.io/rust-clippy/master/index.html#unneeded_wildcard_pattern
+ +[`unnested_or_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnested_or_patterns
+ +[`unreachable`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreachable
+ +[`unreadable_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
+ +[`unsafe_derive_deserialize`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_derive_deserialize
+ +[`unsafe_removed_from_name`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_removed_from_name
+ +[`unsafe_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsafe_vector_initialization
+ +[`unseparated_literal_suffix`]: https://rust-lang.github.io/rust-clippy/master/index.html#unseparated_literal_suffix
+ +[`unsound_collection_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#unsound_collection_transmute
+ +[`unstable_as_mut_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_mut_slice
+ +[`unstable_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#unstable_as_slice
+ +[`unused_async`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_async
+ +[`unused_collect`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_collect
+ +[`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
+ +[`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
+ +[`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
+ +[`unusual_byte_groupings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unusual_byte_groupings
+ +[`unwrap_in_result`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_in_result
+ +[`unwrap_or_else_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_or_else_default
+ +[`unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used
+ +[`upper_case_acronyms`]: https://rust-lang.github.io/rust-clippy/master/index.html#upper_case_acronyms
+ +[`use_debug`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_debug
+ +[`use_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#use_self
+ +[`used_underscore_binding`]: https://rust-lang.github.io/rust-clippy/master/index.html#used_underscore_binding
+ +[`useless_asref`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_asref
+ +[`useless_attribute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_attribute
+ +[`useless_conversion`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
+ +[`useless_format`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_format
+ +[`useless_let_if_seq`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_let_if_seq
+ +[`useless_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_transmute
+ +[`useless_vec`]: https://rust-lang.github.io/rust-clippy/master/index.html#useless_vec
+ +[`vec_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_box
+ +[`vec_init_then_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_init_then_push
+ +[`vec_resize_to_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#vec_resize_to_zero
+ +[`verbose_bit_mask`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_bit_mask
+ +[`verbose_file_reads`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_file_reads
+ +[`vtable_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#vtable_address_comparisons
+ +[`while_immutable_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_immutable_condition
+ +[`while_let_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_loop
+ +[`while_let_on_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_on_iterator
+ +[`wildcard_dependencies`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_dependencies
+ +[`wildcard_enum_match_arm`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_enum_match_arm
+ +[`wildcard_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports
+ +[`wildcard_in_or_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_in_or_patterns
+ +[`write_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#write_literal
+ +[`write_with_newline`]: https://rust-lang.github.io/rust-clippy/master/index.html#write_with_newline
+ +[`writeln_empty_string`]: https://rust-lang.github.io/rust-clippy/master/index.html#writeln_empty_string
+ +[`wrong_pub_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_pub_self_convention
+ +[`wrong_self_convention`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_self_convention
+ +[`wrong_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#wrong_transmute
+ +[`zero_divided_by_zero`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_divided_by_zero
+ +[`zero_prefixed_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_prefixed_literal
+ +[`zero_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_ptr
+ +[`zero_sized_map_values`]: https://rust-lang.github.io/rust-clippy/master/index.html#zero_sized_map_values
+ +[`zst_offset`]: https://rust-lang.github.io/rust-clippy/master/index.html#zst_offset
+ +<!-- end autogenerated links to lint list -->
diff --cc src/tools/clippy/COPYRIGHT

index 238c919b69d6b41522f43178381aba48be058e6e,0000000000000000000000000000000000000000..a6be75b5e310a29ce5af8231014a893aaf6b65e8

mode 100644,000000..100644
--- 1/src/tools/clippy/COPYRIGHT
--- /dev/null
+++ b/src/tools/clippy/COPYRIGHT
@@@ -1,7 -1,0 +1,7 @@@
- Copyright 2014-2021 The Rust Project Developers
++Copyright 2014-2022 The Rust Project Developers
+ +
+ +Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ +http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ +<LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ +option. All files in the project carrying such notice may not be
+ +copied, modified, or distributed except according to those terms.
diff --cc src/tools/clippy/LICENSE-APACHE

index 04169a42b8be8337d55f7732e7ff26fd9b7032b1,0000000000000000000000000000000000000000..0d62c37278e586a8196a77071d3b190d44655755

mode 100644,000000..100644
--- 1/src/tools/clippy/LICENSE-APACHE
--- /dev/null
+++ b/src/tools/clippy/LICENSE-APACHE
@@@ -1,201 -1,0 +1,201 @@@
- Copyright 2014-2021 The Rust Project Developers
+ +                              Apache License
+ +                        Version 2.0, January 2004
+ +                     http://www.apache.org/licenses/
+ +
+ +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+ +
+ +1. Definitions.
+ +
+ +   "License" shall mean the terms and conditions for use, reproduction,
+ +   and distribution as defined by Sections 1 through 9 of this document.
+ +
+ +   "Licensor" shall mean the copyright owner or entity authorized by
+ +   the copyright owner that is granting the License.
+ +
+ +   "Legal Entity" shall mean the union of the acting entity and all
+ +   other entities that control, are controlled by, or are under common
+ +   control with that entity. For the purposes of this definition,
+ +   "control" means (i) the power, direct or indirect, to cause the
+ +   direction or management of such entity, whether by contract or
+ +   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ +   outstanding shares, or (iii) beneficial ownership of such entity.
+ +
+ +   "You" (or "Your") shall mean an individual or Legal Entity
+ +   exercising permissions granted by this License.
+ +
+ +   "Source" form shall mean the preferred form for making modifications,
+ +   including but not limited to software source code, documentation
+ +   source, and configuration files.
+ +
+ +   "Object" form shall mean any form resulting from mechanical
+ +   transformation or translation of a Source form, including but
+ +   not limited to compiled object code, generated documentation,
+ +   and conversions to other media types.
+ +
+ +   "Work" shall mean the work of authorship, whether in Source or
+ +   Object form, made available under the License, as indicated by a
+ +   copyright notice that is included in or attached to the work
+ +   (an example is provided in the Appendix below).
+ +
+ +   "Derivative Works" shall mean any work, whether in Source or Object
+ +   form, that is based on (or derived from) the Work and for which the
+ +   editorial revisions, annotations, elaborations, or other modifications
+ +   represent, as a whole, an original work of authorship. For the purposes
+ +   of this License, Derivative Works shall not include works that remain
+ +   separable from, or merely link (or bind by name) to the interfaces of,
+ +   the Work and Derivative Works thereof.
+ +
+ +   "Contribution" shall mean any work of authorship, including
+ +   the original version of the Work and any modifications or additions
+ +   to that Work or Derivative Works thereof, that is intentionally
+ +   submitted to Licensor for inclusion in the Work by the copyright owner
+ +   or by an individual or Legal Entity authorized to submit on behalf of
+ +   the copyright owner. For the purposes of this definition, "submitted"
+ +   means any form of electronic, verbal, or written communication sent
+ +   to the Licensor or its representatives, including but not limited to
+ +   communication on electronic mailing lists, source code control systems,
+ +   and issue tracking systems that are managed by, or on behalf of, the
+ +   Licensor for the purpose of discussing and improving the Work, but
+ +   excluding communication that is conspicuously marked or otherwise
+ +   designated in writing by the copyright owner as "Not a Contribution."
+ +
+ +   "Contributor" shall mean Licensor and any individual or Legal Entity
+ +   on behalf of whom a Contribution has been received by Licensor and
+ +   subsequently incorporated within the Work.
+ +
+ +2. Grant of Copyright License. Subject to the terms and conditions of
+ +   this License, each Contributor hereby grants to You a perpetual,
+ +   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ +   copyright license to reproduce, prepare Derivative Works of,
+ +   publicly display, publicly perform, sublicense, and distribute the
+ +   Work and such Derivative Works in Source or Object form.
+ +
+ +3. Grant of Patent License. Subject to the terms and conditions of
+ +   this License, each Contributor hereby grants to You a perpetual,
+ +   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ +   (except as stated in this section) patent license to make, have made,
+ +   use, offer to sell, sell, import, and otherwise transfer the Work,
+ +   where such license applies only to those patent claims licensable
+ +   by such Contributor that are necessarily infringed by their
+ +   Contribution(s) alone or by combination of their Contribution(s)
+ +   with the Work to which such Contribution(s) was submitted. If You
+ +   institute patent litigation against any entity (including a
+ +   cross-claim or counterclaim in a lawsuit) alleging that the Work
+ +   or a Contribution incorporated within the Work constitutes direct
+ +   or contributory patent infringement, then any patent licenses
+ +   granted to You under this License for that Work shall terminate
+ +   as of the date such litigation is filed.
+ +
+ +4. Redistribution. You may reproduce and distribute copies of the
+ +   Work or Derivative Works thereof in any medium, with or without
+ +   modifications, and in Source or Object form, provided that You
+ +   meet the following conditions:
+ +
+ +   (a) You must give any other recipients of the Work or
+ +       Derivative Works a copy of this License; and
+ +
+ +   (b) You must cause any modified files to carry prominent notices
+ +       stating that You changed the files; and
+ +
+ +   (c) You must retain, in the Source form of any Derivative Works
+ +       that You distribute, all copyright, patent, trademark, and
+ +       attribution notices from the Source form of the Work,
+ +       excluding those notices that do not pertain to any part of
+ +       the Derivative Works; and
+ +
+ +   (d) If the Work includes a "NOTICE" text file as part of its
+ +       distribution, then any Derivative Works that You distribute must
+ +       include a readable copy of the attribution notices contained
+ +       within such NOTICE file, excluding those notices that do not
+ +       pertain to any part of the Derivative Works, in at least one
+ +       of the following places: within a NOTICE text file distributed
+ +       as part of the Derivative Works; within the Source form or
+ +       documentation, if provided along with the Derivative Works; or,
+ +       within a display generated by the Derivative Works, if and
+ +       wherever such third-party notices normally appear. The contents
+ +       of the NOTICE file are for informational purposes only and
+ +       do not modify the License. You may add Your own attribution
+ +       notices within Derivative Works that You distribute, alongside
+ +       or as an addendum to the NOTICE text from the Work, provided
+ +       that such additional attribution notices cannot be construed
+ +       as modifying the License.
+ +
+ +   You may add Your own copyright statement to Your modifications and
+ +   may provide additional or different license terms and conditions
+ +   for use, reproduction, or distribution of Your modifications, or
+ +   for any such Derivative Works as a whole, provided Your use,
+ +   reproduction, and distribution of the Work otherwise complies with
+ +   the conditions stated in this License.
+ +
+ +5. Submission of Contributions. Unless You explicitly state otherwise,
+ +   any Contribution intentionally submitted for inclusion in the Work
+ +   by You to the Licensor shall be under the terms and conditions of
+ +   this License, without any additional terms or conditions.
+ +   Notwithstanding the above, nothing herein shall supersede or modify
+ +   the terms of any separate license agreement you may have executed
+ +   with Licensor regarding such Contributions.
+ +
+ +6. Trademarks. This License does not grant permission to use the trade
+ +   names, trademarks, service marks, or product names of the Licensor,
+ +   except as required for reasonable and customary use in describing the
+ +   origin of the Work and reproducing the content of the NOTICE file.
+ +
+ +7. Disclaimer of Warranty. Unless required by applicable law or
+ +   agreed to in writing, Licensor provides the Work (and each
+ +   Contributor provides its Contributions) on an "AS IS" BASIS,
+ +   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ +   implied, including, without limitation, any warranties or conditions
+ +   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ +   PARTICULAR PURPOSE. You are solely responsible for determining the
+ +   appropriateness of using or redistributing the Work and assume any
+ +   risks associated with Your exercise of permissions under this License.
+ +
+ +8. Limitation of Liability. In no event and under no legal theory,
+ +   whether in tort (including negligence), contract, or otherwise,
+ +   unless required by applicable law (such as deliberate and grossly
+ +   negligent acts) or agreed to in writing, shall any Contributor be
+ +   liable to You for damages, including any direct, indirect, special,
+ +   incidental, or consequential damages of any character arising as a
+ +   result of this License or out of the use or inability to use the
+ +   Work (including but not limited to damages for loss of goodwill,
+ +   work stoppage, computer failure or malfunction, or any and all
+ +   other commercial damages or losses), even if such Contributor
+ +   has been advised of the possibility of such damages.
+ +
+ +9. Accepting Warranty or Additional Liability. While redistributing
+ +   the Work or Derivative Works thereof, You may choose to offer,
+ +   and charge a fee for, acceptance of support, warranty, indemnity,
+ +   or other liability obligations and/or rights consistent with this
+ +   License. However, in accepting such obligations, You may act only
+ +   on Your own behalf and on Your sole responsibility, not on behalf
+ +   of any other Contributor, and only if You agree to indemnify,
+ +   defend, and hold each Contributor harmless for any liability
+ +   incurred by, or claims asserted against, such Contributor by reason
+ +   of your accepting any such warranty or additional liability.
+ +
+ +END OF TERMS AND CONDITIONS
+ +
+ +APPENDIX: How to apply the Apache License to your work.
+ +
+ +   To apply the Apache License to your work, attach the following
+ +   boilerplate notice, with the fields enclosed by brackets "[]"
+ +   replaced with your own identifying information. (Don't include
+ +   the brackets!)  The text should be enclosed in the appropriate
+ +   comment syntax for the file format. We also recommend that a
+ +   file or class name and description of purpose be included on the
+ +   same "printed page" as the copyright notice for easier
+ +   identification within third-party archives.
+ +
++Copyright 2014-2022 The Rust Project Developers
+ +
+ +Licensed under the Apache License, Version 2.0 (the "License");
+ +you may not use this file except in compliance with the License.
+ +You may obtain a copy of the License at
+ +
+ +      http://www.apache.org/licenses/LICENSE-2.0
+ +
+ +Unless required by applicable law or agreed to in writing, software
+ +distributed under the License is distributed on an "AS IS" BASIS,
+ +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ +See the License for the specific language governing permissions and
+ +limitations under the License.
diff --cc src/tools/clippy/LICENSE-MIT

index 90a2d3950d19b07323204ca4b3a1dedcb608a89f,0000000000000000000000000000000000000000..b724b24aa8309d6f210dec5f9f91f7693481c786

mode 100644,000000..100644
--- 1/src/tools/clippy/LICENSE-MIT
--- /dev/null
+++ b/src/tools/clippy/LICENSE-MIT
@@@ -1,27 -1,0 +1,27 @@@
- Copyright (c) 2014-2021 The Rust Project Developers
+ +MIT License
+ +
++Copyright (c) 2014-2022 The Rust Project Developers
+ +
+ +Permission is hereby granted, free of charge, to any
+ +person obtaining a copy of this software and associated
+ +documentation files (the "Software"), to deal in the
+ +Software without restriction, including without
+ +limitation the rights to use, copy, modify, merge,
+ +publish, distribute, sublicense, and/or sell copies of
+ +the Software, and to permit persons to whom the Software
+ +is furnished to do so, subject to the following
+ +conditions:
+ +
+ +The above copyright notice and this permission notice
+ +shall be included in all copies or substantial portions
+ +of the Software.
+ +
+ +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+ +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+ +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+ +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+ +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ +DEALINGS IN THE SOFTWARE.
diff --cc src/tools/clippy/README.md

index f001a42d917d3134db7457aeb95713434bd3084c,0000000000000000000000000000000000000000..edbc626e354b5bbc11120a1ac539a92538455ba9

mode 100644,000000..100644
--- 1/src/tools/clippy/README.md
--- /dev/null
+++ b/src/tools/clippy/README.md
@@@ -1,247 -1,0 +1,247 @@@
- Copyright 2014-2021 The Rust Project Developers
+ +# Clippy
+ +
+ +[![Clippy Test](https://github.com/rust-lang/rust-clippy/workflows/Clippy%20Test/badge.svg?branch=auto&event=push)](https://github.com/rust-lang/rust-clippy/actions?query=workflow%3A%22Clippy+Test%22+event%3Apush+branch%3Aauto)
+ +[![License: MIT OR Apache-2.0](https://img.shields.io/crates/l/clippy.svg)](#license)
+ +
+ +A collection of lints to catch common mistakes and improve your [Rust](https://github.com/rust-lang/rust) code.
+ +
+ +[There are over 500 lints included in this crate!](https://rust-lang.github.io/rust-clippy/master/index.html)
+ +
+ +Lints are divided into categories, each with a default [lint level](https://doc.rust-lang.org/rustc/lints/levels.html).
+ +You can choose how much Clippy is supposed to ~~annoy~~ help you by changing the lint level by category.
+ +
+ +| Category              | Description                                                                         | Default level |
+ +| --------------------- | ----------------------------------------------------------------------------------- | ------------- |
+ +| `clippy::all`         | all lints that are on by default (correctness, suspicious, style, complexity, perf) | **warn/deny** |
+ +| `clippy::correctness` | code that is outright wrong or useless                                              | **deny**      |
+ +| `clippy::suspicious`  | code that is most likely wrong or useless                                           | **warn**      |
+ +| `clippy::style`       | code that should be written in a more idiomatic way                                 | **warn**      |
+ +| `clippy::complexity`  | code that does something simple but in a complex way                                | **warn**      |
+ +| `clippy::perf`        | code that can be written to run faster                                              | **warn**      |
+ +| `clippy::pedantic`    | lints which are rather strict or have occasional false positives                    | allow         |
+ +| `clippy::nursery`     | new lints that are still under development                                          | allow         |
+ +| `clippy::cargo`       | lints for the cargo manifest                                                        | allow         |
+ +
+ +More to come, please [file an issue](https://github.com/rust-lang/rust-clippy/issues) if you have ideas!
+ +
+ +The [lint list](https://rust-lang.github.io/rust-clippy/master/index.html) also contains "restriction lints", which are
+ +for things which are usually not considered "bad", but may be useful to turn on in specific cases. These should be used
+ +very selectively, if at all.
+ +
+ +Table of contents:
+ +
+ +*   [Usage instructions](#usage)
+ +*   [Configuration](#configuration)
+ +*   [Contributing](#contributing)
+ +*   [License](#license)
+ +
+ +## Usage
+ +
+ +Below are instructions on how to use Clippy as a cargo subcommand,
+ +in projects that do not use cargo, or in Travis CI.
+ +
+ +### As a cargo subcommand (`cargo clippy`)
+ +
+ +One way to use Clippy is by installing Clippy through rustup as a cargo
+ +subcommand.
+ +
+ +#### Step 1: Install Rustup
+ +
+ +You can install [Rustup](https://rustup.rs/) on supported platforms. This will help
+ +us install Clippy and its dependencies.
+ +
+ +If you already have Rustup installed, update to ensure you have the latest
+ +Rustup and compiler:
+ +
+ +```terminal
+ +rustup update
+ +```
+ +
+ +#### Step 2: Install Clippy
+ +
+ +Once you have rustup and the latest stable release (at least Rust 1.29) installed, run the following command:
+ +
+ +```terminal
+ +rustup component add clippy
+ +```
+ +If it says that it can't find the `clippy` component, please run `rustup self update`.
+ +
+ +#### Step 3: Run Clippy
+ +
+ +Now you can run Clippy by invoking the following command:
+ +
+ +```terminal
+ +cargo clippy
+ +```
+ +
+ +#### Automatically applying Clippy suggestions
+ +
+ +Clippy can automatically apply some lint suggestions, just like the compiler.
+ +
+ +```terminal
+ +cargo clippy --fix
+ +```
+ +
+ +#### Workspaces
+ +
+ +All the usual workspace options should work with Clippy. For example the following command
+ +will run Clippy on the `example` crate:
+ +
+ +```terminal
+ +cargo clippy -p example
+ +```
+ +
+ +As with `cargo check`, this includes dependencies that are members of the workspace, like path dependencies.
+ +If you want to run Clippy **only** on the given crate, use the `--no-deps` option like this:
+ +
+ +```terminal
+ +cargo clippy -p example -- --no-deps
+ +```
+ +
+ +### Using `clippy-driver`
+ +
+ +Clippy can also be used in projects that do not use cargo. To do so, run `clippy-driver`
+ +with the same arguments you use for `rustc`. For example:
+ +
+ +```terminal
+ +clippy-driver --edition 2018 -Cpanic=abort foo.rs
+ +```
+ +
+ +Note that `clippy-driver` is designed for running Clippy only and should not be used as a general
+ +replacement for `rustc`. `clippy-driver` may produce artifacts that are not optimized as expected,
+ +for example.
+ +
+ +### Travis CI
+ +
+ +You can add Clippy to Travis CI in the same way you use it locally:
+ +
+ +```yml
+ +language: rust
+ +rust:
+ +  - stable
+ +  - beta
+ +before_script:
+ +  - rustup component add clippy
+ +script:
+ +  - cargo clippy
+ +  # if you want the build job to fail when encountering warnings, use
+ +  - cargo clippy -- -D warnings
+ +  # in order to also check tests and non-default crate features, use
+ +  - cargo clippy --all-targets --all-features -- -D warnings
+ +  - cargo test
+ +  # etc.
+ +```
+ +
+ +Note that adding `-D warnings` will cause your build to fail if **any** warnings are found in your code.
+ +That includes warnings found by rustc (e.g. `dead_code`, etc.). If you want to avoid this and only cause
+ +an error for Clippy warnings, use `#![deny(clippy::all)]` in your code or `-D clippy::all` on the command
+ +line. (You can swap `clippy::all` with the specific lint category you are targeting.)
+ +
+ +## Configuration
+ +
+ +Some lints can be configured in a TOML file named `clippy.toml` or `.clippy.toml`. It contains a basic `variable =
+ +value` mapping e.g.
+ +
+ +```toml
+ +avoid-breaking-exported-api = false
+ +blacklisted-names = ["toto", "tata", "titi"]
+ +cognitive-complexity-threshold = 30
+ +```
+ +
+ +See the [list of lints](https://rust-lang.github.io/rust-clippy/master/index.html) for more information about which
+ +lints can be configured and the meaning of the variables.
+ +
+ +Note that configuration changes will not apply for code that has already been compiled and cached under `./target/`;
+ +for example, adding a new string to `doc-valid-idents` may still result in Clippy flagging that string. To be sure that
+ +any configuration changes are applied, you may want to run `cargo clean` and re-compile your crate from scratch.
+ +
+ +To deactivate the “for further information visit *lint-link*” message you can
+ +define the `CLIPPY_DISABLE_DOCS_LINKS` environment variable.
+ +
+ +### Allowing/denying lints
+ +
+ +You can add options to your code to `allow`/`warn`/`deny` Clippy lints:
+ +
+ +*   the whole set of `Warn` lints using the `clippy` lint group (`#![deny(clippy::all)]`).
+ +    Note that `rustc` has additional [lint groups](https://doc.rust-lang.org/rustc/lints/groups.html).
+ +
+ +*   all lints using both the `clippy` and `clippy::pedantic` lint groups (`#![deny(clippy::all)]`,
+ +    `#![deny(clippy::pedantic)]`). Note that `clippy::pedantic` contains some very aggressive
+ +    lints prone to false positives.
+ +
+ +*   only some lints (`#![deny(clippy::single_match, clippy::box_vec)]`, etc.)
+ +
+ +*   `allow`/`warn`/`deny` can be limited to a single function or module using `#[allow(...)]`, etc.
+ +
+ +Note: `allow` means to suppress the lint for your code. With `warn` the lint
+ +will only emit a warning, while with `deny` the lint will emit an error, when
+ +triggering for your code. An error causes clippy to exit with an error code, so
+ +is useful in scripts like CI/CD.
+ +
+ +If you do not want to include your lint levels in your code, you can globally
+ +enable/disable lints by passing extra flags to Clippy during the run:
+ +
+ +To allow `lint_name`, run
+ +
+ +```terminal
+ +cargo clippy -- -A clippy::lint_name
+ +```
+ +
+ +And to warn on `lint_name`, run
+ +
+ +```terminal
+ +cargo clippy -- -W clippy::lint_name
+ +```
+ +
+ +This also works with lint groups. For example, you
+ +can run Clippy with warnings for all lints enabled:
+ +```terminal
+ +cargo clippy -- -W clippy::pedantic
+ +```
+ +
+ +If you care only about a single lint, you can allow all others and then explicitly warn on
+ +the lint(s) you are interested in:
+ +```terminal
+ +cargo clippy -- -A clippy::all -W clippy::useless_format -W clippy::...
+ +```
+ +
+ +### Specifying the minimum supported Rust version
+ +
+ +Projects that intend to support old versions of Rust can disable lints pertaining to newer features by
+ +specifying the minimum supported Rust version (MSRV) in the clippy configuration file.
+ +
+ +```toml
+ +msrv = "1.30.0"
+ +```
+ +
+ +The MSRV can also be specified as an inner attribute, like below.
+ +
+ +```rust
+ +#![feature(custom_inner_attributes)]
+ +#![clippy::msrv = "1.30.0"]
+ +
+ +fn main() {
+ +  ...
+ +}
+ +```
+ +
+ +You can also omit the patch version when specifying the MSRV, so `msrv = 1.30`
+ +is equivalent to `msrv = 1.30.0`.
+ +
+ +Note: `custom_inner_attributes` is an unstable feature, so it has to be enabled explicitly.
+ +
+ +Lints that recognize this configuration option can be found [here](https://rust-lang.github.io/rust-clippy/master/index.html#msrv)
+ +
+ +## Contributing
+ +
+ +If you want to contribute to Clippy, you can find more information in [CONTRIBUTING.md](https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md).
+ +
+ +## License
+ +
++Copyright 2014-2022 The Rust Project Developers
+ +
+ +Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ +[https://www.apache.org/licenses/LICENSE-2.0](https://www.apache.org/licenses/LICENSE-2.0)> or the MIT license
+ +<LICENSE-MIT or [https://opensource.org/licenses/MIT](https://opensource.org/licenses/MIT)>, at your
+ +option. Files in the project may not be
+ +copied, modified, or distributed except according to those terms.
diff --cc src/tools/clippy/clippy_lints/src/bit_mask.rs

index 0977cf22b2c4e00343756b8ef381f66291ae24f5,0000000000000000000000000000000000000000..ca4af66cad16bd48d474490af53d9c06ffc82a87

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/bit_mask.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/bit_mask.rs
@@@ -1,335 -1,0 +1,335 @@@
-     /// |Comparison  |Bit Op|Example     |is always|Formula               |
-     /// |------------|------|------------|---------|----------------------|
-     /// |`==` or `!=`| `&`  |`x & 2 == 3`|`false`  |`c & m != c`          |
-     /// |`<`  or `>=`| `&`  |`x & 2 < 3` |`true`   |`m < c`               |
-     /// |`>`  or `<=`| `&`  |`x & 1 > 1` |`false`  |`m <= c`              |
-     /// |`==` or `!=`| `|`  |`x | 1 == 0`|`false`  |`c | m != c`          |
-     /// |`<`  or `>=`| `|`  |`x | 1 < 1` |`false`  |`m >= c`              |
-     /// |`<=` or `>` | `|`  |`x | 1 > 0` |`true`   |`m > c`               |
+ +use clippy_utils::consts::{constant, Constant};
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+ +use clippy_utils::sugg::Sugg;
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::LitKind;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{BinOpKind, Expr, ExprKind};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_session::{declare_tool_lint, impl_lint_pass};
+ +use rustc_span::source_map::Span;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for incompatible bit masks in comparisons.
+ +    ///
+ +    /// The formula for detecting if an expression of the type `_ <bit_op> m
+ +    /// <cmp_op> c` (where `<bit_op>` is one of {`&`, `|`} and `<cmp_op>` is one of
+ +    /// {`!=`, `>=`, `>`, `!=`, `>=`, `>`}) can be determined from the following
+ +    /// table:
+ +    ///
-     /// |Comparison| Bit Op  |Example    |equals |
-     /// |----------|---------|-----------|-------|
-     /// |`>` / `<=`|`|` / `^`|`x | 2 > 3`|`x > 3`|
-     /// |`<` / `>=`|`|` / `^`|`x ^ 1 < 4`|`x < 4`|
++    /// |Comparison  |Bit Op|Example      |is always|Formula               |
++    /// |------------|------|-------------|---------|----------------------|
++    /// |`==` or `!=`| `&`  |`x & 2 == 3` |`false`  |`c & m != c`          |
++    /// |`<`  or `>=`| `&`  |`x & 2 < 3`  |`true`   |`m < c`               |
++    /// |`>`  or `<=`| `&`  |`x & 1 > 1`  |`false`  |`m <= c`              |
++    /// |`==` or `!=`| `\|` |`x \| 1 == 0`|`false`  |`c \| m != c`         |
++    /// |`<`  or `>=`| `\|` |`x \| 1 < 1` |`false`  |`m >= c`              |
++    /// |`<=` or `>` | `\|` |`x \| 1 > 0` |`true`   |`m > c`               |
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// If the bits that the comparison cares about are always
+ +    /// set to zero or one by the bit mask, the comparison is constant `true` or
+ +    /// `false` (depending on mask, compared value, and operators).
+ +    ///
+ +    /// So the code is actively misleading, and the only reason someone would write
+ +    /// this intentionally is to win an underhanded Rust contest or create a
+ +    /// test-case for this lint.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = 1;
+ +    /// if (x & 1 == 2) { }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub BAD_BIT_MASK,
+ +    correctness,
+ +    "expressions of the form `_ & mask == select` that will only ever return `true` or `false`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for bit masks in comparisons which can be removed
+ +    /// without changing the outcome. The basic structure can be seen in the
+ +    /// following table:
+ +    ///
++    /// |Comparison| Bit Op   |Example     |equals |
++    /// |----------|----------|------------|-------|
++    /// |`>` / `<=`|`\|` / `^`|`x \| 2 > 3`|`x > 3`|
++    /// |`<` / `>=`|`\|` / `^`|`x ^ 1 < 4` |`x < 4`|
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Not equally evil as [`bad_bit_mask`](#bad_bit_mask),
+ +    /// but still a bit misleading, because the bit mask is ineffective.
+ +    ///
+ +    /// ### Known problems
+ +    /// False negatives: This lint will only match instances
+ +    /// where we have figured out the math (which is for a power-of-two compared
+ +    /// value). This means things like `x | 1 >= 7` (which would be better written
+ +    /// as `x >= 6`) will not be reported (but bit masks like this are fairly
+ +    /// uncommon).
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = 1;
+ +    /// if (x | 1 > 3) {  }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub INEFFECTIVE_BIT_MASK,
+ +    correctness,
+ +    "expressions where a bit mask will be rendered useless by a comparison, e.g., `(x | 1) > 2`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for bit masks that can be replaced by a call
+ +    /// to `trailing_zeros`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `x.trailing_zeros() > 4` is much clearer than `x & 15
+ +    /// == 0`
+ +    ///
+ +    /// ### Known problems
+ +    /// llvm generates better code for `x & 15 == 0` on x86
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = 1;
+ +    /// if x & 0b1111 == 0 { }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub VERBOSE_BIT_MASK,
+ +    pedantic,
+ +    "expressions where a bit mask is less readable than the corresponding method call"
+ +}
+ +
+ +#[derive(Copy, Clone)]
+ +pub struct BitMask {
+ +    verbose_bit_mask_threshold: u64,
+ +}
+ +
+ +impl BitMask {
+ +    #[must_use]
+ +    pub fn new(verbose_bit_mask_threshold: u64) -> Self {
+ +        Self {
+ +            verbose_bit_mask_threshold,
+ +        }
+ +    }
+ +}
+ +
+ +impl_lint_pass!(BitMask => [BAD_BIT_MASK, INEFFECTIVE_BIT_MASK, VERBOSE_BIT_MASK]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for BitMask {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+ +        if let ExprKind::Binary(cmp, left, right) = &e.kind {
+ +            if cmp.node.is_comparison() {
+ +                if let Some(cmp_opt) = fetch_int_literal(cx, right) {
+ +                    check_compare(cx, left, cmp.node, cmp_opt, e.span);
+ +                } else if let Some(cmp_val) = fetch_int_literal(cx, left) {
+ +                    check_compare(cx, right, invert_cmp(cmp.node), cmp_val, e.span);
+ +                }
+ +            }
+ +        }
+ +        if_chain! {
+ +            if let ExprKind::Binary(op, left, right) = &e.kind;
+ +            if BinOpKind::Eq == op.node;
+ +            if let ExprKind::Binary(op1, left1, right1) = &left.kind;
+ +            if BinOpKind::BitAnd == op1.node;
+ +            if let ExprKind::Lit(lit) = &right1.kind;
+ +            if let LitKind::Int(n, _) = lit.node;
+ +            if let ExprKind::Lit(lit1) = &right.kind;
+ +            if let LitKind::Int(0, _) = lit1.node;
+ +            if n.leading_zeros() == n.count_zeros();
+ +            if n > u128::from(self.verbose_bit_mask_threshold);
+ +            then {
+ +                span_lint_and_then(cx,
+ +                                   VERBOSE_BIT_MASK,
+ +                                   e.span,
+ +                                   "bit mask could be simplified with a call to `trailing_zeros`",
+ +                                   |diag| {
+ +                    let sugg = Sugg::hir(cx, left1, "...").maybe_par();
+ +                    diag.span_suggestion(
+ +                        e.span,
+ +                        "try",
+ +                        format!("{}.trailing_zeros() >= {}", sugg, n.count_ones()),
+ +                        Applicability::MaybeIncorrect,
+ +                    );
+ +                });
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +#[must_use]
+ +fn invert_cmp(cmp: BinOpKind) -> BinOpKind {
+ +    match cmp {
+ +        BinOpKind::Eq => BinOpKind::Eq,
+ +        BinOpKind::Ne => BinOpKind::Ne,
+ +        BinOpKind::Lt => BinOpKind::Gt,
+ +        BinOpKind::Gt => BinOpKind::Lt,
+ +        BinOpKind::Le => BinOpKind::Ge,
+ +        BinOpKind::Ge => BinOpKind::Le,
+ +        _ => BinOpKind::Or, // Dummy
+ +    }
+ +}
+ +
+ +fn check_compare(cx: &LateContext<'_>, bit_op: &Expr<'_>, cmp_op: BinOpKind, cmp_value: u128, span: Span) {
+ +    if let ExprKind::Binary(op, left, right) = &bit_op.kind {
+ +        if op.node != BinOpKind::BitAnd && op.node != BinOpKind::BitOr {
+ +            return;
+ +        }
+ +        fetch_int_literal(cx, right)
+ +            .or_else(|| fetch_int_literal(cx, left))
+ +            .map_or((), |mask| check_bit_mask(cx, op.node, cmp_op, mask, cmp_value, span));
+ +    }
+ +}
+ +
+ +#[allow(clippy::too_many_lines)]
+ +fn check_bit_mask(
+ +    cx: &LateContext<'_>,
+ +    bit_op: BinOpKind,
+ +    cmp_op: BinOpKind,
+ +    mask_value: u128,
+ +    cmp_value: u128,
+ +    span: Span,
+ +) {
+ +    match cmp_op {
+ +        BinOpKind::Eq | BinOpKind::Ne => match bit_op {
+ +            BinOpKind::BitAnd => {
+ +                if mask_value & cmp_value != cmp_value {
+ +                    if cmp_value != 0 {
+ +                        span_lint(
+ +                            cx,
+ +                            BAD_BIT_MASK,
+ +                            span,
+ +                            &format!(
+ +                                "incompatible bit mask: `_ & {}` can never be equal to `{}`",
+ +                                mask_value, cmp_value
+ +                            ),
+ +                        );
+ +                    }
+ +                } else if mask_value == 0 {
+ +                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
+ +                }
+ +            },
+ +            BinOpKind::BitOr => {
+ +                if mask_value | cmp_value != cmp_value {
+ +                    span_lint(
+ +                        cx,
+ +                        BAD_BIT_MASK,
+ +                        span,
+ +                        &format!(
+ +                            "incompatible bit mask: `_ | {}` can never be equal to `{}`",
+ +                            mask_value, cmp_value
+ +                        ),
+ +                    );
+ +                }
+ +            },
+ +            _ => (),
+ +        },
+ +        BinOpKind::Lt | BinOpKind::Ge => match bit_op {
+ +            BinOpKind::BitAnd => {
+ +                if mask_value < cmp_value {
+ +                    span_lint(
+ +                        cx,
+ +                        BAD_BIT_MASK,
+ +                        span,
+ +                        &format!(
+ +                            "incompatible bit mask: `_ & {}` will always be lower than `{}`",
+ +                            mask_value, cmp_value
+ +                        ),
+ +                    );
+ +                } else if mask_value == 0 {
+ +                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
+ +                }
+ +            },
+ +            BinOpKind::BitOr => {
+ +                if mask_value >= cmp_value {
+ +                    span_lint(
+ +                        cx,
+ +                        BAD_BIT_MASK,
+ +                        span,
+ +                        &format!(
+ +                            "incompatible bit mask: `_ | {}` will never be lower than `{}`",
+ +                            mask_value, cmp_value
+ +                        ),
+ +                    );
+ +                } else {
+ +                    check_ineffective_lt(cx, span, mask_value, cmp_value, "|");
+ +                }
+ +            },
+ +            BinOpKind::BitXor => check_ineffective_lt(cx, span, mask_value, cmp_value, "^"),
+ +            _ => (),
+ +        },
+ +        BinOpKind::Le | BinOpKind::Gt => match bit_op {
+ +            BinOpKind::BitAnd => {
+ +                if mask_value <= cmp_value {
+ +                    span_lint(
+ +                        cx,
+ +                        BAD_BIT_MASK,
+ +                        span,
+ +                        &format!(
+ +                            "incompatible bit mask: `_ & {}` will never be higher than `{}`",
+ +                            mask_value, cmp_value
+ +                        ),
+ +                    );
+ +                } else if mask_value == 0 {
+ +                    span_lint(cx, BAD_BIT_MASK, span, "&-masking with zero");
+ +                }
+ +            },
+ +            BinOpKind::BitOr => {
+ +                if mask_value > cmp_value {
+ +                    span_lint(
+ +                        cx,
+ +                        BAD_BIT_MASK,
+ +                        span,
+ +                        &format!(
+ +                            "incompatible bit mask: `_ | {}` will always be higher than `{}`",
+ +                            mask_value, cmp_value
+ +                        ),
+ +                    );
+ +                } else {
+ +                    check_ineffective_gt(cx, span, mask_value, cmp_value, "|");
+ +                }
+ +            },
+ +            BinOpKind::BitXor => check_ineffective_gt(cx, span, mask_value, cmp_value, "^"),
+ +            _ => (),
+ +        },
+ +        _ => (),
+ +    }
+ +}
+ +
+ +fn check_ineffective_lt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op: &str) {
+ +    if c.is_power_of_two() && m < c {
+ +        span_lint(
+ +            cx,
+ +            INEFFECTIVE_BIT_MASK,
+ +            span,
+ +            &format!(
+ +                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
+ +                op, m, c
+ +            ),
+ +        );
+ +    }
+ +}
+ +
+ +fn check_ineffective_gt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op: &str) {
+ +    if (c + 1).is_power_of_two() && m <= c {
+ +        span_lint(
+ +            cx,
+ +            INEFFECTIVE_BIT_MASK,
+ +            span,
+ +            &format!(
+ +                "ineffective bit mask: `x {} {}` compared to `{}`, is the same as x compared directly",
+ +                op, m, c
+ +            ),
+ +        );
+ +    }
+ +}
+ +
+ +fn fetch_int_literal(cx: &LateContext<'_>, lit: &Expr<'_>) -> Option<u128> {
+ +    match constant(cx, cx.typeck_results(), lit)?.0 {
+ +        Constant::Int(n) => Some(n),
+ +        _ => None,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/copies.rs

index 73ce656ad151437d490bf435e525c9d8c1797258,0000000000000000000000000000000000000000..f44d370a8fd031e51073ef5f675879cb67da6cb6

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/copies.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/copies.rs
@@@ -1,646 -1,0 +1,651 @@@
-                 lint_same_then_else(cx, &blocks, conds.len() == blocks.len(), expr);
+ +use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
+ +use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
+ +use clippy_utils::{
+ +    both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, is_else_clause, is_lint_allowed,
+ +    search_same, ContainsName, SpanlessEq, SpanlessHash,
+ +};
+ +use if_chain::if_chain;
+ +use rustc_data_structures::fx::FxHashSet;
+ +use rustc_errors::{Applicability, DiagnosticBuilder};
+ +use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+ +use rustc_hir::{Block, Expr, ExprKind, HirId};
+ +use rustc_lint::{LateContext, LateLintPass, LintContext};
+ +use rustc_middle::hir::map::Map;
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::{source_map::Span, symbol::Symbol, BytePos};
+ +use std::borrow::Cow;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for consecutive `if`s with the same condition.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is probably a copy & paste error.
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// if a == b {
+ +    ///     …
+ +    /// } else if a == b {
+ +    ///     …
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// Note that this lint ignores all conditions with a function call as it could
+ +    /// have side effects:
+ +    ///
+ +    /// ```ignore
+ +    /// if foo() {
+ +    ///     …
+ +    /// } else if foo() { // not linted
+ +    ///     …
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub IFS_SAME_COND,
+ +    correctness,
+ +    "consecutive `if`s with the same condition"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for consecutive `if`s with the same function call.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is probably a copy & paste error.
+ +    /// Despite the fact that function can have side effects and `if` works as
+ +    /// intended, such an approach is implicit and can be considered a "code smell".
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// if foo() == bar {
+ +    ///     …
+ +    /// } else if foo() == bar {
+ +    ///     …
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// This probably should be:
+ +    /// ```ignore
+ +    /// if foo() == bar {
+ +    ///     …
+ +    /// } else if foo() == baz {
+ +    ///     …
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// or if the original code was not a typo and called function mutates a state,
+ +    /// consider move the mutation out of the `if` condition to avoid similarity to
+ +    /// a copy & paste error:
+ +    ///
+ +    /// ```ignore
+ +    /// let first = foo();
+ +    /// if first == bar {
+ +    ///     …
+ +    /// } else {
+ +    ///     let second = foo();
+ +    ///     if second == bar {
+ +    ///     …
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "1.41.0"]
+ +    pub SAME_FUNCTIONS_IN_IF_CONDITION,
+ +    pedantic,
+ +    "consecutive `if`s with the same function call"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `if/else` with the same body as the *then* part
+ +    /// and the *else* part.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is probably a copy & paste error.
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// let foo = if … {
+ +    ///     42
+ +    /// } else {
+ +    ///     42
+ +    /// };
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub IF_SAME_THEN_ELSE,
+ +    correctness,
+ +    "`if` with the same `then` and `else` blocks"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks if the `if` and `else` block contain shared code that can be
+ +    /// moved out of the blocks.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Duplicate code is less maintainable.
+ +    ///
+ +    /// ### Known problems
+ +    /// * The lint doesn't check if the moved expressions modify values that are beeing used in
+ +    ///   the if condition. The suggestion can in that case modify the behavior of the program.
+ +    ///   See [rust-clippy#7452](https://github.com/rust-lang/rust-clippy/issues/7452)
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// let foo = if … {
+ +    ///     println!("Hello World");
+ +    ///     13
+ +    /// } else {
+ +    ///     println!("Hello World");
+ +    ///     42
+ +    /// };
+ +    /// ```
+ +    ///
+ +    /// Could be written as:
+ +    /// ```ignore
+ +    /// println!("Hello World");
+ +    /// let foo = if … {
+ +    ///     13
+ +    /// } else {
+ +    ///     42
+ +    /// };
+ +    /// ```
+ +    #[clippy::version = "1.53.0"]
+ +    pub BRANCHES_SHARING_CODE,
+ +    nursery,
+ +    "`if` statement with shared code in all blocks"
+ +}
+ +
+ +declare_lint_pass!(CopyAndPaste => [
+ +    IFS_SAME_COND,
+ +    SAME_FUNCTIONS_IN_IF_CONDITION,
+ +    IF_SAME_THEN_ELSE,
+ +    BRANCHES_SHARING_CODE
+ +]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        if !expr.span.from_expansion() {
+ +            if let ExprKind::If(_, _, _) = expr.kind {
+ +                // skip ifs directly in else, it will be checked in the parent if
+ +                if let Some(&Expr {
+ +                    kind: ExprKind::If(_, _, Some(else_expr)),
+ +                    ..
+ +                }) = get_parent_expr(cx, expr)
+ +                {
+ +                    if else_expr.hir_id == expr.hir_id {
+ +                        return;
+ +                    }
+ +                }
+ +
+ +                let (conds, blocks) = if_sequence(expr);
+ +                // Conditions
+ +                lint_same_cond(cx, &conds);
+ +                lint_same_fns_in_if_cond(cx, &conds);
+ +                // Block duplication
-     let (start_eq, mut end_eq, expr_eq) = if let Some(block_eq) = scan_block_for_eq(cx, blocks) {
++                lint_same_then_else(cx, &conds, &blocks, conds.len() == blocks.len(), expr);
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +/// Implementation of `BRANCHES_SHARING_CODE` and `IF_SAME_THEN_ELSE` if the blocks are equal.
+ +fn lint_same_then_else<'tcx>(
+ +    cx: &LateContext<'tcx>,
++    conds: &[&'tcx Expr<'_>],
+ +    blocks: &[&Block<'tcx>],
+ +    has_conditional_else: bool,
+ +    expr: &'tcx Expr<'_>,
+ +) {
+ +    // We only lint ifs with multiple blocks
+ +    if blocks.len() < 2 || is_else_clause(cx.tcx, expr) {
+ +        return;
+ +    }
+ +
+ +    // Check if each block has shared code
+ +    let has_expr = blocks[0].expr.is_some();
+ +
- fn scan_block_for_eq(cx: &LateContext<'_>, blocks: &[&Block<'_>]) -> Option<BlockEqual> {
++    let (start_eq, mut end_eq, expr_eq) = if let Some(block_eq) = scan_block_for_eq(cx, conds, blocks) {
+ +        (block_eq.start_eq, block_eq.end_eq, block_eq.expr_eq)
+ +    } else {
+ +        return;
+ +    };
+ +
+ +    // BRANCHES_SHARING_CODE prerequisites
+ +    if has_conditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
+ +        return;
+ +    }
+ +
+ +    // Only the start is the same
+ +    if start_eq != 0 && end_eq == 0 && (!has_expr || !expr_eq) {
+ +        let block = blocks[0];
+ +        let start_stmts = block.stmts.split_at(start_eq).0;
+ +
+ +        let mut start_walker = UsedValueFinderVisitor::new(cx);
+ +        for stmt in start_stmts {
+ +            intravisit::walk_stmt(&mut start_walker, stmt);
+ +        }
+ +
+ +        emit_branches_sharing_code_lint(
+ +            cx,
+ +            start_eq,
+ +            0,
+ +            false,
+ +            check_for_warn_of_moved_symbol(cx, &start_walker.def_symbols, expr),
+ +            blocks,
+ +            expr,
+ +        );
+ +    } else if end_eq != 0 || (has_expr && expr_eq) {
+ +        let block = blocks[blocks.len() - 1];
+ +        let (start_stmts, block_stmts) = block.stmts.split_at(start_eq);
+ +        let (block_stmts, end_stmts) = block_stmts.split_at(block_stmts.len() - end_eq);
+ +
+ +        // Scan start
+ +        let mut start_walker = UsedValueFinderVisitor::new(cx);
+ +        for stmt in start_stmts {
+ +            intravisit::walk_stmt(&mut start_walker, stmt);
+ +        }
+ +        let mut moved_syms = start_walker.def_symbols;
+ +
+ +        // Scan block
+ +        let mut block_walker = UsedValueFinderVisitor::new(cx);
+ +        for stmt in block_stmts {
+ +            intravisit::walk_stmt(&mut block_walker, stmt);
+ +        }
+ +        let mut block_defs = block_walker.defs;
+ +
+ +        // Scan moved stmts
+ +        let mut moved_start: Option<usize> = None;
+ +        let mut end_walker = UsedValueFinderVisitor::new(cx);
+ +        for (index, stmt) in end_stmts.iter().enumerate() {
+ +            intravisit::walk_stmt(&mut end_walker, stmt);
+ +
+ +            for value in &end_walker.uses {
+ +                // Well we can't move this and all prev statements. So reset
+ +                if block_defs.contains(value) {
+ +                    moved_start = Some(index + 1);
+ +                    end_walker.defs.drain().for_each(|x| {
+ +                        block_defs.insert(x);
+ +                    });
+ +
+ +                    end_walker.def_symbols.clear();
+ +                }
+ +            }
+ +
+ +            end_walker.uses.clear();
+ +        }
+ +
+ +        if let Some(moved_start) = moved_start {
+ +            end_eq -= moved_start;
+ +        }
+ +
+ +        let end_linable = block.expr.map_or_else(
+ +            || end_eq != 0,
+ +            |expr| {
+ +                intravisit::walk_expr(&mut end_walker, expr);
+ +                end_walker.uses.iter().any(|x| !block_defs.contains(x))
+ +            },
+ +        );
+ +
+ +        if end_linable {
+ +            end_walker.def_symbols.drain().for_each(|x| {
+ +                moved_syms.insert(x);
+ +            });
+ +        }
+ +
+ +        emit_branches_sharing_code_lint(
+ +            cx,
+ +            start_eq,
+ +            end_eq,
+ +            end_linable,
+ +            check_for_warn_of_moved_symbol(cx, &moved_syms, expr),
+ +            blocks,
+ +            expr,
+ +        );
+ +    }
+ +}
+ +
+ +struct BlockEqual {
+ +    /// The amount statements that are equal from the start
+ +    start_eq: usize,
+ +    /// The amount statements that are equal from the end
+ +    end_eq: usize,
+ +    ///  An indication if the block expressions are the same. This will also be true if both are
+ +    /// `None`
+ +    expr_eq: bool,
+ +}
+ +
+ +/// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `None` to
+ +/// abort any further processing and avoid duplicate lint triggers.
-     let mut iter = blocks.windows(2);
-     while let Some(&[win0, win1]) = iter.next() {
-         let l_stmts = win0.stmts;
-         let r_stmts = win1.stmts;
++fn scan_block_for_eq(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &[&Block<'_>]) -> Option<BlockEqual> {
+ +    let mut start_eq = usize::MAX;
+ +    let mut end_eq = usize::MAX;
+ +    let mut expr_eq = true;
-         let block_expr_eq = both(&win0.expr, &win1.expr, |l, r| evaluator.eq_expr(l, r));
++    let mut iter = blocks.windows(2).enumerate();
++    while let Some((i, &[block0, block1])) = iter.next() {
++        let l_stmts = block0.stmts;
++        let r_stmts = block1.stmts;
+ +
+ +        // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
+ +        // The comparison therefore needs to be done in a way that builds the correct context.
+ +        let mut evaluator = SpanlessEq::new(cx);
+ +        let mut evaluator = evaluator.inter_expr();
+ +
+ +        let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
+ +
+ +        let current_end_eq = {
+ +            // We skip the middle statements which can't be equal
+ +            let end_comparison_count = l_stmts.len().min(r_stmts.len()) - current_start_eq;
+ +            let it1 = l_stmts.iter().skip(l_stmts.len() - end_comparison_count);
+ +            let it2 = r_stmts.iter().skip(r_stmts.len() - end_comparison_count);
+ +            it1.zip(it2)
+ +                .fold(0, |acc, (l, r)| if evaluator.eq_stmt(l, r) { acc + 1 } else { 0 })
+ +        };
-             if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win0.hir_id);
-             if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win1.hir_id);
++        let block_expr_eq = both(&block0.expr, &block1.expr, |l, r| evaluator.eq_expr(l, r));
+ +
+ +        // IF_SAME_THEN_ELSE
+ +        if_chain! {
+ +            if block_expr_eq;
+ +            if l_stmts.len() == r_stmts.len();
+ +            if l_stmts.len() == current_start_eq;
-                     win0.span,
++            // `conds` may have one last item than `blocks`.
++            // Any `i` from `blocks.windows(2)` will exist in `conds`, but `i+1` may not exist on the last iteration.
++            if !matches!(conds[i].kind, ExprKind::Let(..));
++            if !matches!(conds.get(i + 1).map(|e| &e.kind), Some(ExprKind::Let(..)));
++            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, block0.hir_id);
++            if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, block1.hir_id);
+ +            then {
+ +                span_lint_and_note(
+ +                    cx,
+ +                    IF_SAME_THEN_ELSE,
-                     Some(win1.span),
++                    block0.span,
+ +                    "this `if` has identical blocks",
++                    Some(block1.span),
+ +                    "same as this",
+ +                );
+ +
+ +                return None;
+ +            }
+ +        }
+ +
+ +        start_eq = start_eq.min(current_start_eq);
+ +        end_eq = end_eq.min(current_end_eq);
+ +        expr_eq &= block_expr_eq;
+ +    }
+ +
+ +    if !expr_eq {
+ +        end_eq = 0;
+ +    }
+ +
+ +    // Check if the regions are overlapping. Set `end_eq` to prevent the overlap
+ +    let min_block_size = blocks.iter().map(|x| x.stmts.len()).min().unwrap();
+ +    if (start_eq + end_eq) > min_block_size {
+ +        end_eq = min_block_size - start_eq;
+ +    }
+ +
+ +    Some(BlockEqual {
+ +        start_eq,
+ +        end_eq,
+ +        expr_eq,
+ +    })
+ +}
+ +
+ +fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &FxHashSet<Symbol>, if_expr: &Expr<'_>) -> bool {
+ +    get_enclosing_block(cx, if_expr.hir_id).map_or(false, |block| {
+ +        let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
+ +
+ +        symbols
+ +            .iter()
+ +            .filter(|sym| !sym.as_str().starts_with('_'))
+ +            .any(move |sym| {
+ +                let mut walker = ContainsName {
+ +                    name: *sym,
+ +                    result: false,
+ +                };
+ +
+ +                // Scan block
+ +                block
+ +                    .stmts
+ +                    .iter()
+ +                    .filter(|stmt| !ignore_span.overlaps(stmt.span))
+ +                    .for_each(|stmt| intravisit::walk_stmt(&mut walker, stmt));
+ +
+ +                if let Some(expr) = block.expr {
+ +                    intravisit::walk_expr(&mut walker, expr);
+ +                }
+ +
+ +                walker.result
+ +            })
+ +    })
+ +}
+ +
+ +fn emit_branches_sharing_code_lint(
+ +    cx: &LateContext<'_>,
+ +    start_stmts: usize,
+ +    end_stmts: usize,
+ +    lint_end: bool,
+ +    warn_about_moved_symbol: bool,
+ +    blocks: &[&Block<'_>],
+ +    if_expr: &Expr<'_>,
+ +) {
+ +    if start_stmts == 0 && !lint_end {
+ +        return;
+ +    }
+ +
+ +    // (help, span, suggestion)
+ +    let mut suggestions: Vec<(&str, Span, String)> = vec![];
+ +    let mut add_expr_note = false;
+ +
+ +    // Construct suggestions
+ +    let sm = cx.sess().source_map();
+ +    if start_stmts > 0 {
+ +        let block = blocks[0];
+ +        let span_start = first_line_of_span(cx, if_expr.span).shrink_to_lo();
+ +        let span_end = sm.stmt_span(block.stmts[start_stmts - 1].span, block.span);
+ +
+ +        let cond_span = first_line_of_span(cx, if_expr.span).until(block.span);
+ +        let cond_snippet = reindent_multiline(snippet(cx, cond_span, "_"), false, None);
+ +        let cond_indent = indent_of(cx, cond_span);
+ +        let moved_span = block.stmts[0].span.source_callsite().to(span_end);
+ +        let moved_snippet = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
+ +        let suggestion = moved_snippet.to_string() + "\n" + &cond_snippet + "{";
+ +        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, cond_indent);
+ +
+ +        let span = span_start.to(span_end);
+ +        suggestions.push(("start", span, suggestion.to_string()));
+ +    }
+ +
+ +    if lint_end {
+ +        let block = blocks[blocks.len() - 1];
+ +        let span_end = block.span.shrink_to_hi();
+ +
+ +        let moved_start = if end_stmts == 0 && block.expr.is_some() {
+ +            block.expr.unwrap().span.source_callsite()
+ +        } else {
+ +            sm.stmt_span(block.stmts[block.stmts.len() - end_stmts].span, block.span)
+ +        };
+ +        let moved_end = block.expr.map_or_else(
+ +            || sm.stmt_span(block.stmts[block.stmts.len() - 1].span, block.span),
+ +            |expr| expr.span.source_callsite(),
+ +        );
+ +
+ +        let moved_span = moved_start.to(moved_end);
+ +        let moved_snipped = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
+ +        let indent = indent_of(cx, if_expr.span.shrink_to_hi());
+ +        let suggestion = "}\n".to_string() + &moved_snipped;
+ +        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, indent);
+ +
+ +        let mut span = moved_start.to(span_end);
+ +        // Improve formatting if the inner block has indention (i.e. normal Rust formatting)
+ +        let test_span = Span::new(span.lo() - BytePos(4), span.lo(), span.ctxt(), span.parent());
+ +        if snippet_opt(cx, test_span)
+ +            .map(|snip| snip == "    ")
+ +            .unwrap_or_default()
+ +        {
+ +            span = span.with_lo(test_span.lo());
+ +        }
+ +
+ +        suggestions.push(("end", span, suggestion.to_string()));
+ +        add_expr_note = !cx.typeck_results().expr_ty(if_expr).is_unit();
+ +    }
+ +
+ +    let add_optional_msgs = |diag: &mut DiagnosticBuilder<'_>| {
+ +        if add_expr_note {
+ +            diag.note("The end suggestion probably needs some adjustments to use the expression result correctly");
+ +        }
+ +
+ +        if warn_about_moved_symbol {
+ +            diag.warn("Some moved values might need to be renamed to avoid wrong references");
+ +        }
+ +    };
+ +
+ +    // Emit lint
+ +    if suggestions.len() == 1 {
+ +        let (place_str, span, sugg) = suggestions.pop().unwrap();
+ +        let msg = format!("all if blocks contain the same code at the {}", place_str);
+ +        let help = format!("consider moving the {} statements out like this", place_str);
+ +        span_lint_and_then(cx, BRANCHES_SHARING_CODE, span, msg.as_str(), |diag| {
+ +            diag.span_suggestion(span, help.as_str(), sugg, Applicability::Unspecified);
+ +
+ +            add_optional_msgs(diag);
+ +        });
+ +    } else if suggestions.len() == 2 {
+ +        let (_, end_span, end_sugg) = suggestions.pop().unwrap();
+ +        let (_, start_span, start_sugg) = suggestions.pop().unwrap();
+ +        span_lint_and_then(
+ +            cx,
+ +            BRANCHES_SHARING_CODE,
+ +            start_span,
+ +            "all if blocks contain the same code at the start and the end. Here at the start",
+ +            move |diag| {
+ +                diag.span_note(end_span, "and here at the end");
+ +
+ +                diag.span_suggestion(
+ +                    start_span,
+ +                    "consider moving the start statements out like this",
+ +                    start_sugg,
+ +                    Applicability::Unspecified,
+ +                );
+ +
+ +                diag.span_suggestion(
+ +                    end_span,
+ +                    "and consider moving the end statements out like this",
+ +                    end_sugg,
+ +                    Applicability::Unspecified,
+ +                );
+ +
+ +                add_optional_msgs(diag);
+ +            },
+ +        );
+ +    }
+ +}
+ +
+ +/// This visitor collects `HirId`s and Symbols of defined symbols and `HirId`s of used values.
+ +struct UsedValueFinderVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,
+ +
+ +    /// The `HirId`s of defined values in the scanned statements
+ +    defs: FxHashSet<HirId>,
+ +
+ +    /// The Symbols of the defined symbols in the scanned statements
+ +    def_symbols: FxHashSet<Symbol>,
+ +
+ +    /// The `HirId`s of the used values
+ +    uses: FxHashSet<HirId>,
+ +}
+ +
+ +impl<'a, 'tcx> UsedValueFinderVisitor<'a, 'tcx> {
+ +    fn new(cx: &'a LateContext<'tcx>) -> Self {
+ +        UsedValueFinderVisitor {
+ +            cx,
+ +            defs: FxHashSet::default(),
+ +            def_symbols: FxHashSet::default(),
+ +            uses: FxHashSet::default(),
+ +        }
+ +    }
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for UsedValueFinderVisitor<'a, 'tcx> {
+ +    type Map = Map<'tcx>;
+ +
+ +    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+ +        NestedVisitorMap::All(self.cx.tcx.hir())
+ +    }
+ +
+ +    fn visit_local(&mut self, l: &'tcx rustc_hir::Local<'tcx>) {
+ +        let local_id = l.pat.hir_id;
+ +        self.defs.insert(local_id);
+ +
+ +        if let Some(sym) = l.pat.simple_ident() {
+ +            self.def_symbols.insert(sym.name);
+ +        }
+ +
+ +        if let Some(expr) = l.init {
+ +            intravisit::walk_expr(self, expr);
+ +        }
+ +    }
+ +
+ +    fn visit_qpath(&mut self, qpath: &'tcx rustc_hir::QPath<'tcx>, id: HirId, _span: rustc_span::Span) {
+ +        if let rustc_hir::QPath::Resolved(_, path) = *qpath {
+ +            if path.segments.len() == 1 {
+ +                if let rustc_hir::def::Res::Local(var) = self.cx.qpath_res(qpath, id) {
+ +                    self.uses.insert(var);
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +/// Implementation of `IFS_SAME_COND`.
+ +fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
+ +    let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
+ +        let mut h = SpanlessHash::new(cx);
+ +        h.hash_expr(expr);
+ +        h.finish()
+ +    };
+ +
+ +    let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool { eq_expr_value(cx, lhs, rhs) };
+ +
+ +    for (i, j) in search_same(conds, hash, eq) {
+ +        span_lint_and_note(
+ +            cx,
+ +            IFS_SAME_COND,
+ +            j.span,
+ +            "this `if` has the same condition as a previous `if`",
+ +            Some(i.span),
+ +            "same as this",
+ +        );
+ +    }
+ +}
+ +
+ +/// Implementation of `SAME_FUNCTIONS_IN_IF_CONDITION`.
+ +fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
+ +    let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
+ +        let mut h = SpanlessHash::new(cx);
+ +        h.hash_expr(expr);
+ +        h.finish()
+ +    };
+ +
+ +    let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
+ +        // Do not lint if any expr originates from a macro
+ +        if lhs.span.from_expansion() || rhs.span.from_expansion() {
+ +            return false;
+ +        }
+ +        // Do not spawn warning if `IFS_SAME_COND` already produced it.
+ +        if eq_expr_value(cx, lhs, rhs) {
+ +            return false;
+ +        }
+ +        SpanlessEq::new(cx).eq_expr(lhs, rhs)
+ +    };
+ +
+ +    for (i, j) in search_same(conds, hash, eq) {
+ +        span_lint_and_note(
+ +            cx,
+ +            SAME_FUNCTIONS_IN_IF_CONDITION,
+ +            j.span,
+ +            "this `if` has the same function call as a previous `if`",
+ +            Some(i.span),
+ +            "same as this",
+ +        );
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/format.rs

index 688d8f8630f3fa38b84e55dd4489309b62ba2f73,0000000000000000000000000000000000000000..395c920c9974c0a525772f0e5ae88c108458b40e

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/format.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/format.rs
@@@ -1,122 -1,0 +1,137 @@@
- use rustc_span::{sym, Span};
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::macros::{root_macro_call_first_node, FormatArgsExpn};
+ +use clippy_utils::source::{snippet_opt, snippet_with_applicability};
+ +use clippy_utils::sugg::Sugg;
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{Expr, ExprKind};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_middle::ty;
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::symbol::kw;
-                     let sugg = if is_new_string {
++use rustc_span::{sym, BytePos, Span};
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for the use of `format!("string literal with no
+ +    /// argument")` and `format!("{}", foo)` where `foo` is a string.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// There is no point of doing that. `format!("foo")` can
+ +    /// be replaced by `"foo".to_owned()` if you really need a `String`. The even
+ +    /// worse `&format!("foo")` is often encountered in the wild. `format!("{}",
+ +    /// foo)` can be replaced by `foo.clone()` if `foo: String` or `foo.to_owned()`
+ +    /// if `foo: &str`.
+ +    ///
+ +    /// ### Examples
+ +    /// ```rust
+ +    ///
+ +    /// // Bad
+ +    /// let foo = "foo";
+ +    /// format!("{}", foo);
+ +    ///
+ +    /// // Good
+ +    /// foo.to_owned();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub USELESS_FORMAT,
+ +    complexity,
+ +    "useless use of `format!`"
+ +}
+ +
+ +declare_lint_pass!(UselessFormat => [USELESS_FORMAT]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for UselessFormat {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        let (format_args, call_site) = if_chain! {
+ +            if let Some(macro_call) = root_macro_call_first_node(cx, expr);
+ +            if cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id);
+ +            if let Some(format_args) = FormatArgsExpn::find_nested(cx, expr, macro_call.expn);
+ +            then {
+ +                (format_args, macro_call.span)
+ +            } else {
+ +                return
+ +            }
+ +        };
+ +
+ +        let mut applicability = Applicability::MachineApplicable;
+ +        if format_args.value_args.is_empty() {
+ +            match *format_args.format_string_parts {
+ +                [] => span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability),
+ +                [_] => {
+ +                    if let Some(s_src) = snippet_opt(cx, format_args.format_string_span) {
+ +                        // Simulate macro expansion, converting {{ and }} to { and }.
+ +                        let s_expand = s_src.replace("{{", "{").replace("}}", "}");
+ +                        let sugg = format!("{}.to_string()", s_expand);
+ +                        span_useless_format(cx, call_site, sugg, applicability);
+ +                    }
+ +                },
+ +                [..] => {},
+ +            }
+ +        } else if let [value] = *format_args.value_args {
+ +            if_chain! {
+ +                if format_args.format_string_parts == [kw::Empty];
+ +                if match cx.typeck_results().expr_ty(value).peel_refs().kind() {
+ +                    ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(sym::String, adt.did),
+ +                    ty::Str => true,
+ +                    _ => false,
+ +                };
+ +                if let Some(args) = format_args.args();
+ +                if args.iter().all(|arg| arg.format_trait == sym::Display && !arg.has_string_formatting());
+ +                then {
+ +                    let is_new_string = match value.kind {
+ +                        ExprKind::Binary(..) => true,
+ +                        ExprKind::MethodCall(path, ..) => path.ident.name.as_str() == "to_string",
+ +                        _ => false,
+ +                    };
++                    let sugg = if format_args.format_string_span.contains(value.span) {
++                        // Implicit argument. e.g. `format!("{x}")` span points to `{x}`
++                        let spdata = value.span.data();
++                        let span = Span::new(
++                            spdata.lo + BytePos(1),
++                            spdata.hi - BytePos(1),
++                            spdata.ctxt,
++                            spdata.parent
++                        );
++                        let snip = snippet_with_applicability(cx, span, "..", &mut applicability);
++                        if is_new_string {
++                            snip.into()
++                        } else {
++                            format!("{snip}.to_string()")
++                        }
++                    } else if is_new_string {
+ +                        snippet_with_applicability(cx, value.span, "..", &mut applicability).into_owned()
+ +                    } else {
+ +                        let sugg = Sugg::hir_with_applicability(cx, value, "<arg>", &mut applicability);
+ +                        format!("{}.to_string()", sugg.maybe_par())
+ +                    };
+ +                    span_useless_format(cx, call_site, sugg, applicability);
+ +                }
+ +            }
+ +        };
+ +    }
+ +}
+ +
+ +fn span_useless_format_empty(cx: &LateContext<'_>, span: Span, sugg: String, applicability: Applicability) {
+ +    span_lint_and_sugg(
+ +        cx,
+ +        USELESS_FORMAT,
+ +        span,
+ +        "useless use of `format!`",
+ +        "consider using `String::new()`",
+ +        sugg,
+ +        applicability,
+ +    );
+ +}
+ +
+ +fn span_useless_format(cx: &LateContext<'_>, span: Span, sugg: String, applicability: Applicability) {
+ +    span_lint_and_sugg(
+ +        cx,
+ +        USELESS_FORMAT,
+ +        span,
+ +        "useless use of `format!`",
+ +        "consider using `.to_string()`",
+ +        sugg,
+ +        applicability,
+ +    );
+ +}
diff --cc src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs

index 6d829a18b2e0927a0ef6ae95bf186fa15797b952,0000000000000000000000000000000000000000..834f6d2425e93895114bd6e29fbc4cebb11120d6

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
@@@ -1,125 -1,0 +1,128 @@@
-             .zip(decl.inputs.iter())
-             .filter_map(|(arg, ty)| raw_ptr_arg(arg, ty))
+ +use rustc_hir::{self as hir, intravisit, HirIdSet};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::{hir::map::Map, ty};
+ +use rustc_span::def_id::LocalDefId;
+ +
+ +use clippy_utils::diagnostics::span_lint;
+ +use clippy_utils::ty::type_is_unsafe_function;
+ +use clippy_utils::{iter_input_pats, path_to_local};
+ +
+ +use super::NOT_UNSAFE_PTR_ARG_DEREF;
+ +
+ +pub(super) fn check_fn<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    kind: intravisit::FnKind<'tcx>,
+ +    decl: &'tcx hir::FnDecl<'tcx>,
+ +    body: &'tcx hir::Body<'tcx>,
+ +    hir_id: hir::HirId,
+ +) {
+ +    let unsafety = match kind {
+ +        intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _) => unsafety,
+ +        intravisit::FnKind::Method(_, sig, _) => sig.header.unsafety,
+ +        intravisit::FnKind::Closure => return,
+ +    };
+ +
+ +    check_raw_ptr(cx, unsafety, decl, body, cx.tcx.hir().local_def_id(hir_id));
+ +}
+ +
+ +pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+ +    if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind {
+ +        let body = cx.tcx.hir().body(eid);
+ +        check_raw_ptr(cx, sig.header.unsafety, sig.decl, body, item.def_id);
+ +    }
+ +}
+ +
+ +fn check_raw_ptr<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    unsafety: hir::Unsafety,
+ +    decl: &'tcx hir::FnDecl<'tcx>,
+ +    body: &'tcx hir::Body<'tcx>,
+ +    def_id: LocalDefId,
+ +) {
+ +    let expr = &body.value;
+ +    if unsafety == hir::Unsafety::Normal && cx.access_levels.is_exported(def_id) {
+ +        let raw_ptrs = iter_input_pats(decl, body)
- fn raw_ptr_arg(arg: &hir::Param<'_>, ty: &hir::Ty<'_>) -> Option<hir::HirId> {
-     if let (&hir::PatKind::Binding(_, id, _, _), &hir::TyKind::Ptr(_)) = (&arg.pat.kind, &ty.kind) {
++            .filter_map(|arg| raw_ptr_arg(cx, arg))
+ +            .collect::<HirIdSet>();
+ +
+ +        if !raw_ptrs.is_empty() {
+ +            let typeck_results = cx.tcx.typeck_body(body.id());
+ +            let mut v = DerefVisitor {
+ +                cx,
+ +                ptrs: raw_ptrs,
+ +                typeck_results,
+ +            };
+ +
+ +            intravisit::walk_expr(&mut v, expr);
+ +        }
+ +    }
+ +}
+ +
++fn raw_ptr_arg(cx: &LateContext<'_>, arg: &hir::Param<'_>) -> Option<hir::HirId> {
++    if let (&hir::PatKind::Binding(_, id, _, _), Some(&ty::RawPtr(_))) = (
++        &arg.pat.kind,
++        cx.maybe_typeck_results()
++            .map(|typeck_results| typeck_results.pat_ty(arg.pat).kind()),
++    ) {
+ +        Some(id)
+ +    } else {
+ +        None
+ +    }
+ +}
+ +
+ +struct DerefVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,
+ +    ptrs: HirIdSet,
+ +    typeck_results: &'a ty::TypeckResults<'tcx>,
+ +}
+ +
+ +impl<'a, 'tcx> intravisit::Visitor<'tcx> for DerefVisitor<'a, 'tcx> {
+ +    type Map = Map<'tcx>;
+ +
+ +    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+ +        match expr.kind {
+ +            hir::ExprKind::Call(f, args) => {
+ +                let ty = self.typeck_results.expr_ty(f);
+ +
+ +                if type_is_unsafe_function(self.cx, ty) {
+ +                    for arg in args {
+ +                        self.check_arg(arg);
+ +                    }
+ +                }
+ +            },
+ +            hir::ExprKind::MethodCall(_, _, args, _) => {
+ +                let def_id = self.typeck_results.type_dependent_def_id(expr.hir_id).unwrap();
+ +                let base_type = self.cx.tcx.type_of(def_id);
+ +
+ +                if type_is_unsafe_function(self.cx, base_type) {
+ +                    for arg in args {
+ +                        self.check_arg(arg);
+ +                    }
+ +                }
+ +            },
+ +            hir::ExprKind::Unary(hir::UnOp::Deref, ptr) => self.check_arg(ptr),
+ +            _ => (),
+ +        }
+ +
+ +        intravisit::walk_expr(self, expr);
+ +    }
+ +
+ +    fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
+ +        intravisit::NestedVisitorMap::None
+ +    }
+ +}
+ +
+ +impl<'a, 'tcx> DerefVisitor<'a, 'tcx> {
+ +    fn check_arg(&self, ptr: &hir::Expr<'_>) {
+ +        if let Some(id) = path_to_local(ptr) {
+ +            if self.ptrs.contains(&id) {
+ +                span_lint(
+ +                    self.cx,
+ +                    NOT_UNSAFE_PTR_ARG_DEREF,
+ +                    ptr.span,
+ +                    "this public function might dereference a raw pointer but is not marked `unsafe`",
+ +                );
+ +            }
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/iter_not_returning_iterator.rs

index d3bdc819a9f2b48e277d9dd5aaca17859e3d1782,0000000000000000000000000000000000000000..b56d87c5348c2996ace5bafdf1475582df5c2d98

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/iter_not_returning_iterator.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/iter_not_returning_iterator.rs
@@@ -1,90 -1,0 +1,90 @@@
-         let ret_ty = cx.tcx.fn_sig(fn_id).skip_binder().output();
+ +use clippy_utils::{diagnostics::span_lint, get_parent_node, ty::implements_trait};
+ +use rustc_hir::{def_id::LocalDefId, FnSig, ImplItem, ImplItemKind, Item, ItemKind, Node, TraitItem, TraitItemKind};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::symbol::sym;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Detects methods named `iter` or `iter_mut` that do not have a return type that implements `Iterator`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Methods named `iter` or `iter_mut` conventionally return an `Iterator`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // `String` does not implement `Iterator`
+ +    /// struct Data {}
+ +    /// impl Data {
+ +    ///     fn iter(&self) -> String {
+ +    ///         todo!()
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// use std::str::Chars;
+ +    /// struct Data {}
+ +    /// impl Data {
+ +    ///    fn iter(&self) -> Chars<'static> {
+ +    ///        todo!()
+ +    ///    }
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "1.57.0"]
+ +    pub ITER_NOT_RETURNING_ITERATOR,
+ +    pedantic,
+ +    "methods named `iter` or `iter_mut` that do not return an `Iterator`"
+ +}
+ +
+ +declare_lint_pass!(IterNotReturningIterator => [ITER_NOT_RETURNING_ITERATOR]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for IterNotReturningIterator {
+ +    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+ +        let name = item.ident.name.as_str();
+ +        if matches!(name, "iter" | "iter_mut") {
+ +            if let TraitItemKind::Fn(fn_sig, _) = &item.kind {
+ +                check_sig(cx, name, fn_sig, item.def_id);
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'tcx>) {
+ +        let name = item.ident.name.as_str();
+ +        if matches!(name, "iter" | "iter_mut")
+ +            && !matches!(
+ +                get_parent_node(cx.tcx, item.hir_id()),
+ +                Some(Node::Item(Item { kind: ItemKind::Impl(i), .. })) if i.of_trait.is_some()
+ +            )
+ +        {
+ +            if let ImplItemKind::Fn(fn_sig, _) = &item.kind {
+ +                check_sig(cx, name, fn_sig, item.def_id);
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +fn check_sig(cx: &LateContext<'_>, name: &str, sig: &FnSig<'_>, fn_id: LocalDefId) {
+ +    if sig.decl.implicit_self.has_implicit_self() {
++        let ret_ty = cx.tcx.erase_late_bound_regions(cx.tcx.fn_sig(fn_id).output());
+ +        let ret_ty = cx
+ +            .tcx
+ +            .try_normalize_erasing_regions(cx.param_env, ret_ty)
+ +            .unwrap_or(ret_ty);
+ +        if cx
+ +            .tcx
+ +            .get_diagnostic_item(sym::Iterator)
+ +            .map_or(false, |iter_id| !implements_trait(cx, ret_ty, iter_id, &[]))
+ +        {
+ +            span_lint(
+ +                cx,
+ +                ITER_NOT_RETURNING_ITERATOR,
+ +                sig.span,
+ +                &format!(
+ +                    "this method is named `{}` but its return type does not implement `Iterator`",
+ +                    name
+ +                ),
+ +            );
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/lib.register_all.rs

index 26fb4259952b6ac5b971179f41b36ad0b86d3c7b,0000000000000000000000000000000000000000..87fd7f99748a1df8d1b00018e7e7b1c09d55a68d

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.register_all.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.register_all.rs
@@@ -1,317 -1,0 +1,317 @@@
-     LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
+ +// This file was generated by `cargo dev update_lints`.
+ +// Use that command to update this file and do not edit by hand.
+ +// Manual edits will be overwritten.
+ +
+ +store.register_group(true, "clippy::all", Some("clippy_all"), vec![
+ +    LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+ +    LintId::of(approx_const::APPROX_CONSTANT),
+ +    LintId::of(assertions_on_constants::ASSERTIONS_ON_CONSTANTS),
+ +    LintId::of(assign_ops::ASSIGN_OP_PATTERN),
+ +    LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+ +    LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+ +    LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+ +    LintId::of(attrs::DEPRECATED_CFG_ATTR),
+ +    LintId::of(attrs::DEPRECATED_SEMVER),
+ +    LintId::of(attrs::MISMATCHED_TARGET_OS),
+ +    LintId::of(attrs::USELESS_ATTRIBUTE),
+ +    LintId::of(bit_mask::BAD_BIT_MASK),
+ +    LintId::of(bit_mask::INEFFECTIVE_BIT_MASK),
+ +    LintId::of(blacklisted_name::BLACKLISTED_NAME),
+ +    LintId::of(blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS),
+ +    LintId::of(bool_assert_comparison::BOOL_ASSERT_COMPARISON),
+ +    LintId::of(booleans::LOGIC_BUG),
+ +    LintId::of(booleans::NONMINIMAL_BOOL),
+ +    LintId::of(casts::CAST_REF_TO_MUT),
+ +    LintId::of(casts::CHAR_LIT_AS_U8),
+ +    LintId::of(casts::FN_TO_NUMERIC_CAST),
+ +    LintId::of(casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION),
+ +    LintId::of(casts::UNNECESSARY_CAST),
+ +    LintId::of(collapsible_if::COLLAPSIBLE_ELSE_IF),
+ +    LintId::of(collapsible_if::COLLAPSIBLE_IF),
+ +    LintId::of(collapsible_match::COLLAPSIBLE_MATCH),
+ +    LintId::of(comparison_chain::COMPARISON_CHAIN),
+ +    LintId::of(copies::IFS_SAME_COND),
+ +    LintId::of(copies::IF_SAME_THEN_ELSE),
+ +    LintId::of(default::FIELD_REASSIGN_WITH_DEFAULT),
+ +    LintId::of(dereference::NEEDLESS_BORROW),
+ +    LintId::of(derivable_impls::DERIVABLE_IMPLS),
+ +    LintId::of(derive::DERIVE_HASH_XOR_EQ),
+ +    LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+ +    LintId::of(disallowed_methods::DISALLOWED_METHODS),
+ +    LintId::of(disallowed_types::DISALLOWED_TYPES),
+ +    LintId::of(doc::MISSING_SAFETY_DOC),
+ +    LintId::of(doc::NEEDLESS_DOCTEST_MAIN),
+ +    LintId::of(double_comparison::DOUBLE_COMPARISONS),
+ +    LintId::of(double_parens::DOUBLE_PARENS),
+ +    LintId::of(drop_forget_ref::DROP_COPY),
+ +    LintId::of(drop_forget_ref::DROP_REF),
+ +    LintId::of(drop_forget_ref::FORGET_COPY),
+ +    LintId::of(drop_forget_ref::FORGET_REF),
+ +    LintId::of(duration_subsec::DURATION_SUBSEC),
+ +    LintId::of(entry::MAP_ENTRY),
+ +    LintId::of(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+ +    LintId::of(enum_variants::ENUM_VARIANT_NAMES),
+ +    LintId::of(enum_variants::MODULE_INCEPTION),
+ +    LintId::of(eq_op::EQ_OP),
+ +    LintId::of(eq_op::OP_REF),
+ +    LintId::of(erasing_op::ERASING_OP),
+ +    LintId::of(escape::BOXED_LOCAL),
+ +    LintId::of(eta_reduction::REDUNDANT_CLOSURE),
+ +    LintId::of(eval_order_dependence::DIVERGING_SUB_EXPRESSION),
+ +    LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+ +    LintId::of(explicit_write::EXPLICIT_WRITE),
+ +    LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+ +    LintId::of(float_literal::EXCESSIVE_PRECISION),
+ +    LintId::of(format::USELESS_FORMAT),
+ +    LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
+ +    LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
+ +    LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+ +    LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+ +    LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+ +    LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+ +    LintId::of(from_over_into::FROM_OVER_INTO),
+ +    LintId::of(from_str_radix_10::FROM_STR_RADIX_10),
+ +    LintId::of(functions::DOUBLE_MUST_USE),
+ +    LintId::of(functions::MUST_USE_UNIT),
+ +    LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+ +    LintId::of(functions::RESULT_UNIT_ERR),
+ +    LintId::of(functions::TOO_MANY_ARGUMENTS),
+ +    LintId::of(get_last_with_len::GET_LAST_WITH_LEN),
+ +    LintId::of(identity_op::IDENTITY_OP),
+ +    LintId::of(if_let_mutex::IF_LET_MUTEX),
+ +    LintId::of(indexing_slicing::OUT_OF_BOUNDS_INDEXING),
+ +    LintId::of(infinite_iter::INFINITE_ITER),
+ +    LintId::of(inherent_to_string::INHERENT_TO_STRING),
+ +    LintId::of(inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY),
+ +    LintId::of(init_numbered_fields::INIT_NUMBERED_FIELDS),
+ +    LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+ +    LintId::of(int_plus_one::INT_PLUS_ONE),
+ +    LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+ +    LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+ +    LintId::of(len_zero::COMPARISON_TO_EMPTY),
+ +    LintId::of(len_zero::LEN_WITHOUT_IS_EMPTY),
+ +    LintId::of(len_zero::LEN_ZERO),
+ +    LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+ +    LintId::of(lifetimes::EXTRA_UNUSED_LIFETIMES),
+ +    LintId::of(lifetimes::NEEDLESS_LIFETIMES),
+ +    LintId::of(literal_representation::INCONSISTENT_DIGIT_GROUPING),
+ +    LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+ +    LintId::of(literal_representation::UNUSUAL_BYTE_GROUPINGS),
+ +    LintId::of(loops::EMPTY_LOOP),
+ +    LintId::of(loops::EXPLICIT_COUNTER_LOOP),
+ +    LintId::of(loops::FOR_KV_MAP),
+ +    LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+ +    LintId::of(loops::ITER_NEXT_LOOP),
+ +    LintId::of(loops::MANUAL_FLATTEN),
+ +    LintId::of(loops::MANUAL_MEMCPY),
+ +    LintId::of(loops::MUT_RANGE_BOUND),
+ +    LintId::of(loops::NEEDLESS_COLLECT),
+ +    LintId::of(loops::NEEDLESS_RANGE_LOOP),
+ +    LintId::of(loops::NEVER_LOOP),
+ +    LintId::of(loops::SAME_ITEM_PUSH),
+ +    LintId::of(loops::SINGLE_ELEMENT_LOOP),
+ +    LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+ +    LintId::of(loops::WHILE_LET_LOOP),
+ +    LintId::of(loops::WHILE_LET_ON_ITERATOR),
+ +    LintId::of(main_recursion::MAIN_RECURSION),
+ +    LintId::of(manual_async_fn::MANUAL_ASYNC_FN),
+ +    LintId::of(manual_bits::MANUAL_BITS),
+ +    LintId::of(manual_map::MANUAL_MAP),
+ +    LintId::of(manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE),
+ +    LintId::of(manual_strip::MANUAL_STRIP),
+ +    LintId::of(manual_unwrap_or::MANUAL_UNWRAP_OR),
+ +    LintId::of(map_clone::MAP_CLONE),
+ +    LintId::of(map_unit_fn::OPTION_MAP_UNIT_FN),
+ +    LintId::of(map_unit_fn::RESULT_MAP_UNIT_FN),
+ +    LintId::of(match_result_ok::MATCH_RESULT_OK),
+ +    LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
+ +    LintId::of(matches::INFALLIBLE_DESTRUCTURING_MATCH),
+ +    LintId::of(matches::MATCH_AS_REF),
+ +    LintId::of(matches::MATCH_LIKE_MATCHES_MACRO),
+ +    LintId::of(matches::MATCH_OVERLAPPING_ARM),
+ +    LintId::of(matches::MATCH_REF_PATS),
+ +    LintId::of(matches::MATCH_SINGLE_BINDING),
+ +    LintId::of(matches::REDUNDANT_PATTERN_MATCHING),
+ +    LintId::of(matches::SINGLE_MATCH),
+ +    LintId::of(matches::WILDCARD_IN_OR_PATTERNS),
+ +    LintId::of(mem_replace::MEM_REPLACE_OPTION_WITH_NONE),
+ +    LintId::of(mem_replace::MEM_REPLACE_WITH_DEFAULT),
+ +    LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+ +    LintId::of(methods::BIND_INSTEAD_OF_MAP),
+ +    LintId::of(methods::BYTES_NTH),
+ +    LintId::of(methods::CHARS_LAST_CMP),
+ +    LintId::of(methods::CHARS_NEXT_CMP),
+ +    LintId::of(methods::CLONE_DOUBLE_REF),
+ +    LintId::of(methods::CLONE_ON_COPY),
+ +    LintId::of(methods::EXPECT_FUN_CALL),
+ +    LintId::of(methods::EXTEND_WITH_DRAIN),
+ +    LintId::of(methods::FILTER_MAP_IDENTITY),
+ +    LintId::of(methods::FILTER_NEXT),
+ +    LintId::of(methods::FLAT_MAP_IDENTITY),
+ +    LintId::of(methods::INSPECT_FOR_EACH),
+ +    LintId::of(methods::INTO_ITER_ON_REF),
+ +    LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+ +    LintId::of(methods::ITER_CLONED_COLLECT),
+ +    LintId::of(methods::ITER_COUNT),
+ +    LintId::of(methods::ITER_NEXT_SLICE),
+ +    LintId::of(methods::ITER_NTH),
+ +    LintId::of(methods::ITER_NTH_ZERO),
++    LintId::of(methods::ITER_OVEREAGER_CLONED),
+ +    LintId::of(methods::ITER_SKIP_NEXT),
+ +    LintId::of(methods::MANUAL_FILTER_MAP),
+ +    LintId::of(methods::MANUAL_FIND_MAP),
+ +    LintId::of(methods::MANUAL_SATURATING_ARITHMETIC),
+ +    LintId::of(methods::MANUAL_SPLIT_ONCE),
+ +    LintId::of(methods::MANUAL_STR_REPEAT),
+ +    LintId::of(methods::MAP_COLLECT_RESULT_UNIT),
+ +    LintId::of(methods::MAP_FLATTEN),
+ +    LintId::of(methods::MAP_IDENTITY),
+ +    LintId::of(methods::NEEDLESS_SPLITN),
+ +    LintId::of(methods::NEW_RET_NO_SELF),
+ +    LintId::of(methods::OK_EXPECT),
+ +    LintId::of(methods::OPTION_AS_REF_DEREF),
+ +    LintId::of(methods::OPTION_FILTER_MAP),
+ +    LintId::of(methods::OPTION_MAP_OR_NONE),
+ +    LintId::of(methods::OR_FUN_CALL),
+ +    LintId::of(methods::RESULT_MAP_OR_INTO_OPTION),
+ +    LintId::of(methods::SEARCH_IS_SOME),
+ +    LintId::of(methods::SHOULD_IMPLEMENT_TRAIT),
+ +    LintId::of(methods::SINGLE_CHAR_ADD_STR),
+ +    LintId::of(methods::SINGLE_CHAR_PATTERN),
+ +    LintId::of(methods::SKIP_WHILE_NEXT),
+ +    LintId::of(methods::STRING_EXTEND_CHARS),
+ +    LintId::of(methods::SUSPICIOUS_MAP),
+ +    LintId::of(methods::SUSPICIOUS_SPLITN),
+ +    LintId::of(methods::UNINIT_ASSUMED_INIT),
+ +    LintId::of(methods::UNNECESSARY_FILTER_MAP),
+ +    LintId::of(methods::UNNECESSARY_FOLD),
+ +    LintId::of(methods::UNNECESSARY_LAZY_EVALUATIONS),
+ +    LintId::of(methods::UNNECESSARY_TO_OWNED),
+ +    LintId::of(methods::UNWRAP_OR_ELSE_DEFAULT),
+ +    LintId::of(methods::USELESS_ASREF),
+ +    LintId::of(methods::WRONG_SELF_CONVENTION),
+ +    LintId::of(methods::ZST_OFFSET),
+ +    LintId::of(minmax::MIN_MAX),
+ +    LintId::of(misc::CMP_NAN),
+ +    LintId::of(misc::CMP_OWNED),
+ +    LintId::of(misc::MODULO_ONE),
+ +    LintId::of(misc::SHORT_CIRCUIT_STATEMENT),
+ +    LintId::of(misc::TOPLEVEL_REF_ARG),
+ +    LintId::of(misc::ZERO_PTR),
+ +    LintId::of(misc_early::BUILTIN_TYPE_SHADOW),
+ +    LintId::of(misc_early::DOUBLE_NEG),
+ +    LintId::of(misc_early::DUPLICATE_UNDERSCORE_ARGUMENT),
+ +    LintId::of(misc_early::MIXED_CASE_HEX_LITERALS),
+ +    LintId::of(misc_early::REDUNDANT_PATTERN),
+ +    LintId::of(misc_early::UNNEEDED_WILDCARD_PATTERN),
+ +    LintId::of(misc_early::ZERO_PREFIXED_LITERAL),
+ +    LintId::of(mut_key::MUTABLE_KEY_TYPE),
+ +    LintId::of(mut_mutex_lock::MUT_MUTEX_LOCK),
+ +    LintId::of(mut_reference::UNNECESSARY_MUT_PASSED),
+ +    LintId::of(needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE),
+ +    LintId::of(needless_bool::BOOL_COMPARISON),
+ +    LintId::of(needless_bool::NEEDLESS_BOOL),
+ +    LintId::of(needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE),
+ +    LintId::of(needless_late_init::NEEDLESS_LATE_INIT),
+ +    LintId::of(needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF),
+ +    LintId::of(needless_question_mark::NEEDLESS_QUESTION_MARK),
+ +    LintId::of(needless_update::NEEDLESS_UPDATE),
+ +    LintId::of(neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD),
+ +    LintId::of(neg_multiply::NEG_MULTIPLY),
+ +    LintId::of(new_without_default::NEW_WITHOUT_DEFAULT),
+ +    LintId::of(no_effect::NO_EFFECT),
+ +    LintId::of(no_effect::UNNECESSARY_OPERATION),
+ +    LintId::of(non_copy_const::BORROW_INTERIOR_MUTABLE_CONST),
+ +    LintId::of(non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST),
+ +    LintId::of(non_expressive_names::JUST_UNDERSCORES_AND_DIGITS),
+ +    LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+ +    LintId::of(octal_escapes::OCTAL_ESCAPES),
+ +    LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+ +    LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+ +    LintId::of(overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL),
+ +    LintId::of(partialeq_ne_impl::PARTIALEQ_NE_IMPL),
+ +    LintId::of(precedence::PRECEDENCE),
+ +    LintId::of(ptr::CMP_NULL),
+ +    LintId::of(ptr::INVALID_NULL_PTR_USAGE),
+ +    LintId::of(ptr::MUT_FROM_REF),
+ +    LintId::of(ptr::PTR_ARG),
+ +    LintId::of(ptr_eq::PTR_EQ),
+ +    LintId::of(ptr_offset_with_cast::PTR_OFFSET_WITH_CAST),
+ +    LintId::of(question_mark::QUESTION_MARK),
+ +    LintId::of(ranges::MANUAL_RANGE_CONTAINS),
+ +    LintId::of(ranges::RANGE_ZIP_WITH_LEN),
+ +    LintId::of(ranges::REVERSED_EMPTY_RANGES),
+ +    LintId::of(redundant_clone::REDUNDANT_CLONE),
+ +    LintId::of(redundant_closure_call::REDUNDANT_CLOSURE_CALL),
+ +    LintId::of(redundant_field_names::REDUNDANT_FIELD_NAMES),
+ +    LintId::of(redundant_slicing::REDUNDANT_SLICING),
+ +    LintId::of(redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES),
+ +    LintId::of(reference::DEREF_ADDROF),
+ +    LintId::of(reference::REF_IN_DEREF),
+ +    LintId::of(regex::INVALID_REGEX),
+ +    LintId::of(repeat_once::REPEAT_ONCE),
+ +    LintId::of(returns::LET_AND_RETURN),
+ +    LintId::of(returns::NEEDLESS_RETURN),
+ +    LintId::of(self_assignment::SELF_ASSIGNMENT),
+ +    LintId::of(self_named_constructors::SELF_NAMED_CONSTRUCTORS),
+ +    LintId::of(serde_api::SERDE_API_MISUSE),
+ +    LintId::of(single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS),
+ +    LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+ +    LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+ +    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+ +    LintId::of(strings::STRING_FROM_UTF8_AS_BYTES),
+ +    LintId::of(strlen_on_c_strings::STRLEN_ON_C_STRINGS),
+ +    LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+ +    LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+ +    LintId::of(swap::ALMOST_SWAPPED),
+ +    LintId::of(swap::MANUAL_SWAP),
+ +    LintId::of(tabs_in_doc_comments::TABS_IN_DOC_COMMENTS),
+ +    LintId::of(temporary_assignment::TEMPORARY_ASSIGNMENT),
+ +    LintId::of(to_digit_is_some::TO_DIGIT_IS_SOME),
+ +    LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
+ +    LintId::of(transmute::CROSSPOINTER_TRANSMUTE),
+ +    LintId::of(transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS),
+ +    LintId::of(transmute::TRANSMUTE_BYTES_TO_STR),
+ +    LintId::of(transmute::TRANSMUTE_FLOAT_TO_INT),
+ +    LintId::of(transmute::TRANSMUTE_INT_TO_BOOL),
+ +    LintId::of(transmute::TRANSMUTE_INT_TO_CHAR),
+ +    LintId::of(transmute::TRANSMUTE_INT_TO_FLOAT),
+ +    LintId::of(transmute::TRANSMUTE_NUM_TO_BYTES),
+ +    LintId::of(transmute::TRANSMUTE_PTR_TO_REF),
+ +    LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+ +    LintId::of(transmute::WRONG_TRANSMUTE),
+ +    LintId::of(transmuting_null::TRANSMUTING_NULL),
+ +    LintId::of(try_err::TRY_ERR),
+ +    LintId::of(types::BORROWED_BOX),
+ +    LintId::of(types::BOX_COLLECTION),
+ +    LintId::of(types::REDUNDANT_ALLOCATION),
+ +    LintId::of(types::TYPE_COMPLEXITY),
+ +    LintId::of(types::VEC_BOX),
+ +    LintId::of(undropped_manually_drops::UNDROPPED_MANUALLY_DROPS),
+ +    LintId::of(unicode::INVISIBLE_CHARACTERS),
+ +    LintId::of(uninit_vec::UNINIT_VEC),
+ +    LintId::of(unit_hash::UNIT_HASH),
+ +    LintId::of(unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD),
+ +    LintId::of(unit_types::UNIT_ARG),
+ +    LintId::of(unit_types::UNIT_CMP),
+ +    LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+ +    LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+ +    LintId::of(unnecessary_sort_by::UNNECESSARY_SORT_BY),
+ +    LintId::of(unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME),
+ +    LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+ +    LintId::of(unused_unit::UNUSED_UNIT),
+ +    LintId::of(unwrap::PANICKING_UNWRAP),
+ +    LintId::of(unwrap::UNNECESSARY_UNWRAP),
+ +    LintId::of(upper_case_acronyms::UPPER_CASE_ACRONYMS),
+ +    LintId::of(useless_conversion::USELESS_CONVERSION),
+ +    LintId::of(vec::USELESS_VEC),
+ +    LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
+ +    LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+ +    LintId::of(write::PRINTLN_EMPTY_STRING),
+ +    LintId::of(write::PRINT_LITERAL),
+ +    LintId::of(write::PRINT_WITH_NEWLINE),
+ +    LintId::of(write::WRITELN_EMPTY_STRING),
+ +    LintId::of(write::WRITE_LITERAL),
+ +    LintId::of(write::WRITE_WITH_NEWLINE),
+ +    LintId::of(zero_div_zero::ZERO_DIVIDED_BY_ZERO),
+ +])
diff --cc src/tools/clippy/clippy_lints/src/lib.register_lints.rs

index 746bdb19c3d927c71003c869be6f41ef6774a82c,0000000000000000000000000000000000000000..56146a0fd3a7525d84cfeb51f2dd08cfdf8119c0

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.register_lints.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.register_lints.rs
@@@ -1,535 -1,0 +1,536 @@@
+ +// This file was generated by `cargo dev update_lints`.
+ +// Use that command to update this file and do not edit by hand.
+ +// Manual edits will be overwritten.
+ +
+ +store.register_lints(&[
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::CLIPPY_LINTS_INTERNAL,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::COMPILER_LINT_FUNCTIONS,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::DEFAULT_LINT,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::IF_CHAIN_STYLE,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::INTERNING_DEFINED_SYMBOL,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::INVALID_PATHS,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::LINT_WITHOUT_LINT_PASS,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::OUTER_EXPN_EXPN_DATA,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::PRODUCE_ICE,
+ +    #[cfg(feature = "internal")]
+ +    utils::internal_lints::UNNECESSARY_SYMBOL_STR,
+ +    absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS,
+ +    approx_const::APPROX_CONSTANT,
+ +    arithmetic::FLOAT_ARITHMETIC,
+ +    arithmetic::INTEGER_ARITHMETIC,
+ +    as_conversions::AS_CONVERSIONS,
+ +    asm_syntax::INLINE_ASM_X86_ATT_SYNTAX,
+ +    asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX,
+ +    assertions_on_constants::ASSERTIONS_ON_CONSTANTS,
+ +    assign_ops::ASSIGN_OP_PATTERN,
+ +    assign_ops::MISREFACTORED_ASSIGN_OP,
+ +    async_yields_async::ASYNC_YIELDS_ASYNC,
+ +    attrs::BLANKET_CLIPPY_RESTRICTION_LINTS,
+ +    attrs::DEPRECATED_CFG_ATTR,
+ +    attrs::DEPRECATED_SEMVER,
+ +    attrs::EMPTY_LINE_AFTER_OUTER_ATTR,
+ +    attrs::INLINE_ALWAYS,
+ +    attrs::MISMATCHED_TARGET_OS,
+ +    attrs::USELESS_ATTRIBUTE,
+ +    await_holding_invalid::AWAIT_HOLDING_LOCK,
+ +    await_holding_invalid::AWAIT_HOLDING_REFCELL_REF,
+ +    bit_mask::BAD_BIT_MASK,
+ +    bit_mask::INEFFECTIVE_BIT_MASK,
+ +    bit_mask::VERBOSE_BIT_MASK,
+ +    blacklisted_name::BLACKLISTED_NAME,
+ +    blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS,
+ +    bool_assert_comparison::BOOL_ASSERT_COMPARISON,
+ +    booleans::LOGIC_BUG,
+ +    booleans::NONMINIMAL_BOOL,
+ +    borrow_as_ptr::BORROW_AS_PTR,
+ +    bytecount::NAIVE_BYTECOUNT,
+ +    cargo_common_metadata::CARGO_COMMON_METADATA,
+ +    case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS,
+ +    casts::CAST_LOSSLESS,
+ +    casts::CAST_POSSIBLE_TRUNCATION,
+ +    casts::CAST_POSSIBLE_WRAP,
+ +    casts::CAST_PRECISION_LOSS,
+ +    casts::CAST_PTR_ALIGNMENT,
+ +    casts::CAST_REF_TO_MUT,
+ +    casts::CAST_SIGN_LOSS,
+ +    casts::CHAR_LIT_AS_U8,
+ +    casts::FN_TO_NUMERIC_CAST,
+ +    casts::FN_TO_NUMERIC_CAST_ANY,
+ +    casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION,
+ +    casts::PTR_AS_PTR,
+ +    casts::UNNECESSARY_CAST,
+ +    checked_conversions::CHECKED_CONVERSIONS,
+ +    cognitive_complexity::COGNITIVE_COMPLEXITY,
+ +    collapsible_if::COLLAPSIBLE_ELSE_IF,
+ +    collapsible_if::COLLAPSIBLE_IF,
+ +    collapsible_match::COLLAPSIBLE_MATCH,
+ +    comparison_chain::COMPARISON_CHAIN,
+ +    copies::BRANCHES_SHARING_CODE,
+ +    copies::IFS_SAME_COND,
+ +    copies::IF_SAME_THEN_ELSE,
+ +    copies::SAME_FUNCTIONS_IN_IF_CONDITION,
+ +    copy_iterator::COPY_ITERATOR,
+ +    create_dir::CREATE_DIR,
+ +    dbg_macro::DBG_MACRO,
+ +    default::DEFAULT_TRAIT_ACCESS,
+ +    default::FIELD_REASSIGN_WITH_DEFAULT,
+ +    default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK,
+ +    dereference::EXPLICIT_DEREF_METHODS,
+ +    dereference::NEEDLESS_BORROW,
+ +    dereference::REF_BINDING_TO_REFERENCE,
+ +    derivable_impls::DERIVABLE_IMPLS,
+ +    derive::DERIVE_HASH_XOR_EQ,
+ +    derive::DERIVE_ORD_XOR_PARTIAL_ORD,
+ +    derive::EXPL_IMPL_CLONE_ON_COPY,
+ +    derive::UNSAFE_DERIVE_DESERIALIZE,
+ +    disallowed_methods::DISALLOWED_METHODS,
+ +    disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS,
+ +    disallowed_types::DISALLOWED_TYPES,
+ +    doc::DOC_MARKDOWN,
+ +    doc::MISSING_ERRORS_DOC,
+ +    doc::MISSING_PANICS_DOC,
+ +    doc::MISSING_SAFETY_DOC,
+ +    doc::NEEDLESS_DOCTEST_MAIN,
+ +    double_comparison::DOUBLE_COMPARISONS,
+ +    double_parens::DOUBLE_PARENS,
+ +    drop_forget_ref::DROP_COPY,
+ +    drop_forget_ref::DROP_REF,
+ +    drop_forget_ref::FORGET_COPY,
+ +    drop_forget_ref::FORGET_REF,
+ +    duration_subsec::DURATION_SUBSEC,
+ +    else_if_without_else::ELSE_IF_WITHOUT_ELSE,
+ +    empty_enum::EMPTY_ENUM,
+ +    entry::MAP_ENTRY,
+ +    enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT,
+ +    enum_variants::ENUM_VARIANT_NAMES,
+ +    enum_variants::MODULE_INCEPTION,
+ +    enum_variants::MODULE_NAME_REPETITIONS,
+ +    eq_op::EQ_OP,
+ +    eq_op::OP_REF,
+ +    equatable_if_let::EQUATABLE_IF_LET,
+ +    erasing_op::ERASING_OP,
+ +    escape::BOXED_LOCAL,
+ +    eta_reduction::REDUNDANT_CLOSURE,
+ +    eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+ +    eval_order_dependence::DIVERGING_SUB_EXPRESSION,
+ +    eval_order_dependence::EVAL_ORDER_DEPENDENCE,
+ +    excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS,
+ +    excessive_bools::STRUCT_EXCESSIVE_BOOLS,
+ +    exhaustive_items::EXHAUSTIVE_ENUMS,
+ +    exhaustive_items::EXHAUSTIVE_STRUCTS,
+ +    exit::EXIT,
+ +    explicit_write::EXPLICIT_WRITE,
+ +    fallible_impl_from::FALLIBLE_IMPL_FROM,
+ +    feature_name::NEGATIVE_FEATURE_NAMES,
+ +    feature_name::REDUNDANT_FEATURE_NAMES,
+ +    float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS,
+ +    float_literal::EXCESSIVE_PRECISION,
+ +    float_literal::LOSSY_FLOAT_LITERAL,
+ +    floating_point_arithmetic::IMPRECISE_FLOPS,
+ +    floating_point_arithmetic::SUBOPTIMAL_FLOPS,
+ +    format::USELESS_FORMAT,
+ +    format_args::FORMAT_IN_FORMAT_ARGS,
+ +    format_args::TO_STRING_IN_FORMAT_ARGS,
+ +    formatting::POSSIBLE_MISSING_COMMA,
+ +    formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
+ +    formatting::SUSPICIOUS_ELSE_FORMATTING,
+ +    formatting::SUSPICIOUS_UNARY_OP_FORMATTING,
+ +    from_over_into::FROM_OVER_INTO,
+ +    from_str_radix_10::FROM_STR_RADIX_10,
+ +    functions::DOUBLE_MUST_USE,
+ +    functions::MUST_USE_CANDIDATE,
+ +    functions::MUST_USE_UNIT,
+ +    functions::NOT_UNSAFE_PTR_ARG_DEREF,
+ +    functions::RESULT_UNIT_ERR,
+ +    functions::TOO_MANY_ARGUMENTS,
+ +    functions::TOO_MANY_LINES,
+ +    future_not_send::FUTURE_NOT_SEND,
+ +    get_last_with_len::GET_LAST_WITH_LEN,
+ +    identity_op::IDENTITY_OP,
+ +    if_let_mutex::IF_LET_MUTEX,
+ +    if_not_else::IF_NOT_ELSE,
+ +    if_then_some_else_none::IF_THEN_SOME_ELSE_NONE,
+ +    implicit_hasher::IMPLICIT_HASHER,
+ +    implicit_return::IMPLICIT_RETURN,
+ +    implicit_saturating_sub::IMPLICIT_SATURATING_SUB,
+ +    inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR,
+ +    index_refutable_slice::INDEX_REFUTABLE_SLICE,
+ +    indexing_slicing::INDEXING_SLICING,
+ +    indexing_slicing::OUT_OF_BOUNDS_INDEXING,
+ +    infinite_iter::INFINITE_ITER,
+ +    infinite_iter::MAYBE_INFINITE_ITER,
+ +    inherent_impl::MULTIPLE_INHERENT_IMPL,
+ +    inherent_to_string::INHERENT_TO_STRING,
+ +    inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY,
+ +    init_numbered_fields::INIT_NUMBERED_FIELDS,
+ +    inline_fn_without_body::INLINE_FN_WITHOUT_BODY,
+ +    int_plus_one::INT_PLUS_ONE,
+ +    integer_division::INTEGER_DIVISION,
+ +    invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS,
+ +    items_after_statements::ITEMS_AFTER_STATEMENTS,
+ +    iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR,
+ +    large_const_arrays::LARGE_CONST_ARRAYS,
+ +    large_enum_variant::LARGE_ENUM_VARIANT,
+ +    large_stack_arrays::LARGE_STACK_ARRAYS,
+ +    len_zero::COMPARISON_TO_EMPTY,
+ +    len_zero::LEN_WITHOUT_IS_EMPTY,
+ +    len_zero::LEN_ZERO,
+ +    let_if_seq::USELESS_LET_IF_SEQ,
+ +    let_underscore::LET_UNDERSCORE_DROP,
+ +    let_underscore::LET_UNDERSCORE_LOCK,
+ +    let_underscore::LET_UNDERSCORE_MUST_USE,
+ +    lifetimes::EXTRA_UNUSED_LIFETIMES,
+ +    lifetimes::NEEDLESS_LIFETIMES,
+ +    literal_representation::DECIMAL_LITERAL_REPRESENTATION,
+ +    literal_representation::INCONSISTENT_DIGIT_GROUPING,
+ +    literal_representation::LARGE_DIGIT_GROUPS,
+ +    literal_representation::MISTYPED_LITERAL_SUFFIXES,
+ +    literal_representation::UNREADABLE_LITERAL,
+ +    literal_representation::UNUSUAL_BYTE_GROUPINGS,
+ +    loops::EMPTY_LOOP,
+ +    loops::EXPLICIT_COUNTER_LOOP,
+ +    loops::EXPLICIT_INTO_ITER_LOOP,
+ +    loops::EXPLICIT_ITER_LOOP,
+ +    loops::FOR_KV_MAP,
+ +    loops::FOR_LOOPS_OVER_FALLIBLES,
+ +    loops::ITER_NEXT_LOOP,
+ +    loops::MANUAL_FLATTEN,
+ +    loops::MANUAL_MEMCPY,
+ +    loops::MUT_RANGE_BOUND,
+ +    loops::NEEDLESS_COLLECT,
+ +    loops::NEEDLESS_RANGE_LOOP,
+ +    loops::NEVER_LOOP,
+ +    loops::SAME_ITEM_PUSH,
+ +    loops::SINGLE_ELEMENT_LOOP,
+ +    loops::WHILE_IMMUTABLE_CONDITION,
+ +    loops::WHILE_LET_LOOP,
+ +    loops::WHILE_LET_ON_ITERATOR,
+ +    macro_use::MACRO_USE_IMPORTS,
+ +    main_recursion::MAIN_RECURSION,
+ +    manual_assert::MANUAL_ASSERT,
+ +    manual_async_fn::MANUAL_ASYNC_FN,
+ +    manual_bits::MANUAL_BITS,
+ +    manual_map::MANUAL_MAP,
+ +    manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE,
+ +    manual_ok_or::MANUAL_OK_OR,
+ +    manual_strip::MANUAL_STRIP,
+ +    manual_unwrap_or::MANUAL_UNWRAP_OR,
+ +    map_clone::MAP_CLONE,
+ +    map_err_ignore::MAP_ERR_IGNORE,
+ +    map_unit_fn::OPTION_MAP_UNIT_FN,
+ +    map_unit_fn::RESULT_MAP_UNIT_FN,
+ +    match_on_vec_items::MATCH_ON_VEC_ITEMS,
+ +    match_result_ok::MATCH_RESULT_OK,
+ +    match_str_case_mismatch::MATCH_STR_CASE_MISMATCH,
+ +    matches::INFALLIBLE_DESTRUCTURING_MATCH,
+ +    matches::MATCH_AS_REF,
+ +    matches::MATCH_BOOL,
+ +    matches::MATCH_LIKE_MATCHES_MACRO,
+ +    matches::MATCH_OVERLAPPING_ARM,
+ +    matches::MATCH_REF_PATS,
+ +    matches::MATCH_SAME_ARMS,
+ +    matches::MATCH_SINGLE_BINDING,
+ +    matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
+ +    matches::MATCH_WILD_ERR_ARM,
+ +    matches::REDUNDANT_PATTERN_MATCHING,
+ +    matches::REST_PAT_IN_FULLY_BOUND_STRUCTS,
+ +    matches::SINGLE_MATCH,
+ +    matches::SINGLE_MATCH_ELSE,
+ +    matches::WILDCARD_ENUM_MATCH_ARM,
+ +    matches::WILDCARD_IN_OR_PATTERNS,
+ +    mem_forget::MEM_FORGET,
+ +    mem_replace::MEM_REPLACE_OPTION_WITH_NONE,
+ +    mem_replace::MEM_REPLACE_WITH_DEFAULT,
+ +    mem_replace::MEM_REPLACE_WITH_UNINIT,
+ +    methods::BIND_INSTEAD_OF_MAP,
+ +    methods::BYTES_NTH,
+ +    methods::CHARS_LAST_CMP,
+ +    methods::CHARS_NEXT_CMP,
+ +    methods::CLONED_INSTEAD_OF_COPIED,
+ +    methods::CLONE_DOUBLE_REF,
+ +    methods::CLONE_ON_COPY,
+ +    methods::CLONE_ON_REF_PTR,
+ +    methods::EXPECT_FUN_CALL,
+ +    methods::EXPECT_USED,
+ +    methods::EXTEND_WITH_DRAIN,
+ +    methods::FILETYPE_IS_FILE,
+ +    methods::FILTER_MAP_IDENTITY,
+ +    methods::FILTER_MAP_NEXT,
+ +    methods::FILTER_NEXT,
+ +    methods::FLAT_MAP_IDENTITY,
+ +    methods::FLAT_MAP_OPTION,
+ +    methods::FROM_ITER_INSTEAD_OF_COLLECT,
+ +    methods::GET_UNWRAP,
+ +    methods::IMPLICIT_CLONE,
+ +    methods::INEFFICIENT_TO_STRING,
+ +    methods::INSPECT_FOR_EACH,
+ +    methods::INTO_ITER_ON_REF,
+ +    methods::ITERATOR_STEP_BY_ZERO,
+ +    methods::ITER_CLONED_COLLECT,
+ +    methods::ITER_COUNT,
+ +    methods::ITER_NEXT_SLICE,
+ +    methods::ITER_NTH,
+ +    methods::ITER_NTH_ZERO,
++    methods::ITER_OVEREAGER_CLONED,
+ +    methods::ITER_SKIP_NEXT,
+ +    methods::MANUAL_FILTER_MAP,
+ +    methods::MANUAL_FIND_MAP,
+ +    methods::MANUAL_SATURATING_ARITHMETIC,
+ +    methods::MANUAL_SPLIT_ONCE,
+ +    methods::MANUAL_STR_REPEAT,
+ +    methods::MAP_COLLECT_RESULT_UNIT,
+ +    methods::MAP_FLATTEN,
+ +    methods::MAP_IDENTITY,
+ +    methods::MAP_UNWRAP_OR,
+ +    methods::NEEDLESS_SPLITN,
+ +    methods::NEW_RET_NO_SELF,
+ +    methods::OK_EXPECT,
+ +    methods::OPTION_AS_REF_DEREF,
+ +    methods::OPTION_FILTER_MAP,
+ +    methods::OPTION_MAP_OR_NONE,
+ +    methods::OR_FUN_CALL,
+ +    methods::RESULT_MAP_OR_INTO_OPTION,
+ +    methods::SEARCH_IS_SOME,
+ +    methods::SHOULD_IMPLEMENT_TRAIT,
+ +    methods::SINGLE_CHAR_ADD_STR,
+ +    methods::SINGLE_CHAR_PATTERN,
+ +    methods::SKIP_WHILE_NEXT,
+ +    methods::STRING_EXTEND_CHARS,
+ +    methods::SUSPICIOUS_MAP,
+ +    methods::SUSPICIOUS_SPLITN,
+ +    methods::UNINIT_ASSUMED_INIT,
+ +    methods::UNNECESSARY_FILTER_MAP,
+ +    methods::UNNECESSARY_FOLD,
+ +    methods::UNNECESSARY_LAZY_EVALUATIONS,
+ +    methods::UNNECESSARY_TO_OWNED,
+ +    methods::UNWRAP_OR_ELSE_DEFAULT,
+ +    methods::UNWRAP_USED,
+ +    methods::USELESS_ASREF,
+ +    methods::WRONG_SELF_CONVENTION,
+ +    methods::ZST_OFFSET,
+ +    minmax::MIN_MAX,
+ +    misc::CMP_NAN,
+ +    misc::CMP_OWNED,
+ +    misc::FLOAT_CMP,
+ +    misc::FLOAT_CMP_CONST,
+ +    misc::MODULO_ONE,
+ +    misc::SHORT_CIRCUIT_STATEMENT,
+ +    misc::TOPLEVEL_REF_ARG,
+ +    misc::USED_UNDERSCORE_BINDING,
+ +    misc::ZERO_PTR,
+ +    misc_early::BUILTIN_TYPE_SHADOW,
+ +    misc_early::DOUBLE_NEG,
+ +    misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
+ +    misc_early::MIXED_CASE_HEX_LITERALS,
+ +    misc_early::REDUNDANT_PATTERN,
+ +    misc_early::SEPARATED_LITERAL_SUFFIX,
+ +    misc_early::UNNEEDED_FIELD_PATTERN,
+ +    misc_early::UNNEEDED_WILDCARD_PATTERN,
+ +    misc_early::UNSEPARATED_LITERAL_SUFFIX,
+ +    misc_early::ZERO_PREFIXED_LITERAL,
+ +    missing_const_for_fn::MISSING_CONST_FOR_FN,
+ +    missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS,
+ +    missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES,
+ +    missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS,
+ +    module_style::MOD_MODULE_FILES,
+ +    module_style::SELF_NAMED_MODULE_FILES,
+ +    modulo_arithmetic::MODULO_ARITHMETIC,
+ +    multiple_crate_versions::MULTIPLE_CRATE_VERSIONS,
+ +    mut_key::MUTABLE_KEY_TYPE,
+ +    mut_mut::MUT_MUT,
+ +    mut_mutex_lock::MUT_MUTEX_LOCK,
+ +    mut_reference::UNNECESSARY_MUT_PASSED,
+ +    mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL,
+ +    mutex_atomic::MUTEX_ATOMIC,
+ +    mutex_atomic::MUTEX_INTEGER,
+ +    needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE,
+ +    needless_bitwise_bool::NEEDLESS_BITWISE_BOOL,
+ +    needless_bool::BOOL_COMPARISON,
+ +    needless_bool::NEEDLESS_BOOL,
+ +    needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE,
+ +    needless_continue::NEEDLESS_CONTINUE,
+ +    needless_for_each::NEEDLESS_FOR_EACH,
+ +    needless_late_init::NEEDLESS_LATE_INIT,
+ +    needless_option_as_deref::NEEDLESS_OPTION_AS_DEREF,
+ +    needless_pass_by_value::NEEDLESS_PASS_BY_VALUE,
+ +    needless_question_mark::NEEDLESS_QUESTION_MARK,
+ +    needless_update::NEEDLESS_UPDATE,
+ +    neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD,
+ +    neg_multiply::NEG_MULTIPLY,
+ +    new_without_default::NEW_WITHOUT_DEFAULT,
+ +    no_effect::NO_EFFECT,
+ +    no_effect::NO_EFFECT_UNDERSCORE_BINDING,
+ +    no_effect::UNNECESSARY_OPERATION,
+ +    non_copy_const::BORROW_INTERIOR_MUTABLE_CONST,
+ +    non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST,
+ +    non_expressive_names::JUST_UNDERSCORES_AND_DIGITS,
+ +    non_expressive_names::MANY_SINGLE_CHAR_NAMES,
+ +    non_expressive_names::SIMILAR_NAMES,
+ +    non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS,
+ +    non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY,
+ +    nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES,
+ +    octal_escapes::OCTAL_ESCAPES,
+ +    open_options::NONSENSICAL_OPEN_OPTIONS,
+ +    option_env_unwrap::OPTION_ENV_UNWRAP,
+ +    option_if_let_else::OPTION_IF_LET_ELSE,
+ +    overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL,
+ +    panic_in_result_fn::PANIC_IN_RESULT_FN,
+ +    panic_unimplemented::PANIC,
+ +    panic_unimplemented::TODO,
+ +    panic_unimplemented::UNIMPLEMENTED,
+ +    panic_unimplemented::UNREACHABLE,
+ +    partialeq_ne_impl::PARTIALEQ_NE_IMPL,
+ +    pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE,
+ +    pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF,
+ +    path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE,
+ +    pattern_type_mismatch::PATTERN_TYPE_MISMATCH,
+ +    precedence::PRECEDENCE,
+ +    ptr::CMP_NULL,
+ +    ptr::INVALID_NULL_PTR_USAGE,
+ +    ptr::MUT_FROM_REF,
+ +    ptr::PTR_ARG,
+ +    ptr_eq::PTR_EQ,
+ +    ptr_offset_with_cast::PTR_OFFSET_WITH_CAST,
+ +    question_mark::QUESTION_MARK,
+ +    ranges::MANUAL_RANGE_CONTAINS,
+ +    ranges::RANGE_MINUS_ONE,
+ +    ranges::RANGE_PLUS_ONE,
+ +    ranges::RANGE_ZIP_WITH_LEN,
+ +    ranges::REVERSED_EMPTY_RANGES,
+ +    redundant_clone::REDUNDANT_CLONE,
+ +    redundant_closure_call::REDUNDANT_CLOSURE_CALL,
+ +    redundant_else::REDUNDANT_ELSE,
+ +    redundant_field_names::REDUNDANT_FIELD_NAMES,
+ +    redundant_pub_crate::REDUNDANT_PUB_CRATE,
+ +    redundant_slicing::REDUNDANT_SLICING,
+ +    redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES,
+ +    ref_option_ref::REF_OPTION_REF,
+ +    reference::DEREF_ADDROF,
+ +    reference::REF_IN_DEREF,
+ +    regex::INVALID_REGEX,
+ +    regex::TRIVIAL_REGEX,
+ +    repeat_once::REPEAT_ONCE,
+ +    return_self_not_must_use::RETURN_SELF_NOT_MUST_USE,
+ +    returns::LET_AND_RETURN,
+ +    returns::NEEDLESS_RETURN,
+ +    same_name_method::SAME_NAME_METHOD,
+ +    self_assignment::SELF_ASSIGNMENT,
+ +    self_named_constructors::SELF_NAMED_CONSTRUCTORS,
+ +    semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED,
+ +    serde_api::SERDE_API_MISUSE,
+ +    shadow::SHADOW_REUSE,
+ +    shadow::SHADOW_SAME,
+ +    shadow::SHADOW_UNRELATED,
+ +    single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES,
+ +    single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS,
+ +    size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT,
+ +    slow_vector_initialization::SLOW_VECTOR_INITIALIZATION,
+ +    stable_sort_primitive::STABLE_SORT_PRIMITIVE,
+ +    strings::STRING_ADD,
+ +    strings::STRING_ADD_ASSIGN,
+ +    strings::STRING_FROM_UTF8_AS_BYTES,
+ +    strings::STRING_LIT_AS_BYTES,
+ +    strings::STRING_SLICE,
+ +    strings::STRING_TO_STRING,
+ +    strings::STR_TO_STRING,
+ +    strlen_on_c_strings::STRLEN_ON_C_STRINGS,
+ +    suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS,
+ +    suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL,
+ +    suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL,
+ +    swap::ALMOST_SWAPPED,
+ +    swap::MANUAL_SWAP,
+ +    tabs_in_doc_comments::TABS_IN_DOC_COMMENTS,
+ +    temporary_assignment::TEMPORARY_ASSIGNMENT,
+ +    to_digit_is_some::TO_DIGIT_IS_SOME,
+ +    to_string_in_display::TO_STRING_IN_DISPLAY,
+ +    trailing_empty_array::TRAILING_EMPTY_ARRAY,
+ +    trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS,
+ +    trait_bounds::TYPE_REPETITION_IN_BOUNDS,
+ +    transmute::CROSSPOINTER_TRANSMUTE,
+ +    transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+ +    transmute::TRANSMUTE_BYTES_TO_STR,
+ +    transmute::TRANSMUTE_FLOAT_TO_INT,
+ +    transmute::TRANSMUTE_INT_TO_BOOL,
+ +    transmute::TRANSMUTE_INT_TO_CHAR,
+ +    transmute::TRANSMUTE_INT_TO_FLOAT,
+ +    transmute::TRANSMUTE_NUM_TO_BYTES,
+ +    transmute::TRANSMUTE_PTR_TO_PTR,
+ +    transmute::TRANSMUTE_PTR_TO_REF,
+ +    transmute::UNSOUND_COLLECTION_TRANSMUTE,
+ +    transmute::USELESS_TRANSMUTE,
+ +    transmute::WRONG_TRANSMUTE,
+ +    transmuting_null::TRANSMUTING_NULL,
+ +    try_err::TRY_ERR,
+ +    types::BORROWED_BOX,
+ +    types::BOX_COLLECTION,
+ +    types::LINKEDLIST,
+ +    types::OPTION_OPTION,
+ +    types::RC_BUFFER,
+ +    types::RC_MUTEX,
+ +    types::REDUNDANT_ALLOCATION,
+ +    types::TYPE_COMPLEXITY,
+ +    types::VEC_BOX,
+ +    undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS,
+ +    undropped_manually_drops::UNDROPPED_MANUALLY_DROPS,
+ +    unicode::INVISIBLE_CHARACTERS,
+ +    unicode::NON_ASCII_LITERAL,
+ +    unicode::UNICODE_NOT_NFC,
+ +    uninit_vec::UNINIT_VEC,
+ +    unit_hash::UNIT_HASH,
+ +    unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD,
+ +    unit_types::LET_UNIT_VALUE,
+ +    unit_types::UNIT_ARG,
+ +    unit_types::UNIT_CMP,
+ +    unnamed_address::FN_ADDRESS_COMPARISONS,
+ +    unnamed_address::VTABLE_ADDRESS_COMPARISONS,
+ +    unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS,
+ +    unnecessary_sort_by::UNNECESSARY_SORT_BY,
+ +    unnecessary_wraps::UNNECESSARY_WRAPS,
+ +    unnested_or_patterns::UNNESTED_OR_PATTERNS,
+ +    unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME,
+ +    unused_async::UNUSED_ASYNC,
+ +    unused_io_amount::UNUSED_IO_AMOUNT,
+ +    unused_self::UNUSED_SELF,
+ +    unused_unit::UNUSED_UNIT,
+ +    unwrap::PANICKING_UNWRAP,
+ +    unwrap::UNNECESSARY_UNWRAP,
+ +    unwrap_in_result::UNWRAP_IN_RESULT,
+ +    upper_case_acronyms::UPPER_CASE_ACRONYMS,
+ +    use_self::USE_SELF,
+ +    useless_conversion::USELESS_CONVERSION,
+ +    vec::USELESS_VEC,
+ +    vec_init_then_push::VEC_INIT_THEN_PUSH,
+ +    vec_resize_to_zero::VEC_RESIZE_TO_ZERO,
+ +    verbose_file_reads::VERBOSE_FILE_READS,
+ +    wildcard_dependencies::WILDCARD_DEPENDENCIES,
+ +    wildcard_imports::ENUM_GLOB_USE,
+ +    wildcard_imports::WILDCARD_IMPORTS,
+ +    write::PRINTLN_EMPTY_STRING,
+ +    write::PRINT_LITERAL,
+ +    write::PRINT_STDERR,
+ +    write::PRINT_STDOUT,
+ +    write::PRINT_WITH_NEWLINE,
+ +    write::USE_DEBUG,
+ +    write::WRITELN_EMPTY_STRING,
+ +    write::WRITE_LITERAL,
+ +    write::WRITE_WITH_NEWLINE,
+ +    zero_div_zero::ZERO_DIVIDED_BY_ZERO,
+ +    zero_sized_map_values::ZERO_SIZED_MAP_VALUES,
+ +])
diff --cc src/tools/clippy/clippy_lints/src/lib.register_pedantic.rs

index 1744b7c825078e40ed37210384bb3cda7a4d0409,0000000000000000000000000000000000000000..1292675f4a96cde9b178869674b143c6e5038907

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.register_pedantic.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.register_pedantic.rs
@@@ -1,100 -1,0 +1,101 @@@
+ +// This file was generated by `cargo dev update_lints`.
+ +// Use that command to update this file and do not edit by hand.
+ +// Manual edits will be overwritten.
+ +
+ +store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![
+ +    LintId::of(attrs::INLINE_ALWAYS),
+ +    LintId::of(await_holding_invalid::AWAIT_HOLDING_LOCK),
+ +    LintId::of(await_holding_invalid::AWAIT_HOLDING_REFCELL_REF),
+ +    LintId::of(bit_mask::VERBOSE_BIT_MASK),
+ +    LintId::of(borrow_as_ptr::BORROW_AS_PTR),
+ +    LintId::of(bytecount::NAIVE_BYTECOUNT),
+ +    LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS),
+ +    LintId::of(casts::CAST_LOSSLESS),
+ +    LintId::of(casts::CAST_POSSIBLE_TRUNCATION),
+ +    LintId::of(casts::CAST_POSSIBLE_WRAP),
+ +    LintId::of(casts::CAST_PRECISION_LOSS),
+ +    LintId::of(casts::CAST_PTR_ALIGNMENT),
+ +    LintId::of(casts::CAST_SIGN_LOSS),
+ +    LintId::of(casts::PTR_AS_PTR),
+ +    LintId::of(checked_conversions::CHECKED_CONVERSIONS),
+ +    LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION),
+ +    LintId::of(copy_iterator::COPY_ITERATOR),
+ +    LintId::of(default::DEFAULT_TRAIT_ACCESS),
+ +    LintId::of(dereference::EXPLICIT_DEREF_METHODS),
+ +    LintId::of(dereference::REF_BINDING_TO_REFERENCE),
+ +    LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY),
+ +    LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE),
+ +    LintId::of(doc::DOC_MARKDOWN),
+ +    LintId::of(doc::MISSING_ERRORS_DOC),
+ +    LintId::of(doc::MISSING_PANICS_DOC),
+ +    LintId::of(empty_enum::EMPTY_ENUM),
+ +    LintId::of(enum_variants::MODULE_NAME_REPETITIONS),
+ +    LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS),
+ +    LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS),
+ +    LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS),
+ +    LintId::of(functions::MUST_USE_CANDIDATE),
+ +    LintId::of(functions::TOO_MANY_LINES),
+ +    LintId::of(if_not_else::IF_NOT_ELSE),
+ +    LintId::of(implicit_hasher::IMPLICIT_HASHER),
+ +    LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB),
+ +    LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR),
+ +    LintId::of(infinite_iter::MAYBE_INFINITE_ITER),
+ +    LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS),
+ +    LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS),
+ +    LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR),
+ +    LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS),
+ +    LintId::of(let_underscore::LET_UNDERSCORE_DROP),
+ +    LintId::of(literal_representation::LARGE_DIGIT_GROUPS),
+ +    LintId::of(literal_representation::UNREADABLE_LITERAL),
+ +    LintId::of(loops::EXPLICIT_INTO_ITER_LOOP),
+ +    LintId::of(loops::EXPLICIT_ITER_LOOP),
+ +    LintId::of(macro_use::MACRO_USE_IMPORTS),
+ +    LintId::of(manual_assert::MANUAL_ASSERT),
+ +    LintId::of(manual_ok_or::MANUAL_OK_OR),
+ +    LintId::of(match_on_vec_items::MATCH_ON_VEC_ITEMS),
+ +    LintId::of(matches::MATCH_BOOL),
+ +    LintId::of(matches::MATCH_SAME_ARMS),
+ +    LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS),
+ +    LintId::of(matches::MATCH_WILD_ERR_ARM),
+ +    LintId::of(matches::SINGLE_MATCH_ELSE),
+ +    LintId::of(methods::CLONED_INSTEAD_OF_COPIED),
+ +    LintId::of(methods::FILTER_MAP_NEXT),
+ +    LintId::of(methods::FLAT_MAP_OPTION),
+ +    LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT),
+ +    LintId::of(methods::IMPLICIT_CLONE),
+ +    LintId::of(methods::INEFFICIENT_TO_STRING),
+ +    LintId::of(methods::MAP_UNWRAP_OR),
+ +    LintId::of(misc::FLOAT_CMP),
+ +    LintId::of(misc::USED_UNDERSCORE_BINDING),
+ +    LintId::of(mut_mut::MUT_MUT),
+ +    LintId::of(needless_bitwise_bool::NEEDLESS_BITWISE_BOOL),
+ +    LintId::of(needless_continue::NEEDLESS_CONTINUE),
+ +    LintId::of(needless_for_each::NEEDLESS_FOR_EACH),
+ +    LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE),
+ +    LintId::of(no_effect::NO_EFFECT_UNDERSCORE_BINDING),
+ +    LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES),
+ +    LintId::of(non_expressive_names::SIMILAR_NAMES),
+ +    LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE),
+ +    LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF),
+ +    LintId::of(ranges::RANGE_MINUS_ONE),
+ +    LintId::of(ranges::RANGE_PLUS_ONE),
+ +    LintId::of(redundant_else::REDUNDANT_ELSE),
+ +    LintId::of(ref_option_ref::REF_OPTION_REF),
++    LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
+ +    LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED),
+ +    LintId::of(strings::STRING_ADD_ASSIGN),
+ +    LintId::of(trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS),
+ +    LintId::of(trait_bounds::TYPE_REPETITION_IN_BOUNDS),
+ +    LintId::of(transmute::TRANSMUTE_PTR_TO_PTR),
+ +    LintId::of(types::LINKEDLIST),
+ +    LintId::of(types::OPTION_OPTION),
+ +    LintId::of(unicode::UNICODE_NOT_NFC),
+ +    LintId::of(unit_types::LET_UNIT_VALUE),
+ +    LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS),
+ +    LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS),
+ +    LintId::of(unused_async::UNUSED_ASYNC),
+ +    LintId::of(unused_self::UNUSED_SELF),
+ +    LintId::of(wildcard_imports::ENUM_GLOB_USE),
+ +    LintId::of(wildcard_imports::WILDCARD_IMPORTS),
+ +    LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES),
+ +])
diff --cc src/tools/clippy/clippy_lints/src/lib.register_perf.rs

index f9ffd4cf829fa220ac198750eedf317b4ba93916,0000000000000000000000000000000000000000..c44ef124bfa0ea3bcb1130283606736cc08ebbef

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.register_perf.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.register_perf.rs
@@@ -1,29 -1,0 +1,30 @@@
+ +// This file was generated by `cargo dev update_lints`.
+ +// Use that command to update this file and do not edit by hand.
+ +// Manual edits will be overwritten.
+ +
+ +store.register_group(true, "clippy::perf", Some("clippy_perf"), vec![
+ +    LintId::of(entry::MAP_ENTRY),
+ +    LintId::of(escape::BOXED_LOCAL),
+ +    LintId::of(format_args::FORMAT_IN_FORMAT_ARGS),
+ +    LintId::of(format_args::TO_STRING_IN_FORMAT_ARGS),
+ +    LintId::of(large_const_arrays::LARGE_CONST_ARRAYS),
+ +    LintId::of(large_enum_variant::LARGE_ENUM_VARIANT),
+ +    LintId::of(loops::MANUAL_MEMCPY),
+ +    LintId::of(loops::NEEDLESS_COLLECT),
+ +    LintId::of(methods::EXPECT_FUN_CALL),
+ +    LintId::of(methods::EXTEND_WITH_DRAIN),
+ +    LintId::of(methods::ITER_NTH),
++    LintId::of(methods::ITER_OVEREAGER_CLONED),
+ +    LintId::of(methods::MANUAL_STR_REPEAT),
+ +    LintId::of(methods::OR_FUN_CALL),
+ +    LintId::of(methods::SINGLE_CHAR_PATTERN),
+ +    LintId::of(methods::UNNECESSARY_TO_OWNED),
+ +    LintId::of(misc::CMP_OWNED),
+ +    LintId::of(redundant_clone::REDUNDANT_CLONE),
+ +    LintId::of(slow_vector_initialization::SLOW_VECTOR_INITIALIZATION),
+ +    LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE),
+ +    LintId::of(types::BOX_COLLECTION),
+ +    LintId::of(types::REDUNDANT_ALLOCATION),
+ +    LintId::of(vec::USELESS_VEC),
+ +    LintId::of(vec_init_then_push::VEC_INIT_THEN_PUSH),
+ +])
diff --cc src/tools/clippy/clippy_lints/src/lib.register_suspicious.rs

index 8594338ffa5ab5558dfb2ae26a4eb7f6e831f08a,0000000000000000000000000000000000000000..10f8ae4b7f7fca8583cde6a976955579a3efc4e1

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.register_suspicious.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.register_suspicious.rs
@@@ -1,22 -1,0 +1,21 @@@
-     LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE),
+ +// This file was generated by `cargo dev update_lints`.
+ +// Use that command to update this file and do not edit by hand.
+ +// Manual edits will be overwritten.
+ +
+ +store.register_group(true, "clippy::suspicious", Some("clippy_suspicious"), vec![
+ +    LintId::of(assign_ops::MISREFACTORED_ASSIGN_OP),
+ +    LintId::of(attrs::BLANKET_CLIPPY_RESTRICTION_LINTS),
+ +    LintId::of(eval_order_dependence::EVAL_ORDER_DEPENDENCE),
+ +    LintId::of(float_equality_without_abs::FLOAT_EQUALITY_WITHOUT_ABS),
+ +    LintId::of(formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING),
+ +    LintId::of(formatting::SUSPICIOUS_ELSE_FORMATTING),
+ +    LintId::of(formatting::SUSPICIOUS_UNARY_OP_FORMATTING),
+ +    LintId::of(loops::EMPTY_LOOP),
+ +    LintId::of(loops::FOR_LOOPS_OVER_FALLIBLES),
+ +    LintId::of(loops::MUT_RANGE_BOUND),
+ +    LintId::of(methods::SUSPICIOUS_MAP),
+ +    LintId::of(mut_key::MUTABLE_KEY_TYPE),
+ +    LintId::of(octal_escapes::OCTAL_ESCAPES),
+ +    LintId::of(suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL),
+ +    LintId::of(suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL),
+ +])
diff --cc src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs

index 90492ffda3cc6e626706dde8ee340b459ff7bd38,0000000000000000000000000000000000000000..865e7702b7151567bb0e12da002d1265b2b77301

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs
@@@ -1,51 -1,0 +1,60 @@@
- use rustc_span::{sym, Span};
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::source::snippet_with_context;
++use clippy_utils::ty::peel_mid_ty_refs;
+ +use clippy_utils::{is_diag_item_method, is_diag_trait_item};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir as hir;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::TyS;
- pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, span: Span) {
++use rustc_span::sym;
+ +
+ +use super::IMPLICIT_CLONE;
+ +
-         let input_type = cx.typeck_results().expr_ty(recv).peel_refs();
++pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+ +    if_chain! {
+ +        if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+ +        if is_clone_like(cx, method_name, method_def_id);
+ +        let return_type = cx.typeck_results().expr_ty(expr);
-                 span,
++        let input_type = cx.typeck_results().expr_ty(recv);
++        let (input_type, ref_count) = peel_mid_ty_refs(input_type);
+ +        if let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did));
+ +        if TyS::same_type(return_type, input_type);
+ +        then {
++            let mut app = Applicability::MachineApplicable;
++            let recv_snip = snippet_with_context(cx, recv.span, expr.span.ctxt(), "..", &mut app).0;
+ +            span_lint_and_sugg(
+ +                cx,
+ +                IMPLICIT_CLONE,
-                 "clone".to_string(),
-                 Applicability::MachineApplicable
++                expr.span,
+ +                &format!("implicitly cloning a `{}` by calling `{}` on its dereferenced type", ty_name, method_name),
+ +                "consider using",
++                if ref_count > 1 {
++                    format!("({}{}).clone()", "*".repeat(ref_count - 1), recv_snip)
++                } else {
++                    format!("{}.clone()", recv_snip)
++                },
++                app,
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +/// Returns true if the named method can be used to clone the receiver.
+ +/// Note that `to_string` is not flagged by `implicit_clone`. So other lints that call
+ +/// `is_clone_like` and that do flag `to_string` must handle it separately. See, e.g.,
+ +/// `is_to_owned_like` in `unnecessary_to_owned.rs`.
+ +pub fn is_clone_like(cx: &LateContext<'_>, method_name: &str, method_def_id: hir::def_id::DefId) -> bool {
+ +    match method_name {
+ +        "to_os_string" => is_diag_item_method(cx, method_def_id, sym::OsStr),
+ +        "to_owned" => is_diag_trait_item(cx, method_def_id, sym::ToOwned),
+ +        "to_path_buf" => is_diag_item_method(cx, method_def_id, sym::Path),
+ +        "to_vec" => {
+ +            cx.tcx
+ +                .impl_of_method(method_def_id)
+ +                .map(|impl_did| Some(impl_did) == cx.tcx.lang_items().slice_alloc_impl())
+ +                == Some(true)
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..ca33bfc643da84a5d3a669eaa163c6fcd718e2df

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs
@@@ -1,0 -1,0 +1,62 @@@
++use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::source::snippet;
++use clippy_utils::ty::{get_iterator_item_ty, is_copy};
++use itertools::Itertools;
++use rustc_errors::Applicability;
++use rustc_hir as hir;
++use rustc_lint::LateContext;
++use rustc_middle::ty;
++use std::ops::Not;
++
++use super::ITER_OVEREAGER_CLONED;
++use crate::redundant_clone::REDUNDANT_CLONE;
++
++/// lint overeager use of `cloned()` for `Iterator`s
++pub(super) fn check<'tcx>(
++    cx: &LateContext<'tcx>,
++    expr: &'tcx hir::Expr<'_>,
++    recv: &'tcx hir::Expr<'_>,
++    name: &str,
++    map_arg: &[hir::Expr<'_>],
++) {
++    // Check if it's iterator and get type associated with `Item`.
++    let inner_ty = match get_iterator_item_ty(cx, cx.typeck_results().expr_ty_adjusted(recv)) {
++        Some(ty) => ty,
++        _ => return,
++    };
++
++    match inner_ty.kind() {
++        ty::Ref(_, ty, _) if !is_copy(cx, ty) => {},
++        _ => return,
++    };
++
++    let (lint, preserve_cloned) = match name {
++        "count" => (REDUNDANT_CLONE, false),
++        _ => (ITER_OVEREAGER_CLONED, true),
++    };
++    let wildcard_params = map_arg.is_empty().not().then(|| "...").unwrap_or_default();
++    let msg = format!(
++        "called `cloned().{}({})` on an `Iterator`. It may be more efficient to call `{}({}){}` instead",
++        name,
++        wildcard_params,
++        name,
++        wildcard_params,
++        preserve_cloned.then(|| ".cloned()").unwrap_or_default(),
++    );
++
++    span_lint_and_sugg(
++        cx,
++        lint,
++        expr.span,
++        &msg,
++        "try this",
++        format!(
++            "{}.{}({}){}",
++            snippet(cx, recv.span, ".."),
++            name,
++            map_arg.iter().map(|a| snippet(cx, a.span, "..")).join(", "),
++            preserve_cloned.then(|| ".cloned()").unwrap_or_default(),
++        ),
++        Applicability::MachineApplicable,
++    );
++}
diff --cc src/tools/clippy/clippy_lints/src/methods/mod.rs

index ed5136e7d00ff1cbe7c0643f06062916840ed42c,0000000000000000000000000000000000000000..7357219f7b47c70c763a6e9778c51d84b905ba47

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/mod.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs
@@@ -1,2593 -1,0 +1,2647 @@@
-             ("count", []) => match method_call(recv) {
-                 Some((name @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
-                     iter_count::check(cx, expr, recv2, name);
+ +mod bind_instead_of_map;
+ +mod bytes_nth;
+ +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 clone_on_copy;
+ +mod clone_on_ref_ptr;
+ +mod cloned_instead_of_copied;
+ +mod expect_fun_call;
+ +mod expect_used;
+ +mod extend_with_drain;
+ +mod filetype_is_file;
+ +mod filter_map;
+ +mod filter_map_identity;
+ +mod filter_map_next;
+ +mod filter_next;
+ +mod flat_map_identity;
+ +mod flat_map_option;
+ +mod from_iter_instead_of_collect;
+ +mod get_unwrap;
+ +mod implicit_clone;
+ +mod inefficient_to_string;
+ +mod inspect_for_each;
+ +mod into_iter_on_ref;
+ +mod iter_cloned_collect;
+ +mod iter_count;
+ +mod iter_next_slice;
+ +mod iter_nth;
+ +mod iter_nth_zero;
++mod iter_overeager_cloned;
+ +mod iter_skip_next;
+ +mod iterator_step_by_zero;
+ +mod manual_saturating_arithmetic;
+ +mod manual_str_repeat;
+ +mod map_collect_result_unit;
+ +mod map_flatten;
+ +mod map_identity;
+ +mod map_unwrap_or;
+ +mod ok_expect;
+ +mod option_as_ref_deref;
+ +mod option_map_or_none;
+ +mod option_map_unwrap_or;
+ +mod or_fun_call;
+ +mod search_is_some;
+ +mod single_char_add_str;
+ +mod single_char_insert_string;
+ +mod single_char_pattern;
+ +mod single_char_push_string;
+ +mod skip_while_next;
+ +mod str_splitn;
+ +mod string_extend_chars;
+ +mod suspicious_map;
+ +mod suspicious_splitn;
+ +mod uninit_assumed_init;
+ +mod unnecessary_filter_map;
+ +mod unnecessary_fold;
+ +mod unnecessary_iter_cloned;
+ +mod unnecessary_lazy_eval;
+ +mod unnecessary_to_owned;
+ +mod unwrap_or_else_default;
+ +mod unwrap_used;
+ +mod useless_asref;
+ +mod utils;
+ +mod wrong_self_convention;
+ +mod zst_offset;
+ +
+ +use bind_instead_of_map::BindInsteadOfMap;
+ +use clippy_utils::consts::{constant, Constant};
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+ +use clippy_utils::ty::{contains_adt_constructor, contains_ty, implements_trait, is_copy, is_type_diagnostic_item};
+ +use clippy_utils::{contains_return, get_trait_def_id, iter_input_pats, meets_msrv, msrvs, paths, return_ty};
+ +use if_chain::if_chain;
+ +use rustc_hir as hir;
+ +use rustc_hir::def::Res;
+ +use rustc_hir::{Expr, ExprKind, PrimTy, QPath, TraitItem, TraitItemKind};
+ +use rustc_lint::{LateContext, LateLintPass, LintContext};
+ +use rustc_middle::lint::in_external_macro;
+ +use rustc_middle::ty::{self, TraitRef, Ty, TyS};
+ +use rustc_semver::RustcVersion;
+ +use rustc_session::{declare_tool_lint, impl_lint_pass};
+ +use rustc_span::{sym, Span};
+ +use rustc_typeck::hir_ty_to_ty;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usages 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
+ +    /// ```rust
+ +    /// [1, 2, 3].iter().cloned();
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// [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 usage of `_.cloned().<func>()` where call to `.cloned()` can be postponed.
++    ///
++    /// ### Why is this bad?
++    /// It's often inefficient to clone all elements of an iterator, when eventually, only some
++    /// of them will be consumed.
++    ///
++    /// ### Examples
++    /// ```rust
++    /// # let vec = vec!["string".to_string()];
++    ///
++    /// // Bad
++    /// vec.iter().cloned().take(10);
++    ///
++    /// // Good
++    /// vec.iter().take(10).cloned();
++    ///
++    /// // Bad
++    /// vec.iter().cloned().last();
++    ///
++    /// // Good
++    /// vec.iter().last().cloned();
++    ///
++    /// ```
++    /// ### Known Problems
++    /// This `lint` removes the side of effect of cloning items in the iterator.
++    /// A code that relies on that side-effect could fail.
++    ///
++    #[clippy::version = "1.59.0"]
++    pub ITER_OVEREAGER_CLONED,
++    perf,
++    "using `cloned()` early with `Iterator::iter()` can lead to some performance inefficiencies"
++}
++
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usages of `Iterator::flat_map()` where `filter_map()` could be
+ +    /// used instead.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// When applicable, `filter_map()` is more clear since it shows that
+ +    /// `Option` is used to produce 0 or 1 items.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let nums: Vec<i32> = ["1", "2", "whee!"].iter().flat_map(|x| x.parse().ok()).collect();
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// 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 `.unwrap()` calls on `Option`s and on `Result`s.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It is better to handle the `None` or `Err` case,
+ +    /// or at least call `.expect(_)` with a more helpful message. Still, for a lot of
+ +    /// quick-and-dirty code, `unwrap` is a good choice, which is why this lint is
+ +    /// `Allow` by default.
+ +    ///
+ +    /// `result.unwrap()` will let the thread panic on `Err` values.
+ +    /// Normally, you want to implement more sophisticated error handling,
+ +    /// and propagate errors upwards with `?` operator.
+ +    ///
+ +    /// Even if you want to panic on errors, not all `Error`s implement good
+ +    /// messages on display. Therefore, it may be beneficial to look at the places
+ +    /// where they may get displayed. Activate this lint to do just that.
+ +    ///
+ +    /// ### Examples
+ +    /// ```rust
+ +    /// # let opt = Some(1);
+ +    ///
+ +    /// // Bad
+ +    /// opt.unwrap();
+ +    ///
+ +    /// // Good
+ +    /// opt.expect("more helpful message");
+ +    /// ```
+ +    ///
+ +    /// // or
+ +    ///
+ +    /// ```rust
+ +    /// # let res: Result<usize, ()> = Ok(1);
+ +    ///
+ +    /// // Bad
+ +    /// res.unwrap();
+ +    ///
+ +    /// // Good
+ +    /// res.expect("more helpful message");
+ +    /// ```
+ +    #[clippy::version = "1.45.0"]
+ +    pub UNWRAP_USED,
+ +    restriction,
+ +    "using `.unwrap()` on `Result` or `Option`, which should at least get a better message using `expect()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `.expect()` calls on `Option`s and `Result`s.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// 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 opt = Some(1);
+ +    ///
+ +    /// // Bad
+ +    /// opt.expect("one");
+ +    ///
+ +    /// // Good
+ +    /// let opt = Some(1);
+ +    /// opt?;
+ +    /// ```
+ +    ///
+ +    /// // or
+ +    ///
+ +    /// ```rust
+ +    /// # let res: Result<usize, ()> = Ok(1);
+ +    ///
+ +    /// // Bad
+ +    /// res.expect("one");
+ +    ///
+ +    /// // Good
+ +    /// res?;
+ +    /// # Ok::<(), ()>(())
+ +    /// ```
+ +    #[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 methods that should live in a trait
+ +    /// implementation of a `std` trait (see [llogiq's blog
+ +    /// post](http://llogiq.github.io/2015/07/30/traits.html) for further
+ +    /// information) instead of an inherent implementation.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Implementing the traits improve ergonomics for users of
+ +    /// the code, often with very little cost. Also people seeing a `mul(...)`
+ +    /// method
+ +    /// may expect `*` to work equally, so you should have good reason to disappoint
+ +    /// them.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// struct X;
+ +    /// impl X {
+ +    ///     fn add(&self, other: &X) -> X {
+ +    ///         // ..
+ +    /// # X
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub SHOULD_IMPLEMENT_TRAIT,
+ +    style,
+ +    "defining a method that should be implementing a std trait"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for methods with certain name prefixes and which
+ +    /// doesn't match how self is taken. The actual rules are:
+ +    ///
+ +    /// |Prefix |Postfix     |`self` taken           | `self` type  |
+ +    /// |-------|------------|-----------------------|--------------|
+ +    /// |`as_`  | none       |`&self` or `&mut self` | any          |
+ +    /// |`from_`| none       | none                  | any          |
+ +    /// |`into_`| none       |`self`                 | any          |
+ +    /// |`is_`  | none       |`&self` or none        | any          |
+ +    /// |`to_`  | `_mut`     |`&mut self`            | any          |
+ +    /// |`to_`  | not `_mut` |`self`                 | `Copy`       |
+ +    /// |`to_`  | not `_mut` |`&self`                | not `Copy`   |
+ +    ///
+ +    /// Note: Clippy doesn't trigger methods with `to_` prefix in:
+ +    /// - Traits definition.
+ +    /// Clippy can not tell if a type that implements a trait is `Copy` or not.
+ +    /// - Traits implementation, when `&self` is taken.
+ +    /// The method signature is controlled by the trait and often `&self` is required for all types that implement the trait
+ +    /// (see e.g. the `std::string::ToString` trait).
+ +    ///
+ +    /// Clippy allows `Pin<&Self>` and `Pin<&mut Self>` if `&self` and `&mut self` is required.
+ +    ///
+ +    /// Please find more info here:
+ +    /// https://rust-lang.github.io/api-guidelines/naming.html#ad-hoc-conversions-follow-as_-to_-into_-conventions-c-conv
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Consistency breeds readability. If you follow the
+ +    /// conventions, your users won't be surprised that they, e.g., need to supply a
+ +    /// mutable reference to a `as_..` function.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # struct X;
+ +    /// impl X {
+ +    ///     fn as_str(self) -> &'static str {
+ +    ///         // ..
+ +    /// # ""
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub WRONG_SELF_CONVENTION,
+ +    style,
+ +    "defining a method named with an established prefix (like \"into_\") that takes `self` with the wrong convention"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `ok().expect(..)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Because you usually call `expect()` on the `Result`
+ +    /// directly to get a better error message.
+ +    ///
+ +    /// ### Known problems
+ +    /// The error type needs to implement `Debug`
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = Ok::<_, ()>(());
+ +    ///
+ +    /// // Bad
+ +    /// x.ok().expect("why did I do this again?");
+ +    ///
+ +    /// // Good
+ +    /// x.expect("why did I do this again?");
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub OK_EXPECT,
+ +    style,
+ +    "using `ok().expect()`, which gives worse error messages than calling `expect` directly on the Result"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usages of `_.unwrap_or_else(Default::default)` on `Option` and
+ +    /// `Result` values.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, these can be written as `_.unwrap_or_default`, which is
+ +    /// simpler and more concise.
+ +    ///
+ +    /// ### Examples
+ +    /// ```rust
+ +    /// # let x = Some(1);
+ +    ///
+ +    /// // Bad
+ +    /// x.unwrap_or_else(Default::default);
+ +    /// x.unwrap_or_else(u32::default);
+ +    ///
+ +    /// // Good
+ +    /// x.unwrap_or_default();
+ +    /// ```
+ +    #[clippy::version = "1.56.0"]
+ +    pub UNWRAP_OR_ELSE_DEFAULT,
+ +    style,
+ +    "using `.unwrap_or_else(Default::default)`, which is more succinctly expressed as `.unwrap_or_default()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `option.map(_).unwrap_or(_)` or `option.map(_).unwrap_or_else(_)` or
+ +    /// `result.map(_).unwrap_or_else(_)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, these can be written more concisely (resp.) as
+ +    /// `option.map_or(_, _)`, `option.map_or_else(_, _)` and `result.map_or_else(_, _)`.
+ +    ///
+ +    /// ### Known problems
+ +    /// The order of the arguments is not in execution order
+ +    ///
+ +    /// ### Examples
+ +    /// ```rust
+ +    /// # let x = Some(1);
+ +    ///
+ +    /// // Bad
+ +    /// x.map(|a| a + 1).unwrap_or(0);
+ +    ///
+ +    /// // Good
+ +    /// x.map_or(0, |a| a + 1);
+ +    /// ```
+ +    ///
+ +    /// // or
+ +    ///
+ +    /// ```rust
+ +    /// # let x: Result<usize, ()> = Ok(1);
+ +    /// # fn some_function(foo: ()) -> usize { 1 }
+ +    ///
+ +    /// // Bad
+ +    /// x.map(|a| a + 1).unwrap_or_else(some_function);
+ +    ///
+ +    /// // Good
+ +    /// x.map_or_else(some_function, |a| a + 1);
+ +    /// ```
+ +    #[clippy::version = "1.45.0"]
+ +    pub MAP_UNWRAP_OR,
+ +    pedantic,
+ +    "using `.map(f).unwrap_or(a)` or `.map(f).unwrap_or_else(func)`, which are more succinctly expressed as `map_or(a, f)` or `map_or_else(a, f)`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `_.map_or(None, _)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely as
+ +    /// `_.and_then(_)`.
+ +    ///
+ +    /// ### Known problems
+ +    /// The order of the arguments is not in execution order.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let opt = Some(1);
+ +    ///
+ +    /// // Bad
+ +    /// opt.map_or(None, |a| Some(a + 1));
+ +    ///
+ +    /// // Good
+ +    /// opt.and_then(|a| Some(a + 1));
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub OPTION_MAP_OR_NONE,
+ +    style,
+ +    "using `Option.map_or(None, f)`, which is more succinctly expressed as `and_then(f)`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `_.map_or(None, Some)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely as
+ +    /// `_.ok()`.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust
+ +    /// # let r: Result<u32, &str> = Ok(1);
+ +    /// assert_eq!(Some(1), r.map_or(None, Some));
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust
+ +    /// # let r: Result<u32, &str> = Ok(1);
+ +    /// assert_eq!(Some(1), r.ok());
+ +    /// ```
+ +    #[clippy::version = "1.44.0"]
+ +    pub RESULT_MAP_OR_INTO_OPTION,
+ +    style,
+ +    "using `Result.map_or(None, Some)`, which is more succinctly expressed as `ok()`"
+ +}
+ +
+ +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?
+ +    /// Readability, this can be written more concisely as
+ +    /// `_.map(|x| y)` or `_.map_err(|x| y)`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # 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:
+ +    ///
+ +    /// ```rust
+ +    /// # 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
+ +    /// Checks for usage of `_.filter(_).next()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely as
+ +    /// `_.find(_)`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let vec = vec![1];
+ +    /// vec.iter().filter(|x| **x == 0).next();
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust
+ +    /// # 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 `_.skip_while(condition).next()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely as
+ +    /// `_.find(!condition)`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let vec = vec![1];
+ +    /// vec.iter().skip_while(|x| **x == 0).next();
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust
+ +    /// # let vec = vec![1];
+ +    /// vec.iter().find(|x| **x != 0);
+ +    /// ```
+ +    #[clippy::version = "1.42.0"]
+ +    pub SKIP_WHILE_NEXT,
+ +    complexity,
+ +    "using `skip_while(p).next()`, which is more succinctly expressed as `.find(!p)`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `_.map(_).flatten(_)` on `Iterator` and `Option`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely as
+ +    /// `_.flat_map(_)`
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let vec = vec![vec![1]];
+ +    ///
+ +    /// // Bad
+ +    /// vec.iter().map(|x| x.iter()).flatten();
+ +    ///
+ +    /// // Good
+ +    /// vec.iter().flat_map(|x| x.iter());
+ +    /// ```
+ +    #[clippy::version = "1.31.0"]
+ +    pub MAP_FLATTEN,
+ +    complexity,
+ +    "using combinations of `flatten` and `map` which can usually be written as a single method call"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `_.filter(_).map(_)` that can be written more simply
+ +    /// as `filter_map(_)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Redundant code in the `filter` and `map` operations is poor style and
+ +    /// less performant.
+ +    ///
+ +     /// ### Example
+ +    /// Bad:
+ +    /// ```rust
+ +    /// (0_i32..10)
+ +    ///     .filter(|n| n.checked_add(1).is_some())
+ +    ///     .map(|n| n.checked_add(1).unwrap());
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust
+ +    /// (0_i32..10).filter_map(|n| n.checked_add(1));
+ +    /// ```
+ +    #[clippy::version = "1.51.0"]
+ +    pub MANUAL_FILTER_MAP,
+ +    complexity,
+ +    "using `_.filter(_).map(_)` in a way that can be written more simply as `filter_map(_)`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `_.find(_).map(_)` that can be written more simply
+ +    /// as `find_map(_)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Redundant code in the `find` and `map` operations is poor style and
+ +    /// less performant.
+ +    ///
+ +     /// ### Example
+ +    /// Bad:
+ +    /// ```rust
+ +    /// (0_i32..10)
+ +    ///     .find(|n| n.checked_add(1).is_some())
+ +    ///     .map(|n| n.checked_add(1).unwrap());
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust
+ +    /// (0_i32..10).find_map(|n| n.checked_add(1));
+ +    /// ```
+ +    #[clippy::version = "1.51.0"]
+ +    pub MANUAL_FIND_MAP,
+ +    complexity,
+ +    "using `_.find(_).map(_)` in a way that can be written more simply as `find_map(_)`"
+ +}
+ +
+ +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
+ +    /// ```rust
+ +    ///  (0..3).filter_map(|x| if x == 2 { Some(x) } else { None }).next();
+ +    /// ```
+ +    /// Can be written as
+ +    ///
+ +    /// ```rust
+ +    ///  (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 `flat_map(|x| x)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely by using `flatten`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let iter = vec![vec![0]].into_iter();
+ +    /// iter.flat_map(|x| x);
+ +    /// ```
+ +    /// Can be written as
+ +    /// ```rust
+ +    /// # 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 an iterator or string search (such as `find()`,
+ +    /// `position()`, or `rposition()`) followed by a call to `is_some()` or `is_none()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely as:
+ +    /// * `_.any(_)`, or `_.contains(_)` for `is_some()`,
+ +    /// * `!_.any(_)`, or `!_.contains(_)` for `is_none()`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let vec = vec![1];
+ +    /// vec.iter().find(|x| **x == 0).is_some();
+ +    ///
+ +    /// let _ = "hello world".find("world").is_none();
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust
+ +    /// let vec = vec![1];
+ +    /// vec.iter().any(|x| *x == 0);
+ +    ///
+ +    /// let _ = !"hello world".contains("world");
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub SEARCH_IS_SOME,
+ +    complexity,
+ +    "using an iterator or string search followed by `is_some()` or `is_none()`, which is more succinctly expressed as a call to `any()` or `contains()` (with negation in case of `is_none()`)"
+ +}
+ +
+ +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
+ +    /// ```rust
+ +    /// let name = "foo";
+ +    /// if name.chars().next() == Some('_') {};
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust
+ +    /// 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 calls to `.or(foo(..))`, `.unwrap_or(foo(..))`,
+ +    /// etc., and suggests to use `or_else`, `unwrap_or_else`, etc., or
+ +    /// `unwrap_or_default` instead.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The function will always be called and potentially
+ +    /// allocate an object acting as the default.
+ +    ///
+ +    /// ### Known problems
+ +    /// If the function has side-effects, not calling it will
+ +    /// change the semantic of the program, but you shouldn't rely on that anyway.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let foo = Some(String::new());
+ +    /// foo.unwrap_or(String::new());
+ +    /// ```
+ +    /// this can instead be written:
+ +    /// ```rust
+ +    /// # let foo = Some(String::new());
+ +    /// foo.unwrap_or_else(String::new);
+ +    /// ```
+ +    /// or
+ +    /// ```rust
+ +    /// # let foo = Some(String::new());
+ +    /// foo.unwrap_or_default();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub OR_FUN_CALL,
+ +    perf,
+ +    "using any `*or` method with a function call, which suggests `*or_else`"
+ +}
+ +
+ +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
+ +    /// ```rust
+ +    /// # 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
+ +    /// ```rust
+ +    /// # let foo = Some(String::new());
+ +    /// # let err_code = "418";
+ +    /// # let err_msg = "I'm a teapot";
+ +    /// foo.expect(format!("Err {}: {}", err_code, err_msg).as_str());
+ +    /// ```
+ +    /// this can instead be written:
+ +    /// ```rust
+ +    /// # 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 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
+ +    /// ```rust
+ +    /// 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 is this bad?
+ +    /// Calling '.clone()' on an Rc, Arc, or Weak
+ +    /// can obscure the fact that only the pointer is being cloned, not the underlying
+ +    /// data.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # use std::rc::Rc;
+ +    /// let x = Rc::new(1);
+ +    ///
+ +    /// // Bad
+ +    /// x.clone();
+ +    ///
+ +    /// // Good
+ +    /// 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 `.clone()` on an `&&T`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Cloning an `&&T` copies the inner `&T`, instead of
+ +    /// cloning the underlying `T`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// fn main() {
+ +    ///     let x = vec![1];
+ +    ///     let y = &&x;
+ +    ///     let z = y.clone();
+ +    ///     println!("{:p} {:p}", *y, z); // prints out the same pointer
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub CLONE_DOUBLE_REF,
+ +    correctness,
+ +    "using `clone` on `&&T`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `.to_string()` on an `&&T` where
+ +    /// `T` implements `ToString` directly (like `&&str` or `&&String`).
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This bypasses the specialized implementation of
+ +    /// `ToString` and instead goes through the more expensive string formatting
+ +    /// facilities.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Generic implementation for `T: Display` is used (slow)
+ +    /// ["foo", "bar"].iter().map(|s| s.to_string());
+ +    ///
+ +    /// // OK, the specialized impl is used
+ +    /// ["foo", "bar"].iter().map(|&s| s.to_string());
+ +    /// ```
+ +    #[clippy::version = "1.40.0"]
+ +    pub INEFFICIENT_TO_STRING,
+ +    pedantic,
+ +    "using `to_string` on `&&T` where `T: ToString`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `new` not returning a type that contains `Self`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// As a convention, `new` methods are used to make a new
+ +    /// instance of a type.
+ +    ///
+ +    /// ### Example
+ +    /// In an impl block:
+ +    /// ```rust
+ +    /// # struct Foo;
+ +    /// # struct NotAFoo;
+ +    /// impl Foo {
+ +    ///     fn new() -> NotAFoo {
+ +    /// # NotAFoo
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// ```rust
+ +    /// # struct Foo;
+ +    /// struct Bar(Foo);
+ +    /// impl Foo {
+ +    ///     // Bad. The type name must contain `Self`
+ +    ///     fn new() -> Bar {
+ +    /// # Bar(Foo)
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// ```rust
+ +    /// # struct Foo;
+ +    /// # struct FooError;
+ +    /// impl Foo {
+ +    ///     // Good. Return type contains `Self`
+ +    ///     fn new() -> Result<Foo, FooError> {
+ +    /// # Ok(Foo)
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// Or in a trait definition:
+ +    /// ```rust
+ +    /// pub trait Trait {
+ +    ///     // Bad. The type name must contain `Self`
+ +    ///     fn new();
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// ```rust
+ +    /// pub trait Trait {
+ +    ///     // Good. Return type contains `Self`
+ +    ///     fn new() -> Self;
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub NEW_RET_NO_SELF,
+ +    style,
+ +    "not returning type containing `Self` in a `new` method"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for string methods that receive a single-character
+ +    /// `str` as an argument, e.g., `_.split("x")`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Performing these methods using a `char` is faster than
+ +    /// using a `str`.
+ +    ///
+ +    /// ### Known problems
+ +    /// Does not catch multi-byte unicode characters.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// // Bad
+ +    /// _.split("x");
+ +    ///
+ +    /// // Good
+ +    /// _.split('x');
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub SINGLE_CHAR_PATTERN,
+ +    perf,
+ +    "using a single-character str where a char could be used, e.g., `_.split(\"x\")`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calling `.step_by(0)` on iterators which panics.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This very much looks like an oversight. Use `panic!()` instead if you
+ +    /// actually intend to panic.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,should_panic
+ +    /// for x in (0..100).step_by(0) {
+ +    ///     //..
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub ITERATOR_STEP_BY_ZERO,
+ +    correctness,
+ +    "using `Iterator::step_by(0)`, which will panic at runtime"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for indirect collection of populated `Option`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `Option` is like a collection of 0-1 things, so `flatten`
+ +    /// automatically does this without suspicious-looking `unwrap` calls.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let _ = std::iter::empty::<Option<i32>>().filter(Option::is_some).map(Option::unwrap);
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// let _ = std::iter::empty::<Option<i32>>().flatten();
+ +    /// ```
+ +    #[clippy::version = "1.53.0"]
+ +    pub OPTION_FILTER_MAP,
+ +    complexity,
+ +    "filtering `Option` for `Some` then force-unwrapping, which can be one type-safe operation"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for the use of `iter.nth(0)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `iter.next()` is equivalent to
+ +    /// `iter.nth(0)`, as they both consume the next element,
+ +    ///  but is more readable.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # use std::collections::HashSet;
+ +    /// // Bad
+ +    /// # let mut s = HashSet::new();
+ +    /// # s.insert(1);
+ +    /// let x = s.iter().nth(0);
+ +    ///
+ +    /// // Good
+ +    /// # let mut s = HashSet::new();
+ +    /// # s.insert(1);
+ +    /// let x = s.iter().next();
+ +    /// ```
+ +    #[clippy::version = "1.42.0"]
+ +    pub ITER_NTH_ZERO,
+ +    style,
+ +    "replace `iter.nth(0)` with `iter.next()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for use of `.iter().nth()` (and the related
+ +    /// `.iter_mut().nth()`) on standard library types with *O*(1) element access.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `.get()` and `.get_mut()` are more efficient and more
+ +    /// readable.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let some_vec = vec![0, 1, 2, 3];
+ +    /// let bad_vec = some_vec.iter().nth(3);
+ +    /// let bad_slice = &some_vec[..].iter().nth(3);
+ +    /// ```
+ +    /// The correct use would be:
+ +    /// ```rust
+ +    /// let some_vec = vec![0, 1, 2, 3];
+ +    /// let bad_vec = some_vec.get(3);
+ +    /// let bad_slice = &some_vec[..].get(3);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub ITER_NTH,
+ +    perf,
+ +    "using `.iter().nth()` on a standard library type with O(1) element access"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for use of `.skip(x).next()` on iterators.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `.nth(x)` is cleaner
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let some_vec = vec![0, 1, 2, 3];
+ +    /// let bad_vec = some_vec.iter().skip(3).next();
+ +    /// let bad_slice = &some_vec[..].iter().skip(3).next();
+ +    /// ```
+ +    /// The correct use would be:
+ +    /// ```rust
+ +    /// let some_vec = vec![0, 1, 2, 3];
+ +    /// let bad_vec = some_vec.iter().nth(3);
+ +    /// let bad_slice = &some_vec[..].iter().nth(3);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub ITER_SKIP_NEXT,
+ +    style,
+ +    "using `.skip(x).next()` on an iterator"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for use of `.get().unwrap()` (or
+ +    /// `.get_mut().unwrap`) on a standard library type which implements `Index`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Using the Index trait (`[]`) is more clear and more
+ +    /// concise.
+ +    ///
+ +    /// ### Known problems
+ +    /// Not a replacement for error handling: Using either
+ +    /// `.unwrap()` or the Index trait (`[]`) carries the risk of causing a `panic`
+ +    /// if the value being accessed is `None`. If the use of `.get().unwrap()` is a
+ +    /// temporary placeholder for dealing with the `Option` type, then this does
+ +    /// not mitigate the need for error handling. If there is a chance that `.get()`
+ +    /// will be `None` in your program, then it is advisable that the `None` case
+ +    /// is handled in a future refactor instead of using `.unwrap()` or the Index
+ +    /// trait.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let mut some_vec = vec![0, 1, 2, 3];
+ +    /// let last = some_vec.get(3).unwrap();
+ +    /// *some_vec.get_mut(0).unwrap() = 1;
+ +    /// ```
+ +    /// The correct use would be:
+ +    /// ```rust
+ +    /// let mut some_vec = vec![0, 1, 2, 3];
+ +    /// let last = some_vec[3];
+ +    /// some_vec[0] = 1;
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub GET_UNWRAP,
+ +    restriction,
+ +    "using `.get().unwrap()` or `.get_mut().unwrap()` when using `[]` would work instead"
+ +}
+ +
+ +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
+ +    /// ```rust
+ +    /// let mut a = vec![1, 2, 3];
+ +    /// let mut b = vec![4, 5, 6];
+ +    ///
+ +    /// // Bad
+ +    /// a.extend(b.drain(..));
+ +    ///
+ +    /// // Good
+ +    /// 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 vecor to another"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for the use of `.extend(s.chars())` where s is a
+ +    /// `&str` or `String`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `.push_str(s)` is clearer
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let abc = "abc";
+ +    /// let def = String::from("def");
+ +    /// let mut s = String::new();
+ +    /// s.extend(abc.chars());
+ +    /// s.extend(def.chars());
+ +    /// ```
+ +    /// The correct use would be:
+ +    /// ```rust
+ +    /// let abc = "abc";
+ +    /// let def = String::from("def");
+ +    /// let mut s = String::new();
+ +    /// s.push_str(abc);
+ +    /// s.push_str(&def);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub STRING_EXTEND_CHARS,
+ +    style,
+ +    "using `x.extend(s.chars())` where s is a `&str` or `String`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for the use of `.cloned().collect()` on slice to
+ +    /// create a `Vec`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `.to_vec()` is clearer
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let s = [1, 2, 3, 4, 5];
+ +    /// let s2: Vec<isize> = s[..].iter().cloned().collect();
+ +    /// ```
+ +    /// The better use would be:
+ +    /// ```rust
+ +    /// let s = [1, 2, 3, 4, 5];
+ +    /// let s2: Vec<isize> = s.to_vec();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub ITER_CLONED_COLLECT,
+ +    style,
+ +    "using `.cloned().collect()` on slice to create a `Vec`"
+ +}
+ +
+ +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
+ +    /// ```rust
+ +    /// # let name = "_";
+ +    ///
+ +    /// // Bad
+ +    /// name.chars().last() == Some('_') || name.chars().next_back() == Some('-');
+ +    ///
+ +    /// // Good
+ +    /// 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 `.as_ref()` or `.as_mut()` where the
+ +    /// types before and after the call are the same.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The call is unnecessary.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # fn do_stuff(x: &[i32]) {}
+ +    /// let x: &[i32] = &[1, 2, 3, 4, 5];
+ +    /// do_stuff(x.as_ref());
+ +    /// ```
+ +    /// The correct use would be:
+ +    /// ```rust
+ +    /// # fn do_stuff(x: &[i32]) {}
+ +    /// let x: &[i32] = &[1, 2, 3, 4, 5];
+ +    /// do_stuff(x);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub USELESS_ASREF,
+ +    complexity,
+ +    "using `as_ref` where the types before and after the call are the same"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for using `fold` when a more succinct alternative exists.
+ +    /// Specifically, this checks for `fold`s which could be replaced by `any`, `all`,
+ +    /// `sum` or `product`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let _ = (0..3).fold(false, |acc, x| acc || x > 2);
+ +    /// ```
+ +    /// This could be written as:
+ +    /// ```rust
+ +    /// let _ = (0..3).any(|x| x > 2);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub UNNECESSARY_FOLD,
+ +    style,
+ +    "using `fold` when a more succinct alternative exists"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `filter_map` calls which could be replaced by `filter` or `map`.
+ +    /// More specifically it checks if the closure provided is only performing one of the
+ +    /// filter or map operations and suggests the appropriate option.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Complexity. The intent is also clearer if only a single
+ +    /// operation is being performed.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let _ = (0..3).filter_map(|x| if x > 2 { Some(x) } else { None });
+ +    ///
+ +    /// // As there is no transformation of the argument this could be written as:
+ +    /// let _ = (0..3).filter(|&x| x > 2);
+ +    /// ```
+ +    ///
+ +    /// ```rust
+ +    /// let _ = (0..4).filter_map(|x| Some(x + 1));
+ +    ///
+ +    /// // As there is no conditional check on the argument this could be written as:
+ +    /// let _ = (0..4).map(|x| x + 1);
+ +    /// ```
+ +    #[clippy::version = "1.31.0"]
+ +    pub UNNECESSARY_FILTER_MAP,
+ +    complexity,
+ +    "using `filter_map` when a more succinct alternative exists"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `into_iter` calls on references which should be replaced by `iter`
+ +    /// or `iter_mut`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability. Calling `into_iter` on a reference will not move out its
+ +    /// content into the resulting iterator, which is confusing. It is better just call `iter` or
+ +    /// `iter_mut` directly.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Bad
+ +    /// let _ = (&vec![3, 4, 5]).into_iter();
+ +    ///
+ +    /// // Good
+ +    /// let _ = (&vec![3, 4, 5]).iter();
+ +    /// ```
+ +    #[clippy::version = "1.32.0"]
+ +    pub INTO_ITER_ON_REF,
+ +    style,
+ +    "using `.into_iter()` on a reference"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calls to `map` followed by a `count`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It looks suspicious. Maybe `map` was confused with `filter`.
+ +    /// If the `map` call is intentional, this should be rewritten
+ +    /// using `inspect`. Or, if you intend to drive the iterator to
+ +    /// completion, you can just use `for_each` instead.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let _ = (0..3).map(|x| x + 2).count();
+ +    /// ```
+ +    #[clippy::version = "1.39.0"]
+ +    pub SUSPICIOUS_MAP,
+ +    suspicious,
+ +    "suspicious usage of map"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `MaybeUninit::uninit().assume_init()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// For most types, this is undefined behavior.
+ +    ///
+ +    /// ### Known problems
+ +    /// For now, we accept empty tuples and tuples / arrays
+ +    /// of `MaybeUninit`. There may be other types that allow uninitialized
+ +    /// data, but those are not yet rigorously defined.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Beware the UB
+ +    /// use std::mem::MaybeUninit;
+ +    ///
+ +    /// let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
+ +    /// ```
+ +    ///
+ +    /// Note that the following is OK:
+ +    ///
+ +    /// ```rust
+ +    /// use std::mem::MaybeUninit;
+ +    ///
+ +    /// let _: [MaybeUninit<bool>; 5] = unsafe {
+ +    ///     MaybeUninit::uninit().assume_init()
+ +    /// };
+ +    /// ```
+ +    #[clippy::version = "1.39.0"]
+ +    pub UNINIT_ASSUMED_INIT,
+ +    correctness,
+ +    "`MaybeUninit::uninit().assume_init()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `.checked_add/sub(x).unwrap_or(MAX/MIN)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// These can be written simply with `saturating_add/sub` methods.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let y: u32 = 0;
+ +    /// # let x: u32 = 100;
+ +    /// let add = x.checked_add(y).unwrap_or(u32::MAX);
+ +    /// let sub = x.checked_sub(y).unwrap_or(u32::MIN);
+ +    /// ```
+ +    ///
+ +    /// can be written using dedicated methods for saturating addition/subtraction as:
+ +    ///
+ +    /// ```rust
+ +    /// # let y: u32 = 0;
+ +    /// # let x: u32 = 100;
+ +    /// let add = x.saturating_add(y);
+ +    /// let sub = x.saturating_sub(y);
+ +    /// ```
+ +    #[clippy::version = "1.39.0"]
+ +    pub MANUAL_SATURATING_ARITHMETIC,
+ +    style,
+ +    "`.chcked_add/sub(x).unwrap_or(MAX/MIN)`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `offset(_)`, `wrapping_`{`add`, `sub`}, etc. on raw pointers to
+ +    /// zero-sized types
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is a no-op, and likely unintended
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// unsafe { (&() as *const ()).offset(1) };
+ +    /// ```
+ +    #[clippy::version = "1.41.0"]
+ +    pub ZST_OFFSET,
+ +    correctness,
+ +    "Check for offset calculations on raw pointers to zero-sized types"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `FileType::is_file()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// 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
+ +    /// ```rust
+ +    /// # || {
+ +    /// 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:
+ +    ///
+ +    /// ```rust
+ +    /// # || {
+ +    /// 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 `_.as_ref().map(Deref::deref)` or it's aliases (such as String::as_str).
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability, this can be written more concisely as
+ +    /// `_.as_deref()`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let opt = Some("".to_string());
+ +    /// opt.as_ref().map(String::as_str)
+ +    /// # ;
+ +    /// ```
+ +    /// Can be written as
+ +    /// ```rust
+ +    /// # let opt = Some("".to_string());
+ +    /// opt.as_deref()
+ +    /// # ;
+ +    /// ```
+ +    #[clippy::version = "1.42.0"]
+ +    pub OPTION_AS_REF_DEREF,
+ +    complexity,
+ +    "using `as_ref().map(Deref::deref)`, which is more succinctly expressed as `as_deref()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `iter().next()` on a Slice or an Array
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// These can be shortened into `.get()`
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let a = [1, 2, 3];
+ +    /// # let b = vec![1, 2, 3];
+ +    /// a[2..].iter().next();
+ +    /// b.iter().next();
+ +    /// ```
+ +    /// should be written as:
+ +    /// ```rust
+ +    /// # let a = [1, 2, 3];
+ +    /// # let b = vec![1, 2, 3];
+ +    /// a.get(2);
+ +    /// b.get(0);
+ +    /// ```
+ +    #[clippy::version = "1.46.0"]
+ +    pub ITER_NEXT_SLICE,
+ +    style,
+ +    "using `.iter().next()` on a sliced array, which can be shortened to just `.get()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Warns when using `push_str`/`insert_str` with a single-character string literal
+ +    /// where `push`/`insert` with a `char` would work fine.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It's less clear that we are pushing a single character.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let mut string = String::new();
+ +    /// string.insert_str(0, "R");
+ +    /// string.push_str("R");
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust
+ +    /// let mut string = String::new();
+ +    /// string.insert(0, 'R');
+ +    /// string.push('R');
+ +    /// ```
+ +    #[clippy::version = "1.49.0"]
+ +    pub SINGLE_CHAR_ADD_STR,
+ +    style,
+ +    "`push_str()` or `insert_str()` used with a single-character string literal as parameter"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// As the counterpart to `or_fun_call`, this lint looks for unnecessary
+ +    /// lazily evaluated closures on `Option` and `Result`.
+ +    ///
+ +    /// This lint suggests changing the following functions, when eager evaluation results in
+ +    /// simpler code:
+ +    ///  - `unwrap_or_else` to `unwrap_or`
+ +    ///  - `and_then` to `and`
+ +    ///  - `or_else` to `or`
+ +    ///  - `get_or_insert_with` to `get_or_insert`
+ +    ///  - `ok_or_else` to `ok_or`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Using eager evaluation is shorter and simpler in some cases.
+ +    ///
+ +    /// ### Known problems
+ +    /// It is possible, but not recommended for `Deref` and `Index` to have
+ +    /// side effects. Eagerly evaluating them can change the semantics of the program.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // example code where clippy issues a warning
+ +    /// let opt: Option<u32> = None;
+ +    ///
+ +    /// opt.unwrap_or_else(|| 42);
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// let opt: Option<u32> = None;
+ +    ///
+ +    /// opt.unwrap_or(42);
+ +    /// ```
+ +    #[clippy::version = "1.48.0"]
+ +    pub UNNECESSARY_LAZY_EVALUATIONS,
+ +    style,
+ +    "using unnecessary lazy evaluation, which can be replaced with simpler eager evaluation"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `_.map(_).collect::<Result<(), _>()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Using `try_for_each` instead is more readable and idiomatic.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// (0..3).map(|t| Err(t)).collect::<Result<(), _>>();
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// (0..3).try_for_each(|t| Err(t));
+ +    /// ```
+ +    #[clippy::version = "1.49.0"]
+ +    pub MAP_COLLECT_RESULT_UNIT,
+ +    style,
+ +    "using `.map(_).collect::<Result<(),_>()`, which can be replaced with `try_for_each`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `from_iter()` function calls on types that implement the `FromIterator`
+ +    /// trait.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It is recommended style to use collect. See
+ +    /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// use std::iter::FromIterator;
+ +    ///
+ +    /// 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:
+ +    /// ```rust
+ +    /// 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]);
+ +    /// ```
+ +    #[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 `inspect().for_each()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It is the same as performing the computation
+ +    /// inside `inspect` at the beginning of the closure in `for_each`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// [1,2,3,4,5].iter()
+ +    /// .inspect(|&x| println!("inspect the number: {}", x))
+ +    /// .for_each(|&x| {
+ +    ///     assert!(x >= 0);
+ +    /// });
+ +    /// ```
+ +    /// Can be written as
+ +    /// ```rust
+ +    /// [1,2,3,4,5].iter()
+ +    /// .for_each(|&x| {
+ +    ///     println!("inspect the number: {}", x);
+ +    ///     assert!(x >= 0);
+ +    /// });
+ +    /// ```
+ +    #[clippy::version = "1.51.0"]
+ +    pub INSPECT_FOR_EACH,
+ +    complexity,
+ +    "using `.inspect().for_each()`, which can be replaced with `.for_each()`"
+ +}
+ +
+ +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
+ +    /// ```rust
+ +    /// # let iter = vec![Some(1)].into_iter();
+ +    /// iter.filter_map(|x| x);
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// # 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 instances of `map(f)` where `f` is the identity function.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It can be written more concisely without the call to `map`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let x = [1, 2, 3];
+ +    /// let y: Vec<_> = x.iter().map(|x| x).map(|x| 2*x).collect();
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// let x = [1, 2, 3];
+ +    /// let y: Vec<_> = x.iter().map(|x| 2*x).collect();
+ +    /// ```
+ +    #[clippy::version = "1.52.0"]
+ +    pub MAP_IDENTITY,
+ +    complexity,
+ +    "using iterator.map(|x| x)"
+ +}
+ +
+ +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
+ +    /// ```rust
+ +    /// // Bad
+ +    /// let _ = "Hello".bytes().nth(3);
+ +    ///
+ +    /// // Good
+ +    /// let _ = "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 the usage of `_.to_owned()`, `vec.to_vec()`, or similar when calling `_.clone()` would be clearer.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// These methods do the same thing as `_.clone()` but may be confusing as
+ +    /// to why we are calling `to_vec` on something that is already a `Vec` or calling `to_owned` on something that is already owned.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let a = vec![1, 2, 3];
+ +    /// let b = a.to_vec();
+ +    /// let c = a.to_owned();
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// let a = vec![1, 2, 3];
+ +    /// let b = a.clone();
+ +    /// let c = a.clone();
+ +    /// ```
+ +    #[clippy::version = "1.52.0"]
+ +    pub IMPLICIT_CLONE,
+ +    pedantic,
+ +    "implicitly cloning a value by invoking a function on its dereferenced type"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for the use of `.iter().count()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `.len()` is more efficient and more
+ +    /// readable.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Bad
+ +    /// let some_vec = vec![0, 1, 2, 3];
+ +    /// let _ = some_vec.iter().count();
+ +    /// let _ = &some_vec[..].iter().count();
+ +    ///
+ +    /// // Good
+ +    /// let some_vec = vec![0, 1, 2, 3];
+ +    /// let _ = some_vec.len();
+ +    /// let _ = &some_vec[..].len();
+ +    /// ```
+ +    #[clippy::version = "1.52.0"]
+ +    pub ITER_COUNT,
+ +    complexity,
+ +    "replace `.iter().count()` with `.len()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calls to [`splitn`]
+ +    /// (https://doc.rust-lang.org/std/primitive.str.html#method.splitn) and
+ +    /// related functions with either zero or one splits.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// These calls don't actually split the value and are
+ +    /// likely to be intended as a different number.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Bad
+ +    /// let s = "";
+ +    /// for x in s.splitn(1, ":") {
+ +    ///     // use x
+ +    /// }
+ +    ///
+ +    /// // Good
+ +    /// let s = "";
+ +    /// for x in s.splitn(2, ":") {
+ +    ///     // use x
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "1.54.0"]
+ +    pub SUSPICIOUS_SPLITN,
+ +    correctness,
+ +    "checks for `.splitn(0, ..)` and `.splitn(1, ..)`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for manual implementations of `str::repeat`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// These are both harder to read, as well as less performant.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Bad
+ +    /// let x: String = std::iter::repeat('x').take(10).collect();
+ +    ///
+ +    /// // Good
+ +    /// let x: String = "x".repeat(10);
+ +    /// ```
+ +    #[clippy::version = "1.54.0"]
+ +    pub MANUAL_STR_REPEAT,
+ +    perf,
+ +    "manual implementation of `str::repeat`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usages of `str::splitn(2, _)`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `split_once` is both clearer in intent and slightly more efficient.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// // Bad
+ +    ///  let (key, value) = _.splitn(2, '=').next_tuple()?;
+ +    ///  let value = _.splitn(2, '=').nth(1)?;
+ +    ///
+ +    /// // Good
+ +    /// let (key, value) = _.split_once('=')?;
+ +    /// let value = _.split_once('=')?.1;
+ +    /// ```
+ +    #[clippy::version = "1.57.0"]
+ +    pub MANUAL_SPLIT_ONCE,
+ +    complexity,
+ +    "replace `.splitn(2, pat)` with `.split_once(pat)`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usages of `str::splitn` (or `str::rsplitn`) where using `str::split` would be the same.
+ +    /// ### Why is this bad?
+ +    /// The function `split` is simpler and there is no performance difference in these cases, considering
+ +    /// that both functions return a lazy iterator.
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Bad
+ +    /// let str = "key=value=add";
+ +    /// let _ = str.splitn(3, '=').next().unwrap();
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// // Good
+ +    /// let str = "key=value=add";
+ +    /// let _ = str.split('=').next().unwrap();
+ +    /// ```
+ +    #[clippy::version = "1.58.0"]
+ +    pub NEEDLESS_SPLITN,
+ +    complexity,
+ +    "usages of `str::splitn` that can be replaced with `str::split`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for unnecessary calls to [`ToOwned::to_owned`](https://doc.rust-lang.org/std/borrow/trait.ToOwned.html#tymethod.to_owned)
+ +    /// and other `to_owned`-like functions.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The unnecessary calls result in useless allocations.
+ +    ///
+ +    /// ### Known problems
+ +    /// `unnecessary_to_owned` can falsely trigger if `IntoIterator::into_iter` is applied to an
+ +    /// owned copy of a resource and the resource is later used mutably. See
+ +    /// [#8148](https://github.com/rust-lang/rust-clippy/issues/8148).
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let path = std::path::Path::new("x");
+ +    /// foo(&path.to_string_lossy().to_string());
+ +    /// fn foo(s: &str) {}
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// let path = std::path::Path::new("x");
+ +    /// foo(&path.to_string_lossy());
+ +    /// fn foo(s: &str) {}
+ +    /// ```
+ +    #[clippy::version = "1.58.0"]
+ +    pub UNNECESSARY_TO_OWNED,
+ +    perf,
+ +    "unnecessary calls to `to_owned`-like functions"
+ +}
+ +
+ +pub struct Methods {
+ +    avoid_breaking_exported_api: bool,
+ +    msrv: Option<RustcVersion>,
+ +}
+ +
+ +impl Methods {
+ +    #[must_use]
+ +    pub fn new(avoid_breaking_exported_api: bool, msrv: Option<RustcVersion>) -> Self {
+ +        Self {
+ +            avoid_breaking_exported_api,
+ +            msrv,
+ +        }
+ +    }
+ +}
+ +
+ +impl_lint_pass!(Methods => [
+ +    UNWRAP_USED,
+ +    EXPECT_USED,
+ +    SHOULD_IMPLEMENT_TRAIT,
+ +    WRONG_SELF_CONVENTION,
+ +    OK_EXPECT,
+ +    UNWRAP_OR_ELSE_DEFAULT,
+ +    MAP_UNWRAP_OR,
+ +    RESULT_MAP_OR_INTO_OPTION,
+ +    OPTION_MAP_OR_NONE,
+ +    BIND_INSTEAD_OF_MAP,
+ +    OR_FUN_CALL,
+ +    EXPECT_FUN_CALL,
+ +    CHARS_NEXT_CMP,
+ +    CHARS_LAST_CMP,
+ +    CLONE_ON_COPY,
+ +    CLONE_ON_REF_PTR,
+ +    CLONE_DOUBLE_REF,
++    ITER_OVEREAGER_CLONED,
+ +    CLONED_INSTEAD_OF_COPIED,
+ +    FLAT_MAP_OPTION,
+ +    INEFFICIENT_TO_STRING,
+ +    NEW_RET_NO_SELF,
+ +    SINGLE_CHAR_PATTERN,
+ +    SINGLE_CHAR_ADD_STR,
+ +    SEARCH_IS_SOME,
+ +    FILTER_NEXT,
+ +    SKIP_WHILE_NEXT,
+ +    FILTER_MAP_IDENTITY,
+ +    MAP_IDENTITY,
+ +    MANUAL_FILTER_MAP,
+ +    MANUAL_FIND_MAP,
+ +    OPTION_FILTER_MAP,
+ +    FILTER_MAP_NEXT,
+ +    FLAT_MAP_IDENTITY,
+ +    MAP_FLATTEN,
+ +    ITERATOR_STEP_BY_ZERO,
+ +    ITER_NEXT_SLICE,
+ +    ITER_COUNT,
+ +    ITER_NTH,
+ +    ITER_NTH_ZERO,
+ +    BYTES_NTH,
+ +    ITER_SKIP_NEXT,
+ +    GET_UNWRAP,
+ +    STRING_EXTEND_CHARS,
+ +    ITER_CLONED_COLLECT,
+ +    USELESS_ASREF,
+ +    UNNECESSARY_FOLD,
+ +    UNNECESSARY_FILTER_MAP,
+ +    INTO_ITER_ON_REF,
+ +    SUSPICIOUS_MAP,
+ +    UNINIT_ASSUMED_INIT,
+ +    MANUAL_SATURATING_ARITHMETIC,
+ +    ZST_OFFSET,
+ +    FILETYPE_IS_FILE,
+ +    OPTION_AS_REF_DEREF,
+ +    UNNECESSARY_LAZY_EVALUATIONS,
+ +    MAP_COLLECT_RESULT_UNIT,
+ +    FROM_ITER_INSTEAD_OF_COLLECT,
+ +    INSPECT_FOR_EACH,
+ +    IMPLICIT_CLONE,
+ +    SUSPICIOUS_SPLITN,
+ +    MANUAL_STR_REPEAT,
+ +    EXTEND_WITH_DRAIN,
+ +    MANUAL_SPLIT_ONCE,
+ +    NEEDLESS_SPLITN,
+ +    UNNECESSARY_TO_OWNED,
+ +]);
+ +
+ +/// Extracts a method call name, args, and `Span` of the method name.
+ +fn method_call<'tcx>(recv: &'tcx hir::Expr<'tcx>) -> Option<(&'tcx str, &'tcx [hir::Expr<'tcx>], Span)> {
+ +    if let ExprKind::MethodCall(path, span, args, _) = recv.kind {
+ +        if !args.iter().any(|e| e.span.from_expansion()) {
+ +            let name = path.ident.name.as_str();
+ +            return Some((name, args, span));
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +impl<'tcx> LateLintPass<'tcx> for Methods {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+ +        if expr.span.from_expansion() {
+ +            return;
+ +        }
+ +
+ +        check_methods(cx, expr, self.msrv.as_ref());
+ +
+ +        match expr.kind {
+ +            hir::ExprKind::Call(func, args) => {
+ +                from_iter_instead_of_collect::check(cx, expr, args, func);
+ +            },
+ +            hir::ExprKind::MethodCall(method_call, ref method_span, args, _) => {
+ +                or_fun_call::check(cx, expr, *method_span, method_call.ident.as_str(), args);
+ +                expect_fun_call::check(cx, expr, *method_span, method_call.ident.as_str(), args);
+ +                clone_on_copy::check(cx, expr, method_call.ident.name, args);
+ +                clone_on_ref_ptr::check(cx, expr, method_call.ident.name, args);
+ +                inefficient_to_string::check(cx, expr, method_call.ident.name, args);
+ +                single_char_add_str::check(cx, expr, args);
+ +                into_iter_on_ref::check(cx, expr, *method_span, method_call.ident.name, args);
+ +                single_char_pattern::check(cx, expr, method_call.ident.name, args);
+ +                unnecessary_to_owned::check(cx, expr, method_call.ident.name, args);
+ +            },
+ +            hir::ExprKind::Binary(op, lhs, rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => {
+ +                let mut info = BinaryExprInfo {
+ +                    expr,
+ +                    chain: lhs,
+ +                    other: rhs,
+ +                    eq: op.node == hir::BinOpKind::Eq,
+ +                };
+ +                lint_binary_expr_with_method_call(cx, &mut info);
+ +            },
+ +            _ => (),
+ +        }
+ +    }
+ +
+ +    #[allow(clippy::too_many_lines)]
+ +    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) {
+ +        if in_external_macro(cx.sess(), impl_item.span) {
+ +            return;
+ +        }
+ +        let name = impl_item.ident.name.as_str();
+ +        let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id());
+ +        let item = cx.tcx.hir().expect_item(parent);
+ +        let self_ty = cx.tcx.type_of(item.def_id);
+ +
+ +        let implements_trait = matches!(item.kind, hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }));
+ +        if_chain! {
+ +            if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind;
+ +            if let Some(first_arg) = iter_input_pats(sig.decl, cx.tcx.hir().body(id)).next();
+ +
+ +            let method_sig = cx.tcx.fn_sig(impl_item.def_id);
+ +            let method_sig = cx.tcx.erase_late_bound_regions(method_sig);
+ +
+ +            let first_arg_ty = &method_sig.inputs().iter().next();
+ +
+ +            // check conventions w.r.t. conversion method names and predicates
+ +            if let Some(first_arg_ty) = first_arg_ty;
+ +
+ +            then {
+ +                // if this impl block implements a trait, lint in trait definition instead
+ +                if !implements_trait && cx.access_levels.is_exported(impl_item.def_id) {
+ +                    // check missing trait implementations
+ +                    for method_config in &TRAIT_METHODS {
+ +                        if name == method_config.method_name &&
+ +                            sig.decl.inputs.len() == method_config.param_count &&
+ +                            method_config.output_type.matches(&sig.decl.output) &&
+ +                            method_config.self_kind.matches(cx, self_ty, first_arg_ty) &&
+ +                            fn_header_equals(method_config.fn_header, sig.header) &&
+ +                            method_config.lifetime_param_cond(impl_item)
+ +                        {
+ +                            span_lint_and_help(
+ +                                cx,
+ +                                SHOULD_IMPLEMENT_TRAIT,
+ +                                impl_item.span,
+ +                                &format!(
+ +                                    "method `{}` can be confused for the standard trait method `{}::{}`",
+ +                                    method_config.method_name,
+ +                                    method_config.trait_name,
+ +                                    method_config.method_name
+ +                                ),
+ +                                None,
+ +                                &format!(
+ +                                    "consider implementing the trait `{}` or choosing a less ambiguous method name",
+ +                                    method_config.trait_name
+ +                                )
+ +                            );
+ +                        }
+ +                    }
+ +                }
+ +
+ +                if sig.decl.implicit_self.has_implicit_self()
+ +                    && !(self.avoid_breaking_exported_api
+ +                        && cx.access_levels.is_exported(impl_item.def_id))
+ +                {
+ +                    wrong_self_convention::check(
+ +                        cx,
+ +                        name,
+ +                        self_ty,
+ +                        first_arg_ty,
+ +                        first_arg.pat.span,
+ +                        implements_trait,
+ +                        false
+ +                    );
+ +                }
+ +            }
+ +        }
+ +
+ +        // if this impl block implements a trait, lint in trait definition instead
+ +        if implements_trait {
+ +            return;
+ +        }
+ +
+ +        if let hir::ImplItemKind::Fn(_, _) = impl_item.kind {
+ +            let ret_ty = return_ty(cx, impl_item.hir_id());
+ +
+ +            // walk the return type and check for Self (this does not check associated types)
+ +            if let Some(self_adt) = self_ty.ty_adt_def() {
+ +                if contains_adt_constructor(ret_ty, self_adt) {
+ +                    return;
+ +                }
+ +            } else if contains_ty(ret_ty, self_ty) {
+ +                return;
+ +            }
+ +
+ +            // if return type is impl trait, check the associated types
+ +            if let ty::Opaque(def_id, _) = *ret_ty.kind() {
+ +                // one of the associated types must be Self
+ +                for &(predicate, _span) in cx.tcx.explicit_item_bounds(def_id) {
+ +                    if let ty::PredicateKind::Projection(projection_predicate) = predicate.kind().skip_binder() {
+ +                        // walk the associated type and check for Self
+ +                        if let Some(self_adt) = self_ty.ty_adt_def() {
+ +                            if contains_adt_constructor(projection_predicate.ty, self_adt) {
+ +                                return;
+ +                            }
+ +                        } else if contains_ty(projection_predicate.ty, self_ty) {
+ +                            return;
+ +                        }
+ +                    }
+ +                }
+ +            }
+ +
+ +            if name == "new" && !TyS::same_type(ret_ty, self_ty) {
+ +                span_lint(
+ +                    cx,
+ +                    NEW_RET_NO_SELF,
+ +                    impl_item.span,
+ +                    "methods called `new` usually return `Self`",
+ +                );
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+ +        if in_external_macro(cx.tcx.sess, item.span) {
+ +            return;
+ +        }
+ +
+ +        if_chain! {
+ +            if let TraitItemKind::Fn(ref sig, _) = item.kind;
+ +            if sig.decl.implicit_self.has_implicit_self();
+ +            if let Some(first_arg_ty) = sig.decl.inputs.iter().next();
+ +
+ +            then {
+ +                let first_arg_span = first_arg_ty.span;
+ +                let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty);
+ +                let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty().skip_binder();
+ +                wrong_self_convention::check(
+ +                    cx,
+ +                    item.ident.name.as_str(),
+ +                    self_ty,
+ +                    first_arg_ty,
+ +                    first_arg_span,
+ +                    false,
+ +                    true
+ +                );
+ +            }
+ +        }
+ +
+ +        if_chain! {
+ +            if item.ident.name == sym::new;
+ +            if let TraitItemKind::Fn(_, _) = item.kind;
+ +            let ret_ty = return_ty(cx, item.hir_id());
+ +            let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty().skip_binder();
+ +            if !contains_ty(ret_ty, self_ty);
+ +
+ +            then {
+ +                span_lint(
+ +                    cx,
+ +                    NEW_RET_NO_SELF,
+ +                    item.span,
+ +                    "methods called `new` usually return `Self`",
+ +                );
+ +            }
+ +        }
+ +    }
+ +
+ +    extract_msrv_attr!(LateContext);
+ +}
+ +
+ +#[allow(clippy::too_many_lines)]
+ +fn check_methods<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Option<&RustcVersion>) {
+ +    if let Some((name, [recv, args @ ..], span)) = method_call(expr) {
+ +        match (name, args) {
+ +            ("add" | "offset" | "sub" | "wrapping_offset" | "wrapping_add" | "wrapping_sub", [_arg]) => {
+ +                zst_offset::check(cx, expr, recv);
+ +            },
+ +            ("and_then", [arg]) => {
+ +                let biom_option_linted = bind_instead_of_map::OptionAndThenSome::check(cx, expr, recv, arg);
+ +                let biom_result_linted = bind_instead_of_map::ResultAndThenOk::check(cx, expr, recv, arg);
+ +                if !biom_option_linted && !biom_result_linted {
+ +                    unnecessary_lazy_eval::check(cx, expr, recv, arg, "and");
+ +                }
+ +            },
+ +            ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
+ +            ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
+ +            ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
+ +            ("cloned", []) => cloned_instead_of_copied::check(cx, expr, recv, span, msrv),
+ +            ("collect", []) => match method_call(recv) {
+ +                Some((name @ ("cloned" | "copied"), [recv2], _)) => {
+ +                    iter_cloned_collect::check(cx, name, expr, recv2);
+ +                },
+ +                Some(("map", [m_recv, m_arg], _)) => {
+ +                    map_collect_result_unit::check(cx, expr, m_recv, m_arg, recv);
+ +                },
+ +                Some(("take", [take_self_arg, take_arg], _)) => {
+ +                    if meets_msrv(msrv, &msrvs::STR_REPEAT) {
+ +                        manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
+ +                    }
+ +                },
+ +                _ => {},
+ +            },
-             ("flatten", []) => {
-                 if let Some(("map", [recv, map_arg], _)) = method_call(recv) {
-                     map_flatten::check(cx, expr, recv, map_arg);
-                 }
++            (name @ "count", args @ []) => match method_call(recv) {
++                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
++                Some((name2 @ ("into_iter" | "iter" | "iter_mut"), [recv2], _)) => {
++                    iter_count::check(cx, expr, recv2, name2);
+ +                },
+ +                Some(("map", [_, arg], _)) => suspicious_map::check(cx, expr, recv, arg),
+ +                _ => {},
+ +            },
+ +            ("expect", [_]) => match method_call(recv) {
+ +                Some(("ok", [recv], _)) => ok_expect::check(cx, expr, recv),
+ +                _ => expect_used::check(cx, expr, recv),
+ +            },
+ +            ("extend", [arg]) => {
+ +                string_extend_chars::check(cx, expr, recv, arg);
+ +                extend_with_drain::check(cx, expr, recv, arg);
+ +            },
+ +            ("filter_map", [arg]) => {
+ +                unnecessary_filter_map::check(cx, expr, arg);
+ +                filter_map_identity::check(cx, expr, arg, span);
+ +            },
+ +            ("flat_map", [arg]) => {
+ +                flat_map_identity::check(cx, expr, arg, span);
+ +                flat_map_option::check(cx, expr, arg, span);
+ +            },
-             ("next", []) => {
-                 if let Some((name, [recv, args @ ..], _)) = method_call(recv) {
-                     match (name, args) {
-                         ("filter", [arg]) => filter_next::check(cx, expr, recv, arg),
-                         ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv, arg, msrv),
-                         ("iter", []) => iter_next_slice::check(cx, expr, recv),
-                         ("skip", [arg]) => iter_skip_next::check(cx, expr, recv, arg),
++            (name @ "flatten", args @ []) => match method_call(recv) {
++                Some(("map", [recv, map_arg], _)) => map_flatten::check(cx, expr, recv, map_arg),
++                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
++                _ => {},
+ +            },
+ +            ("fold", [init, acc]) => unnecessary_fold::check(cx, expr, init, acc, span),
+ +            ("for_each", [_]) => {
+ +                if let Some(("inspect", [_, _], span2)) = method_call(recv) {
+ +                    inspect_for_each::check(cx, expr, span2);
+ +                }
+ +            },
+ +            ("get_or_insert_with", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "get_or_insert"),
+ +            ("is_file", []) => filetype_is_file::check(cx, expr, recv),
+ +            ("is_none", []) => check_is_some_is_none(cx, expr, recv, false),
+ +            ("is_some", []) => check_is_some_is_none(cx, expr, recv, true),
++            ("last", args @ []) | ("skip", args @ [_]) => {
++                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
++                    if let ("cloned", []) = (name2, args2) {
++                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
++                    }
++                }
++            },
+ +            ("map", [m_arg]) => {
+ +                if let Some((name, [recv2, args @ ..], span2)) = method_call(recv) {
+ +                    match (name, args) {
+ +                        ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, msrv),
+ +                        ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, msrv),
+ +                        ("filter", [f_arg]) => {
+ +                            filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false);
+ +                        },
+ +                        ("find", [f_arg]) => filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, true),
+ +                        _ => {},
+ +                    }
+ +                }
+ +                map_identity::check(cx, expr, recv, m_arg, span);
+ +            },
+ +            ("map_or", [def, map]) => option_map_or_none::check(cx, expr, recv, def, map),
-             ("nth", [n_arg]) => match method_call(recv) {
++            (name @ "next", args @ []) => {
++                if let Some((name2, [recv2, args2 @ ..], _)) = method_call(recv) {
++                    match (name2, args2) {
++                        ("cloned", []) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
++                        ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
++                        ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, msrv),
++                        ("iter", []) => iter_next_slice::check(cx, expr, recv2),
++                        ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
+ +                        ("skip_while", [_]) => skip_while_next::check(cx, expr),
+ +                        _ => {},
+ +                    }
+ +                }
+ +            },
-                 implicit_clone::check(cx, name, expr, recv, span);
++            ("nth", args @ [n_arg]) => match method_call(recv) {
+ +                Some(("bytes", [recv2], _)) => bytes_nth::check(cx, expr, recv2, n_arg),
++                Some(("cloned", [recv2], _)) => iter_overeager_cloned::check(cx, expr, recv2, name, args),
+ +                Some(("iter", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, false),
+ +                Some(("iter_mut", [recv2], _)) => iter_nth::check(cx, expr, recv2, recv, n_arg, true),
+ +                _ => iter_nth_zero::check(cx, expr, recv, n_arg),
+ +            },
+ +            ("ok_or_else", [arg]) => unnecessary_lazy_eval::check(cx, expr, recv, arg, "ok_or"),
+ +            ("or_else", [arg]) => {
+ +                if !bind_instead_of_map::ResultOrElseErrInfo::check(cx, expr, recv, arg) {
+ +                    unnecessary_lazy_eval::check(cx, expr, recv, arg, "or");
+ +                }
+ +            },
+ +            ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
+ +                if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+ +                    suspicious_splitn::check(cx, name, expr, recv, count);
+ +                    if count == 2 && meets_msrv(msrv, &msrvs::STR_SPLIT_ONCE) {
+ +                        str_splitn::check_manual_split_once(cx, name, expr, recv, pat_arg);
+ +                    }
+ +                    if count >= 2 {
+ +                        str_splitn::check_needless_splitn(cx, name, expr, recv, pat_arg, count);
+ +                    }
+ +                }
+ +            },
+ +            ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
+ +                if let Some((Constant::Int(count), _)) = constant(cx, cx.typeck_results(), count_arg) {
+ +                    suspicious_splitn::check(cx, name, expr, recv, count);
+ +                }
+ +            },
+ +            ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
++            ("take", args @ [_arg]) => {
++                if let Some((name2, [recv2, args2 @ ..], _span2)) = method_call(recv) {
++                    if let ("cloned", []) = (name2, args2) {
++                        iter_overeager_cloned::check(cx, expr, recv2, name, args);
++                    }
++                }
++            },
+ +            ("to_os_string" | "to_owned" | "to_path_buf" | "to_vec", []) => {
++                implicit_clone::check(cx, name, expr, recv);
+ +            },
+ +            ("unwrap", []) => match method_call(recv) {
+ +                Some(("get", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, false),
+ +                Some(("get_mut", [recv, get_arg], _)) => get_unwrap::check(cx, expr, recv, get_arg, true),
+ +                _ => unwrap_used::check(cx, expr, recv),
+ +            },
+ +            ("unwrap_or", [u_arg]) => match method_call(recv) {
+ +                Some((arith @ ("checked_add" | "checked_sub" | "checked_mul"), [lhs, rhs], _)) => {
+ +                    manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
+ +                },
+ +                Some(("map", [m_recv, m_arg], span)) => {
+ +                    option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span);
+ +                },
+ +                _ => {},
+ +            },
+ +            ("unwrap_or_else", [u_arg]) => match method_call(recv) {
+ +                Some(("map", [recv, map_arg], _)) if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, msrv) => {},
+ +                _ => {
+ +                    unwrap_or_else_default::check(cx, expr, recv, u_arg);
+ +                    unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
+ +                },
+ +            },
+ +            _ => {},
+ +        }
+ +    }
+ +}
+ +
+ +fn check_is_some_is_none(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, is_some: bool) {
+ +    if let Some((name @ ("find" | "position" | "rposition"), [f_recv, arg], span)) = method_call(recv) {
+ +        search_is_some::check(cx, expr, name, is_some, f_recv, arg, recv, span);
+ +    }
+ +}
+ +
+ +/// Used for `lint_binary_expr_with_method_call`.
+ +#[derive(Copy, Clone)]
+ +struct BinaryExprInfo<'a> {
+ +    expr: &'a hir::Expr<'a>,
+ +    chain: &'a hir::Expr<'a>,
+ +    other: &'a hir::Expr<'a>,
+ +    eq: bool,
+ +}
+ +
+ +/// Checks for the `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
+ +fn lint_binary_expr_with_method_call(cx: &LateContext<'_>, info: &mut BinaryExprInfo<'_>) {
+ +    macro_rules! lint_with_both_lhs_and_rhs {
+ +        ($func:expr, $cx:expr, $info:ident) => {
+ +            if !$func($cx, $info) {
+ +                ::std::mem::swap(&mut $info.chain, &mut $info.other);
+ +                if $func($cx, $info) {
+ +                    return;
+ +                }
+ +            }
+ +        };
+ +    }
+ +
+ +    lint_with_both_lhs_and_rhs!(chars_next_cmp::check, cx, info);
+ +    lint_with_both_lhs_and_rhs!(chars_last_cmp::check, cx, info);
+ +    lint_with_both_lhs_and_rhs!(chars_next_cmp_with_unwrap::check, cx, info);
+ +    lint_with_both_lhs_and_rhs!(chars_last_cmp_with_unwrap::check, cx, info);
+ +}
+ +
+ +const FN_HEADER: hir::FnHeader = hir::FnHeader {
+ +    unsafety: hir::Unsafety::Normal,
+ +    constness: hir::Constness::NotConst,
+ +    asyncness: hir::IsAsync::NotAsync,
+ +    abi: rustc_target::spec::abi::Abi::Rust,
+ +};
+ +
+ +struct ShouldImplTraitCase {
+ +    trait_name: &'static str,
+ +    method_name: &'static str,
+ +    param_count: usize,
+ +    fn_header: hir::FnHeader,
+ +    // implicit self kind expected (none, self, &self, ...)
+ +    self_kind: SelfKind,
+ +    // checks against the output type
+ +    output_type: OutType,
+ +    // certain methods with explicit lifetimes can't implement the equivalent trait method
+ +    lint_explicit_lifetime: bool,
+ +}
+ +impl ShouldImplTraitCase {
+ +    const fn new(
+ +        trait_name: &'static str,
+ +        method_name: &'static str,
+ +        param_count: usize,
+ +        fn_header: hir::FnHeader,
+ +        self_kind: SelfKind,
+ +        output_type: OutType,
+ +        lint_explicit_lifetime: bool,
+ +    ) -> ShouldImplTraitCase {
+ +        ShouldImplTraitCase {
+ +            trait_name,
+ +            method_name,
+ +            param_count,
+ +            fn_header,
+ +            self_kind,
+ +            output_type,
+ +            lint_explicit_lifetime,
+ +        }
+ +    }
+ +
+ +    fn lifetime_param_cond(&self, impl_item: &hir::ImplItem<'_>) -> bool {
+ +        self.lint_explicit_lifetime
+ +            || !impl_item.generics.params.iter().any(|p| {
+ +                matches!(
+ +                    p.kind,
+ +                    hir::GenericParamKind::Lifetime {
+ +                        kind: hir::LifetimeParamKind::Explicit
+ +                    }
+ +                )
+ +            })
+ +    }
+ +}
+ +
+ +#[rustfmt::skip]
+ +const TRAIT_METHODS: [ShouldImplTraitCase; 30] = [
+ +    ShouldImplTraitCase::new("std::ops::Add", "add",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::convert::AsMut", "as_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::convert::AsRef", "as_ref",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::ops::BitAnd", "bitand",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::BitOr", "bitor",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::BitXor", "bitxor",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::borrow::Borrow", "borrow",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::borrow::BorrowMut", "borrow_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::clone::Clone", "clone",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::cmp::Ord", "cmp",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Any, true),
+ +    // FIXME: default doesn't work
+ +    ShouldImplTraitCase::new("std::default::Default", "default",  0,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Deref", "deref",  1,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::ops::DerefMut", "deref_mut",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::ops::Div", "div",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Drop", "drop",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Unit, true),
+ +    ShouldImplTraitCase::new("std::cmp::PartialEq", "eq",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Bool, true),
+ +    ShouldImplTraitCase::new("std::iter::FromIterator", "from_iter",  1,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::str::FromStr", "from_str",  1,  FN_HEADER,  SelfKind::No,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::hash::Hash", "hash",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Unit, true),
+ +    ShouldImplTraitCase::new("std::ops::Index", "index",  2,  FN_HEADER,  SelfKind::Ref,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::ops::IndexMut", "index_mut",  2,  FN_HEADER,  SelfKind::RefMut,  OutType::Ref, true),
+ +    ShouldImplTraitCase::new("std::iter::IntoIterator", "into_iter",  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Mul", "mul",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Neg", "neg",  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::iter::Iterator", "next",  1,  FN_HEADER,  SelfKind::RefMut,  OutType::Any, false),
+ +    ShouldImplTraitCase::new("std::ops::Not", "not",  1,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Rem", "rem",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Shl", "shl",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Shr", "shr",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +    ShouldImplTraitCase::new("std::ops::Sub", "sub",  2,  FN_HEADER,  SelfKind::Value,  OutType::Any, true),
+ +];
+ +
+ +#[derive(Clone, Copy, PartialEq, Debug)]
+ +enum SelfKind {
+ +    Value,
+ +    Ref,
+ +    RefMut,
+ +    No,
+ +}
+ +
+ +impl SelfKind {
+ +    fn matches<'a>(self, cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+ +        fn matches_value<'a>(cx: &LateContext<'a>, parent_ty: Ty<'_>, ty: Ty<'_>) -> bool {
+ +            if ty == parent_ty {
+ +                true
+ +            } else if ty.is_box() {
+ +                ty.boxed_ty() == parent_ty
+ +            } else if is_type_diagnostic_item(cx, ty, sym::Rc) || is_type_diagnostic_item(cx, ty, sym::Arc) {
+ +                if let ty::Adt(_, substs) = ty.kind() {
+ +                    substs.types().next().map_or(false, |t| t == parent_ty)
+ +                } else {
+ +                    false
+ +                }
+ +            } else {
+ +                false
+ +            }
+ +        }
+ +
+ +        fn matches_ref<'a>(cx: &LateContext<'a>, mutability: hir::Mutability, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+ +            if let ty::Ref(_, t, m) = *ty.kind() {
+ +                return m == mutability && t == parent_ty;
+ +            }
+ +
+ +            let trait_path = match mutability {
+ +                hir::Mutability::Not => &paths::ASREF_TRAIT,
+ +                hir::Mutability::Mut => &paths::ASMUT_TRAIT,
+ +            };
+ +
+ +            let trait_def_id = match get_trait_def_id(cx, trait_path) {
+ +                Some(did) => did,
+ +                None => return false,
+ +            };
+ +            implements_trait(cx, ty, trait_def_id, &[parent_ty.into()])
+ +        }
+ +
+ +        fn matches_none<'a>(cx: &LateContext<'a>, parent_ty: Ty<'a>, ty: Ty<'a>) -> bool {
+ +            !matches_value(cx, parent_ty, ty)
+ +                && !matches_ref(cx, hir::Mutability::Not, parent_ty, ty)
+ +                && !matches_ref(cx, hir::Mutability::Mut, parent_ty, ty)
+ +        }
+ +
+ +        match self {
+ +            Self::Value => matches_value(cx, parent_ty, ty),
+ +            Self::Ref => matches_ref(cx, hir::Mutability::Not, parent_ty, ty) || ty == parent_ty && is_copy(cx, ty),
+ +            Self::RefMut => matches_ref(cx, hir::Mutability::Mut, parent_ty, ty),
+ +            Self::No => matches_none(cx, parent_ty, ty),
+ +        }
+ +    }
+ +
+ +    #[must_use]
+ +    fn description(self) -> &'static str {
+ +        match self {
+ +            Self::Value => "`self` by value",
+ +            Self::Ref => "`self` by reference",
+ +            Self::RefMut => "`self` by mutable reference",
+ +            Self::No => "no `self`",
+ +        }
+ +    }
+ +}
+ +
+ +#[derive(Clone, Copy)]
+ +enum OutType {
+ +    Unit,
+ +    Bool,
+ +    Any,
+ +    Ref,
+ +}
+ +
+ +impl OutType {
+ +    fn matches(self, ty: &hir::FnRetTy<'_>) -> bool {
+ +        let is_unit = |ty: &hir::Ty<'_>| matches!(ty.kind, hir::TyKind::Tup(&[]));
+ +        match (self, ty) {
+ +            (Self::Unit, &hir::FnRetTy::DefaultReturn(_)) => true,
+ +            (Self::Unit, &hir::FnRetTy::Return(ty)) if is_unit(ty) => true,
+ +            (Self::Bool, &hir::FnRetTy::Return(ty)) if is_bool(ty) => true,
+ +            (Self::Any, &hir::FnRetTy::Return(ty)) if !is_unit(ty) => true,
+ +            (Self::Ref, &hir::FnRetTy::Return(ty)) => matches!(ty.kind, hir::TyKind::Rptr(_, _)),
+ +            _ => false,
+ +        }
+ +    }
+ +}
+ +
+ +fn is_bool(ty: &hir::Ty<'_>) -> bool {
+ +    if let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
+ +        matches!(path.res, Res::PrimTy(PrimTy::Bool))
+ +    } else {
+ +        false
+ +    }
+ +}
+ +
+ +fn fn_header_equals(expected: hir::FnHeader, actual: hir::FnHeader) -> bool {
+ +    expected.constness == actual.constness
+ +        && expected.unsafety == actual.unsafety
+ +        && expected.asyncness == actual.asyncness
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs

index 4e4653dadcafcdc1bfe926c2c9cda0a58eea697b,0000000000000000000000000000000000000000..448dc4e6147ffb97470ad021a674bab68c8ed432

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs
@@@ -1,178 -1,0 +1,192 @@@
-                     span,
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::eager_or_lazy::switch_to_lazy_eval;
+ +use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_macro_callsite};
+ +use clippy_utils::ty::{implements_trait, match_type};
+ +use clippy_utils::{contains_return, is_trait_item, last_path_segment, paths};
+ +use if_chain::if_chain;
++use rustc_errors::emitter::MAX_SUGGESTION_HIGHLIGHT_LINES;
+ +use rustc_errors::Applicability;
+ +use rustc_hir as hir;
+ +use rustc_lint::LateContext;
+ +use rustc_span::source_map::Span;
+ +use rustc_span::symbol::{kw, sym};
+ +use std::borrow::Cow;
+ +
+ +use super::OR_FUN_CALL;
+ +
+ +/// Checks for the `OR_FUN_CALL` lint.
+ +#[allow(clippy::too_many_lines)]
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    expr: &hir::Expr<'_>,
+ +    method_span: Span,
+ +    name: &str,
+ +    args: &'tcx [hir::Expr<'_>],
+ +) {
+ +    /// Checks for `unwrap_or(T::new())` or `unwrap_or(T::default())`.
++    #[allow(clippy::too_many_arguments)]
+ +    fn check_unwrap_or_default(
+ +        cx: &LateContext<'_>,
+ +        name: &str,
+ +        fun: &hir::Expr<'_>,
+ +        self_expr: &hir::Expr<'_>,
+ +        arg: &hir::Expr<'_>,
+ +        or_has_args: bool,
+ +        span: Span,
++        method_span: Span,
+ +    ) -> bool {
+ +        let is_default_default = || is_trait_item(cx, fun, sym::Default);
+ +
+ +        let implements_default = |arg, default_trait_id| {
+ +            let arg_ty = cx.typeck_results().expr_ty(arg);
+ +            implements_trait(cx, arg_ty, default_trait_id, &[])
+ +        };
+ +
+ +        if_chain! {
+ +            if !or_has_args;
+ +            if name == "unwrap_or";
+ +            if let hir::ExprKind::Path(ref qpath) = fun.kind;
+ +            if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default);
+ +            let path = last_path_segment(qpath).ident.name;
+ +            // needs to target Default::default in particular or be *::new and have a Default impl
+ +            // available
+ +            if (matches!(path, kw::Default) && is_default_default())
+ +                || (matches!(path, sym::new) && implements_default(arg, default_trait_id));
+ +
+ +            then {
+ +                let mut applicability = Applicability::MachineApplicable;
++                let hint = "unwrap_or_default()";
++                let mut sugg_span = span;
++
++                let mut sugg: String = format!(
++                    "{}.{}",
++                    snippet_with_applicability(cx, self_expr.span, "..", &mut applicability),
++                    hint
++                );
++
++                if sugg.lines().count() > MAX_SUGGESTION_HIGHLIGHT_LINES {
++                    sugg_span = method_span.with_hi(span.hi());
++                    sugg = hint.to_string();
++                }
++
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    OR_FUN_CALL,
-                     format!(
-                         "{}.unwrap_or_default()",
-                         snippet_with_applicability(cx, self_expr.span, "..", &mut applicability)
-                     ),
++                    sugg_span,
+ +                    &format!("use of `{}` followed by a call to `{}`", name, path),
+ +                    "try this",
-                 if !check_unwrap_or_default(cx, name, fun, self_arg, arg, or_has_args, expr.span) {
++                    sugg,
+ +                    applicability,
+ +                );
+ +
+ +                true
+ +            } else {
+ +                false
+ +            }
+ +        }
+ +    }
+ +
+ +    /// Checks for `*or(foo())`.
+ +    #[allow(clippy::too_many_arguments)]
+ +    fn check_general_case<'tcx>(
+ +        cx: &LateContext<'tcx>,
+ +        name: &str,
+ +        method_span: Span,
+ +        self_expr: &hir::Expr<'_>,
+ +        arg: &'tcx hir::Expr<'_>,
+ +        span: Span,
+ +        // None if lambda is required
+ +        fun_span: Option<Span>,
+ +    ) {
+ +        // (path, fn_has_argument, methods, suffix)
+ +        static KNOW_TYPES: [(&[&str], bool, &[&str], &str); 4] = [
+ +            (&paths::BTREEMAP_ENTRY, false, &["or_insert"], "with"),
+ +            (&paths::HASHMAP_ENTRY, false, &["or_insert"], "with"),
+ +            (&paths::OPTION, false, &["map_or", "ok_or", "or", "unwrap_or"], "else"),
+ +            (&paths::RESULT, true, &["or", "unwrap_or"], "else"),
+ +        ];
+ +
+ +        if_chain! {
+ +            if KNOW_TYPES.iter().any(|k| k.2.contains(&name));
+ +
+ +            if switch_to_lazy_eval(cx, arg);
+ +            if !contains_return(arg);
+ +
+ +            let self_ty = cx.typeck_results().expr_ty(self_expr);
+ +
+ +            if let Some(&(_, fn_has_arguments, poss, suffix)) =
+ +                KNOW_TYPES.iter().find(|&&i| match_type(cx, self_ty, i.0));
+ +
+ +            if poss.contains(&name);
+ +
+ +            then {
+ +                let macro_expanded_snipped;
+ +                let sugg: Cow<'_, str> = {
+ +                    let (snippet_span, use_lambda) = match (fn_has_arguments, fun_span) {
+ +                        (false, Some(fun_span)) => (fun_span, false),
+ +                        _ => (arg.span, true),
+ +                    };
+ +                    let snippet = {
+ +                        let not_macro_argument_snippet = snippet_with_macro_callsite(cx, snippet_span, "..");
+ +                        if not_macro_argument_snippet == "vec![]" {
+ +                            macro_expanded_snipped = snippet(cx, snippet_span, "..");
+ +                            match macro_expanded_snipped.strip_prefix("$crate::vec::") {
+ +                                Some(stripped) => Cow::from(stripped),
+ +                                None => macro_expanded_snipped
+ +                            }
+ +                        }
+ +                        else {
+ +                            not_macro_argument_snippet
+ +                        }
+ +                    };
+ +
+ +                    if use_lambda {
+ +                        let l_arg = if fn_has_arguments { "_" } else { "" };
+ +                        format!("|{}| {}", l_arg, snippet).into()
+ +                    } else {
+ +                        snippet
+ +                    }
+ +                };
+ +                let span_replace_word = method_span.with_hi(span.hi());
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    OR_FUN_CALL,
+ +                    span_replace_word,
+ +                    &format!("use of `{}` followed by a function call", name),
+ +                    "try this",
+ +                    format!("{}_{}({})", name, suffix, sugg),
+ +                    Applicability::HasPlaceholders,
+ +                );
+ +            }
+ +        }
+ +    }
+ +
+ +    if let [self_arg, arg] = args {
+ +        let inner_arg = if let hir::ExprKind::Block(
+ +            hir::Block {
+ +                stmts: [],
+ +                expr: Some(expr),
+ +                ..
+ +            },
+ +            _,
+ +        ) = arg.kind
+ +        {
+ +            expr
+ +        } else {
+ +            arg
+ +        };
+ +        match inner_arg.kind {
+ +            hir::ExprKind::Call(fun, or_args) => {
+ +                let or_has_args = !or_args.is_empty();
++                if !check_unwrap_or_default(cx, name, fun, self_arg, arg, or_has_args, expr.span, method_span) {
+ +                    let fun_span = if or_has_args { None } else { Some(fun.span) };
+ +                    check_general_case(cx, name, method_span, self_arg, arg, expr.span, fun_span);
+ +                }
+ +            },
+ +            hir::ExprKind::Index(..) | hir::ExprKind::MethodCall(..) => {
+ +                check_general_case(cx, name, method_span, self_arg, arg, expr.span, None);
+ +            },
+ +            _ => (),
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/misc.rs

index 21b3f81d5d981978df903b8e2251eeac41c681ed,0000000000000000000000000000000000000000..8db71d1e967620ca73267880368df8dafc609090

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/misc.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/misc.rs
@@@ -1,789 -1,0 +1,806 @@@
-                     hint = format!("{} == {}", expr_snip, snippet(cx, other.span, ".."));
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
+ +use clippy_utils::source::{snippet, snippet_opt};
+ +use clippy_utils::ty::implements_trait;
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::LitKind;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::intravisit::FnKind;
+ +use rustc_hir::{
+ +    self as hir, def, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, HirId, Mutability, PatKind, Stmt,
+ +    StmtKind, TyKind, UnOp,
+ +};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_middle::lint::in_external_macro;
+ +use rustc_middle::ty::{self, Ty};
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::hygiene::DesugaringKind;
+ +use rustc_span::source_map::{ExpnKind, Span};
+ +use rustc_span::symbol::sym;
+ +
+ +use clippy_utils::consts::{constant, Constant};
+ +use clippy_utils::sugg::Sugg;
+ +use clippy_utils::{
+ +    expr_path_res, get_item_name, get_parent_expr, in_constant, is_diag_trait_item, is_integer_const, iter_input_pats,
+ +    last_path_segment, match_any_def_paths, paths, unsext, SpanlessEq,
+ +};
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for function arguments and let bindings denoted as
+ +    /// `ref`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The `ref` declaration makes the function take an owned
+ +    /// value, but turns the argument into a reference (which means that the value
+ +    /// is destroyed when exiting the function). This adds not much value: either
+ +    /// take a reference type, or take an owned value and create references in the
+ +    /// body.
+ +    ///
+ +    /// For let bindings, `let x = &foo;` is preferred over `let ref x = foo`. The
+ +    /// type of `x` is more obvious with the former.
+ +    ///
+ +    /// ### Known problems
+ +    /// If the argument is dereferenced within the function,
+ +    /// removing the `ref` will lead to errors. This can be fixed by removing the
+ +    /// dereferences, e.g., changing `*x` to `x` within the function.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// // Bad
+ +    /// fn foo(ref x: u8) -> bool {
+ +    ///     true
+ +    /// }
+ +    ///
+ +    /// // Good
+ +    /// fn foo(x: &u8) -> bool {
+ +    ///     true
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub TOPLEVEL_REF_ARG,
+ +    style,
+ +    "an entire binding declared as `ref`, in a function argument or a `let` statement"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for comparisons to NaN.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// NaN does not compare meaningfully to anything – not
+ +    /// even itself – so those comparisons are simply wrong.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = 1.0;
+ +    ///
+ +    /// // Bad
+ +    /// if x == f32::NAN { }
+ +    ///
+ +    /// // Good
+ +    /// if x.is_nan() { }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub CMP_NAN,
+ +    correctness,
+ +    "comparisons to `NAN`, which will always return false, probably not intended"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for (in-)equality comparisons on floating-point
+ +    /// values (apart from zero), except in functions called `*eq*` (which probably
+ +    /// implement equality for a type involving floats).
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Floating point calculations are usually imprecise, so
+ +    /// asking if two values are *exactly* equal is asking for trouble. For a good
+ +    /// guide on what to do, see [the floating point
+ +    /// guide](http://www.floating-point-gui.de/errors/comparison).
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let x = 1.2331f64;
+ +    /// let y = 1.2332f64;
+ +    ///
+ +    /// // Bad
+ +    /// if y == 1.23f64 { }
+ +    /// if y != x {} // where both are floats
+ +    ///
+ +    /// // Good
+ +    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
+ +    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
+ +    /// // let error_margin = std::f64::EPSILON;
+ +    /// if (y - 1.23f64).abs() < error_margin { }
+ +    /// if (y - x).abs() > error_margin { }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub FLOAT_CMP,
+ +    pedantic,
+ +    "using `==` or `!=` on float values instead of comparing difference with an epsilon"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for conversions to owned values just for the sake
+ +    /// of a comparison.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The comparison can operate on a reference, so creating
+ +    /// an owned value effectively throws it away directly afterwards, which is
+ +    /// needlessly consuming code and heap space.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = "foo";
+ +    /// # let y = String::from("foo");
+ +    /// if x.to_owned() == y {}
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust
+ +    /// # let x = "foo";
+ +    /// # let y = String::from("foo");
+ +    /// if x == y {}
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub CMP_OWNED,
+ +    perf,
+ +    "creating owned instances for comparing with others, e.g., `x == \"foo\".to_string()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for getting the remainder of a division by one or minus
+ +    /// one.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The result for a divisor of one can only ever be zero; for
+ +    /// minus one it can cause panic/overflow (if the left operand is the minimal value of
+ +    /// the respective integer type) or results in zero. No one will write such code
+ +    /// deliberately, unless trying to win an Underhanded Rust Contest. Even for that
+ +    /// contest, it's probably a bad idea. Use something more underhanded.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = 1;
+ +    /// let a = x % 1;
+ +    /// let a = x % -1;
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub MODULO_ONE,
+ +    correctness,
+ +    "taking a number modulo +/-1, which can either panic/overflow or always returns 0"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for the use of bindings with a single leading
+ +    /// underscore.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// A single leading underscore is usually used to indicate
+ +    /// that a binding will not be used. Using such a binding breaks this
+ +    /// expectation.
+ +    ///
+ +    /// ### Known problems
+ +    /// The lint does not work properly with desugaring and
+ +    /// macro, it has been allowed in the mean time.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let _x = 0;
+ +    /// let y = _x + 1; // Here we are using `_x`, even though it has a leading
+ +    ///                 // underscore. We should rename `_x` to `x`
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub USED_UNDERSCORE_BINDING,
+ +    pedantic,
+ +    "using a binding which is prefixed with an underscore"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for the use of short circuit boolean conditions as
+ +    /// a
+ +    /// statement.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Using a short circuit boolean condition as a statement
+ +    /// may hide the fact that the second part is executed or not depending on the
+ +    /// outcome of the first part.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// f() && g(); // We should write `if f() { g(); }`.
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub SHORT_CIRCUIT_STATEMENT,
+ +    complexity,
+ +    "using a short circuit boolean condition as a statement"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Catch casts from `0` to some pointer type
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This generally means `null` and is better expressed as
+ +    /// {`std`, `core`}`::ptr::`{`null`, `null_mut`}.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // Bad
+ +    /// let a = 0 as *const u32;
+ +    ///
+ +    /// // Good
+ +    /// let a = std::ptr::null::<u32>();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub ZERO_PTR,
+ +    style,
+ +    "using `0 as *{const, mut} T`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for (in-)equality comparisons on floating-point
+ +    /// value and constant, except in functions called `*eq*` (which probably
+ +    /// implement equality for a type involving floats).
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Floating point calculations are usually imprecise, so
+ +    /// asking if two values are *exactly* equal is asking for trouble. For a good
+ +    /// guide on what to do, see [the floating point
+ +    /// guide](http://www.floating-point-gui.de/errors/comparison).
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let x: f64 = 1.0;
+ +    /// const ONE: f64 = 1.00;
+ +    ///
+ +    /// // Bad
+ +    /// if x == ONE { } // where both are floats
+ +    ///
+ +    /// // Good
+ +    /// let error_margin = f64::EPSILON; // Use an epsilon for comparison
+ +    /// // Or, if Rust <= 1.42, use `std::f64::EPSILON` constant instead.
+ +    /// // let error_margin = std::f64::EPSILON;
+ +    /// if (x - ONE).abs() < error_margin { }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub FLOAT_CMP_CONST,
+ +    restriction,
+ +    "using `==` or `!=` on float constants instead of comparing difference with an epsilon"
+ +}
+ +
+ +declare_lint_pass!(MiscLints => [
+ +    TOPLEVEL_REF_ARG,
+ +    CMP_NAN,
+ +    FLOAT_CMP,
+ +    CMP_OWNED,
+ +    MODULO_ONE,
+ +    USED_UNDERSCORE_BINDING,
+ +    SHORT_CIRCUIT_STATEMENT,
+ +    ZERO_PTR,
+ +    FLOAT_CMP_CONST
+ +]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for MiscLints {
+ +    fn check_fn(
+ +        &mut self,
+ +        cx: &LateContext<'tcx>,
+ +        k: FnKind<'tcx>,
+ +        decl: &'tcx FnDecl<'_>,
+ +        body: &'tcx Body<'_>,
+ +        span: Span,
+ +        _: HirId,
+ +    ) {
+ +        if let FnKind::Closure = k {
+ +            // Does not apply to closures
+ +            return;
+ +        }
+ +        if in_external_macro(cx.tcx.sess, span) {
+ +            return;
+ +        }
+ +        for arg in iter_input_pats(decl, body) {
+ +            if let PatKind::Binding(BindingAnnotation::Ref | BindingAnnotation::RefMut, ..) = arg.pat.kind {
+ +                span_lint(
+ +                    cx,
+ +                    TOPLEVEL_REF_ARG,
+ +                    arg.pat.span,
+ +                    "`ref` directly on a function argument is ignored. \
+ +                    Consider using a reference type instead",
+ +                );
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
+ +        if_chain! {
+ +            if !in_external_macro(cx.tcx.sess, stmt.span);
+ +            if let StmtKind::Local(local) = stmt.kind;
+ +            if let PatKind::Binding(an, .., name, None) = local.pat.kind;
+ +            if let Some(init) = local.init;
+ +            if an == BindingAnnotation::Ref || an == BindingAnnotation::RefMut;
+ +            then {
+ +                // use the macro callsite when the init span (but not the whole local span)
+ +                // comes from an expansion like `vec![1, 2, 3]` in `let ref _ = vec![1, 2, 3];`
+ +                let sugg_init = if init.span.from_expansion() && !local.span.from_expansion() {
+ +                    Sugg::hir_with_macro_callsite(cx, init, "..")
+ +                } else {
+ +                    Sugg::hir(cx, init, "..")
+ +                };
+ +                let (mutopt, initref) = if an == BindingAnnotation::RefMut {
+ +                    ("mut ", sugg_init.mut_addr())
+ +                } else {
+ +                    ("", sugg_init.addr())
+ +                };
+ +                let tyopt = if let Some(ty) = local.ty {
+ +                    format!(": &{mutopt}{ty}", mutopt=mutopt, ty=snippet(cx, ty.span, ".."))
+ +                } else {
+ +                    String::new()
+ +                };
+ +                span_lint_hir_and_then(
+ +                    cx,
+ +                    TOPLEVEL_REF_ARG,
+ +                    init.hir_id,
+ +                    local.pat.span,
+ +                    "`ref` on an entire `let` pattern is discouraged, take a reference with `&` instead",
+ +                    |diag| {
+ +                        diag.span_suggestion(
+ +                            stmt.span,
+ +                            "try",
+ +                            format!(
+ +                                "let {name}{tyopt} = {initref};",
+ +                                name=snippet(cx, name.span, ".."),
+ +                                tyopt=tyopt,
+ +                                initref=initref,
+ +                            ),
+ +                            Applicability::MachineApplicable,
+ +                        );
+ +                    }
+ +                );
+ +            }
+ +        };
+ +        if_chain! {
+ +            if let StmtKind::Semi(expr) = stmt.kind;
+ +            if let ExprKind::Binary(ref binop, a, b) = expr.kind;
+ +            if binop.node == BinOpKind::And || binop.node == BinOpKind::Or;
+ +            if let Some(sugg) = Sugg::hir_opt(cx, a);
+ +            then {
+ +                span_lint_hir_and_then(
+ +                    cx,
+ +                    SHORT_CIRCUIT_STATEMENT,
+ +                    expr.hir_id,
+ +                    stmt.span,
+ +                    "boolean short circuit operator in statement may be clearer using an explicit test",
+ +                    |diag| {
+ +                        let sugg = if binop.node == BinOpKind::Or { !sugg } else { sugg };
+ +                        diag.span_suggestion(
+ +                            stmt.span,
+ +                            "replace it with",
+ +                            format!(
+ +                                "if {} {{ {}; }}",
+ +                                sugg,
+ +                                &snippet(cx, b.span, ".."),
+ +                            ),
+ +                            Applicability::MachineApplicable, // snippet
+ +                        );
+ +                    });
+ +            }
+ +        };
+ +    }
+ +
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        match expr.kind {
+ +            ExprKind::Cast(e, ty) => {
+ +                check_cast(cx, expr.span, e, ty);
+ +                return;
+ +            },
+ +            ExprKind::Binary(ref cmp, left, right) => {
+ +                check_binary(cx, expr, cmp, left, right);
+ +                return;
+ +            },
+ +            _ => {},
+ +        }
+ +        if in_attributes_expansion(expr) || expr.span.is_desugaring(DesugaringKind::Await) {
+ +            // Don't lint things expanded by #[derive(...)], etc or `await` desugaring
+ +            return;
+ +        }
+ +        let sym;
+ +        let binding = match expr.kind {
+ +            ExprKind::Path(ref qpath) if !matches!(qpath, hir::QPath::LangItem(..)) => {
+ +                let binding = last_path_segment(qpath).ident.as_str();
+ +                if binding.starts_with('_') &&
+ +                    !binding.starts_with("__") &&
+ +                    binding != "_result" && // FIXME: #944
+ +                    is_used(cx, expr) &&
+ +                    // don't lint if the declaration is in a macro
+ +                    non_macro_local(cx, cx.qpath_res(qpath, expr.hir_id))
+ +                {
+ +                    Some(binding)
+ +                } else {
+ +                    None
+ +                }
+ +            },
+ +            ExprKind::Field(_, ident) => {
+ +                sym = ident.name;
+ +                let name = sym.as_str();
+ +                if name.starts_with('_') && !name.starts_with("__") {
+ +                    Some(name)
+ +                } else {
+ +                    None
+ +                }
+ +            },
+ +            _ => None,
+ +        };
+ +        if let Some(binding) = binding {
+ +            span_lint(
+ +                cx,
+ +                USED_UNDERSCORE_BINDING,
+ +                expr.span,
+ +                &format!(
+ +                    "used binding `{}` which is prefixed with an underscore. A leading \
+ +                     underscore signals that a binding will not be used",
+ +                    binding
+ +                ),
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +fn get_lint_and_message(
+ +    is_comparing_constants: bool,
+ +    is_comparing_arrays: bool,
+ +) -> (&'static rustc_lint::Lint, &'static str) {
+ +    if is_comparing_constants {
+ +        (
+ +            FLOAT_CMP_CONST,
+ +            if is_comparing_arrays {
+ +                "strict comparison of `f32` or `f64` constant arrays"
+ +            } else {
+ +                "strict comparison of `f32` or `f64` constant"
+ +            },
+ +        )
+ +    } else {
+ +        (
+ +            FLOAT_CMP,
+ +            if is_comparing_arrays {
+ +                "strict comparison of `f32` or `f64` arrays"
+ +            } else {
+ +                "strict comparison of `f32` or `f64`"
+ +            },
+ +        )
+ +    }
+ +}
+ +
+ +fn check_nan(cx: &LateContext<'_>, expr: &Expr<'_>, cmp_expr: &Expr<'_>) {
+ +    if_chain! {
+ +        if !in_constant(cx, cmp_expr.hir_id);
+ +        if let Some((value, _)) = constant(cx, cx.typeck_results(), expr);
+ +        if match value {
+ +            Constant::F32(num) => num.is_nan(),
+ +            Constant::F64(num) => num.is_nan(),
+ +            _ => false,
+ +        };
+ +        then {
+ +            span_lint(
+ +                cx,
+ +                CMP_NAN,
+ +                cmp_expr.span,
+ +                "doomed comparison with `NAN`, use `{f32,f64}::is_nan()` instead",
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +fn is_named_constant<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+ +    if let Some((_, res)) = constant(cx, cx.typeck_results(), expr) {
+ +        res
+ +    } else {
+ +        false
+ +    }
+ +}
+ +
+ +fn is_allowed<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
+ +    match constant(cx, cx.typeck_results(), expr) {
+ +        Some((Constant::F32(f), _)) => f == 0.0 || f.is_infinite(),
+ +        Some((Constant::F64(f), _)) => f == 0.0 || f.is_infinite(),
+ +        Some((Constant::Vec(vec), _)) => vec.iter().all(|f| match f {
+ +            Constant::F32(f) => *f == 0.0 || (*f).is_infinite(),
+ +            Constant::F64(f) => *f == 0.0 || (*f).is_infinite(),
+ +            _ => false,
+ +        }),
+ +        _ => false,
+ +    }
+ +}
+ +
+ +// Return true if `expr` is the result of `signum()` invoked on a float value.
+ +fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    // The negation of a signum is still a signum
+ +    if let ExprKind::Unary(UnOp::Neg, child_expr) = expr.kind {
+ +        return is_signum(cx, child_expr);
+ +    }
+ +
+ +    if_chain! {
+ +        if let ExprKind::MethodCall(method_name, _, [ref self_arg, ..], _) = expr.kind;
+ +        if sym!(signum) == method_name.ident.name;
+ +        // Check that the receiver of the signum() is a float (expressions[0] is the receiver of
+ +        // the method call)
+ +        then {
+ +            return is_float(cx, self_arg);
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +fn is_float(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    let value = &cx.typeck_results().expr_ty(expr).peel_refs().kind();
+ +
+ +    if let ty::Array(arr_ty, _) = value {
+ +        return matches!(arr_ty.kind(), ty::Float(_));
+ +    };
+ +
+ +    matches!(value, ty::Float(_))
+ +}
+ +
+ +fn is_array(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _))
+ +}
+ +
++#[allow(clippy::too_many_lines)]
+ +fn check_to_owned(cx: &LateContext<'_>, expr: &Expr<'_>, other: &Expr<'_>, left: bool) {
+ +    #[derive(Default)]
+ +    struct EqImpl {
+ +        ty_eq_other: bool,
+ +        other_eq_ty: bool,
+ +    }
+ +
+ +    impl EqImpl {
+ +        fn is_implemented(&self) -> bool {
+ +            self.ty_eq_other || self.other_eq_ty
+ +        }
+ +    }
+ +
+ +    fn symmetric_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> Option<EqImpl> {
+ +        cx.tcx.lang_items().eq_trait().map(|def_id| EqImpl {
+ +            ty_eq_other: implements_trait(cx, ty, def_id, &[other.into()]),
+ +            other_eq_ty: implements_trait(cx, other, def_id, &[ty.into()]),
+ +        })
+ +    }
+ +
+ +    let (arg_ty, snip) = match expr.kind {
+ +        ExprKind::MethodCall(.., args, _) if args.len() == 1 => {
+ +            if_chain!(
+ +                if let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id);
+ +                if is_diag_trait_item(cx, expr_def_id, sym::ToString)
+ +                    || is_diag_trait_item(cx, expr_def_id, sym::ToOwned);
+ +                then {
+ +                    (cx.typeck_results().expr_ty(&args[0]), snippet(cx, args[0].span, ".."))
+ +                } else {
+ +                    return;
+ +                }
+ +            )
+ +        },
+ +        ExprKind::Call(path, [arg]) => {
+ +            if expr_path_res(cx, path)
+ +                .opt_def_id()
+ +                .and_then(|id| match_any_def_paths(cx, id, &[&paths::FROM_STR_METHOD, &paths::FROM_FROM]))
+ +                .is_some()
+ +            {
+ +                (cx.typeck_results().expr_ty(arg), snippet(cx, arg.span, ".."))
+ +            } else {
+ +                return;
+ +            }
+ +        },
+ +        _ => return,
+ +    };
+ +
+ +    let other_ty = cx.typeck_results().expr_ty(other);
+ +
+ +    let without_deref = symmetric_partial_eq(cx, arg_ty, other_ty).unwrap_or_default();
+ +    let with_deref = arg_ty
+ +        .builtin_deref(true)
+ +        .and_then(|tam| symmetric_partial_eq(cx, tam.ty, other_ty))
+ +        .unwrap_or_default();
+ +
+ +    if !with_deref.is_implemented() && !without_deref.is_implemented() {
+ +        return;
+ +    }
+ +
+ +    let other_gets_derefed = matches!(other.kind, ExprKind::Unary(UnOp::Deref, _));
+ +
+ +    let lint_span = if other_gets_derefed {
+ +        expr.span.to(other.span)
+ +    } else {
+ +        expr.span
+ +    };
+ +
+ +    span_lint_and_then(
+ +        cx,
+ +        CMP_OWNED,
+ +        lint_span,
+ +        "this creates an owned instance just for comparison",
+ +        |diag| {
+ +            // This also catches `PartialEq` implementations that call `to_owned`.
+ +            if other_gets_derefed {
+ +                diag.span_label(lint_span, "try implementing the comparison without allocating");
+ +                return;
+ +            }
+ +
+ +            let expr_snip;
+ +            let eq_impl;
+ +            if with_deref.is_implemented() {
+ +                expr_snip = format!("*{}", snip);
+ +                eq_impl = with_deref;
+ +            } else {
+ +                expr_snip = snip.to_string();
+ +                eq_impl = without_deref;
+ +            };
+ +
+ +            let span;
+ +            let hint;
+ +            if (eq_impl.ty_eq_other && left) || (eq_impl.other_eq_ty && !left) {
+ +                span = expr.span;
+ +                hint = expr_snip;
+ +            } else {
+ +                span = expr.span.to(other.span);
++
++                let cmp_span = if other.span < expr.span {
++                    other.span.between(expr.span)
++                } else {
++                    expr.span.between(other.span)
++                };
+ +                if eq_impl.ty_eq_other {
-                     hint = format!("{} == {}", snippet(cx, other.span, ".."), expr_snip);
++                    hint = format!(
++                        "{}{}{}",
++                        expr_snip,
++                        snippet(cx, cmp_span, ".."),
++                        snippet(cx, other.span, "..")
++                    );
+ +                } else {
++                    hint = format!(
++                        "{}{}{}",
++                        snippet(cx, other.span, ".."),
++                        snippet(cx, cmp_span, ".."),
++                        expr_snip
++                    );
+ +                }
+ +            }
+ +
+ +            diag.span_suggestion(
+ +                span,
+ +                "try",
+ +                hint,
+ +                Applicability::MachineApplicable, // snippet
+ +            );
+ +        },
+ +    );
+ +}
+ +
+ +/// Heuristic to see if an expression is used. Should be compatible with
+ +/// `unused_variables`'s idea
+ +/// of what it means for an expression to be "used".
+ +fn is_used(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    get_parent_expr(cx, expr).map_or(true, |parent| match parent.kind {
+ +        ExprKind::Assign(_, rhs, _) | ExprKind::AssignOp(_, _, rhs) => SpanlessEq::new(cx).eq_expr(rhs, expr),
+ +        _ => is_used(cx, parent),
+ +    })
+ +}
+ +
+ +/// Tests whether an expression is in a macro expansion (e.g., something
+ +/// generated by `#[derive(...)]` or the like).
+ +fn in_attributes_expansion(expr: &Expr<'_>) -> bool {
+ +    use rustc_span::hygiene::MacroKind;
+ +    if expr.span.from_expansion() {
+ +        let data = expr.span.ctxt().outer_expn_data();
+ +        matches!(data.kind, ExpnKind::Macro(MacroKind::Attr, _))
+ +    } else {
+ +        false
+ +    }
+ +}
+ +
+ +/// Tests whether `res` is a variable defined outside a macro.
+ +fn non_macro_local(cx: &LateContext<'_>, res: def::Res) -> bool {
+ +    if let def::Res::Local(id) = res {
+ +        !cx.tcx.hir().span(id).from_expansion()
+ +    } else {
+ +        false
+ +    }
+ +}
+ +
+ +fn check_cast(cx: &LateContext<'_>, span: Span, e: &Expr<'_>, ty: &hir::Ty<'_>) {
+ +    if_chain! {
+ +        if let TyKind::Ptr(ref mut_ty) = ty.kind;
+ +        if let ExprKind::Lit(ref lit) = e.kind;
+ +        if let LitKind::Int(0, _) = lit.node;
+ +        if !in_constant(cx, e.hir_id);
+ +        then {
+ +            let (msg, sugg_fn) = match mut_ty.mutbl {
+ +                Mutability::Mut => ("`0 as *mut _` detected", "std::ptr::null_mut"),
+ +                Mutability::Not => ("`0 as *const _` detected", "std::ptr::null"),
+ +            };
+ +
+ +            let (sugg, appl) = if let TyKind::Infer = mut_ty.ty.kind {
+ +                (format!("{}()", sugg_fn), Applicability::MachineApplicable)
+ +            } else if let Some(mut_ty_snip) = snippet_opt(cx, mut_ty.ty.span) {
+ +                (format!("{}::<{}>()", sugg_fn, mut_ty_snip), Applicability::MachineApplicable)
+ +            } else {
+ +                // `MaybeIncorrect` as type inference may not work with the suggested code
+ +                (format!("{}()", sugg_fn), Applicability::MaybeIncorrect)
+ +            };
+ +            span_lint_and_sugg(cx, ZERO_PTR, span, msg, "try", sugg, appl);
+ +        }
+ +    }
+ +}
+ +
+ +fn check_binary<'a>(
+ +    cx: &LateContext<'a>,
+ +    expr: &Expr<'_>,
+ +    cmp: &rustc_span::source_map::Spanned<rustc_hir::BinOpKind>,
+ +    left: &'a Expr<'_>,
+ +    right: &'a Expr<'_>,
+ +) {
+ +    let op = cmp.node;
+ +    if op.is_comparison() {
+ +        check_nan(cx, left, expr);
+ +        check_nan(cx, right, expr);
+ +        check_to_owned(cx, left, right, true);
+ +        check_to_owned(cx, right, left, false);
+ +    }
+ +    if (op == BinOpKind::Eq || op == BinOpKind::Ne) && (is_float(cx, left) || is_float(cx, right)) {
+ +        if is_allowed(cx, left) || is_allowed(cx, right) {
+ +            return;
+ +        }
+ +
+ +        // Allow comparing the results of signum()
+ +        if is_signum(cx, left) && is_signum(cx, right) {
+ +            return;
+ +        }
+ +
+ +        if let Some(name) = get_item_name(cx, expr) {
+ +            let name = name.as_str();
+ +            if name == "eq" || name == "ne" || name == "is_nan" || name.starts_with("eq_") || name.ends_with("_eq") {
+ +                return;
+ +            }
+ +        }
+ +        let is_comparing_arrays = is_array(cx, left) || is_array(cx, right);
+ +        let (lint, msg) = get_lint_and_message(
+ +            is_named_constant(cx, left) || is_named_constant(cx, right),
+ +            is_comparing_arrays,
+ +        );
+ +        span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+ +            let lhs = Sugg::hir(cx, left, "..");
+ +            let rhs = Sugg::hir(cx, right, "..");
+ +
+ +            if !is_comparing_arrays {
+ +                diag.span_suggestion(
+ +                    expr.span,
+ +                    "consider comparing them within some margin of error",
+ +                    format!(
+ +                        "({}).abs() {} error_margin",
+ +                        lhs - rhs,
+ +                        if op == BinOpKind::Eq { '<' } else { '>' }
+ +                    ),
+ +                    Applicability::HasPlaceholders, // snippet
+ +                );
+ +            }
+ +            diag.note("`f32::EPSILON` and `f64::EPSILON` are available for the `error_margin`");
+ +        });
+ +    } else if op == BinOpKind::Rem {
+ +        if is_integer_const(cx, right, 1) {
+ +            span_lint(cx, MODULO_ONE, expr.span, "any number modulo 1 will be 0");
+ +        }
+ +
+ +        if let ty::Int(ity) = cx.typeck_results().expr_ty(right).kind() {
+ +            if is_integer_const(cx, right, unsext(cx.tcx, -1, *ity)) {
+ +                span_lint(
+ +                    cx,
+ +                    MODULO_ONE,
+ +                    expr.span,
+ +                    "any number modulo -1 will panic/overflow or result in 0",
+ +                );
+ +            }
+ +        };
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs

index 5dafd08cf3be0e754b8d9e1d29b4076a2a5c5448,0000000000000000000000000000000000000000..79f104eac0be24c9e5b55e719021af891613471a

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs
@@@ -1,132 -1,0 +1,132 @@@
-     suspicious,
+ +use clippy_utils::diagnostics::span_lint_and_help;
+ +use clippy_utils::ty::is_must_use_ty;
+ +use clippy_utils::{nth_arg, return_ty};
+ +use rustc_hir::def_id::LocalDefId;
+ +use rustc_hir::intravisit::FnKind;
+ +use rustc_hir::{Body, FnDecl, HirId, TraitItem, TraitItemKind};
+ +use rustc_lint::{LateContext, LateLintPass, LintContext};
+ +use rustc_middle::lint::in_external_macro;
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::{sym, Span};
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// This lint warns when a method returning `Self` doesn't have the `#[must_use]` attribute.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Methods returning `Self` often create new values, having the `#[must_use]` attribute
+ +    /// prevents users from "forgetting" to use the newly created value.
+ +    ///
+ +    /// The `#[must_use]` attribute can be added to the type itself to ensure that instances
+ +    /// are never forgotten. Functions returning a type marked with `#[must_use]` will not be
+ +    /// linted, as the usage is already enforced by the type attribute.
+ +    ///
+ +    /// ### Limitations
+ +    /// This lint is only applied on methods taking a `self` argument. It would be mostly noise
+ +    /// if it was added on constructors for example.
+ +    ///
+ +    /// ### Example
+ +    /// Missing attribute
+ +    /// ```rust
+ +    /// pub struct Bar;
+ +    /// impl Bar {
+ +    ///     // Bad
+ +    ///     pub fn bar(&self) -> Self {
+ +    ///         Self
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// It's better to have the `#[must_use]` attribute on the method like this:
+ +    /// ```rust
+ +    /// pub struct Bar;
+ +    /// impl Bar {
+ +    ///     #[must_use]
+ +    ///     pub fn bar(&self) -> Self {
+ +    ///         Self
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// Or on the type definition like this:
+ +    /// ```rust
+ +    /// #[must_use]
+ +    /// pub struct Bar;
+ +    /// impl Bar {
+ +    ///     pub fn bar(&self) -> Self {
+ +    ///         Self
+ +    ///     }
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "1.59.0"]
+ +    pub RETURN_SELF_NOT_MUST_USE,
++    pedantic,
+ +    "missing `#[must_use]` annotation on a method returning `Self`"
+ +}
+ +
+ +declare_lint_pass!(ReturnSelfNotMustUse => [RETURN_SELF_NOT_MUST_USE]);
+ +
+ +fn check_method(cx: &LateContext<'_>, decl: &FnDecl<'_>, fn_def: LocalDefId, span: Span, hir_id: HirId) {
+ +    if_chain! {
+ +        // If it comes from an external macro, better ignore it.
+ +        if !in_external_macro(cx.sess(), span);
+ +        if decl.implicit_self.has_implicit_self();
+ +        // We only show this warning for public exported methods.
+ +        if cx.access_levels.is_exported(fn_def);
+ +        // We don't want to emit this lint if the `#[must_use]` attribute is already there.
+ +        if !cx.tcx.hir().attrs(hir_id).iter().any(|attr| attr.has_name(sym::must_use));
+ +        if cx.tcx.visibility(fn_def.to_def_id()).is_public();
+ +        let ret_ty = return_ty(cx, hir_id);
+ +        let self_arg = nth_arg(cx, hir_id, 0);
+ +        // If `Self` has the same type as the returned type, then we want to warn.
+ +        //
+ +        // For this check, we don't want to remove the reference on the returned type because if
+ +        // there is one, we shouldn't emit a warning!
+ +        if self_arg.peel_refs() == ret_ty;
+ +        // If `Self` is already marked as `#[must_use]`, no need for the attribute here.
+ +        if !is_must_use_ty(cx, ret_ty);
+ +
+ +        then {
+ +            span_lint_and_help(
+ +                cx,
+ +                RETURN_SELF_NOT_MUST_USE,
+ +                span,
+ +                "missing `#[must_use]` attribute on a method returning `Self`",
+ +                None,
+ +                "consider adding the `#[must_use]` attribute to the method or directly to the `Self` type"
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +impl<'tcx> LateLintPass<'tcx> for ReturnSelfNotMustUse {
+ +    fn check_fn(
+ +        &mut self,
+ +        cx: &LateContext<'tcx>,
+ +        kind: FnKind<'tcx>,
+ +        decl: &'tcx FnDecl<'tcx>,
+ +        _: &'tcx Body<'tcx>,
+ +        span: Span,
+ +        hir_id: HirId,
+ +    ) {
+ +        if_chain! {
+ +            // We are only interested in methods, not in functions or associated functions.
+ +            if matches!(kind, FnKind::Method(_, _, _));
+ +            if let Some(fn_def) = cx.tcx.hir().opt_local_def_id(hir_id);
+ +            if let Some(impl_def) = cx.tcx.impl_of_method(fn_def.to_def_id());
+ +            // We don't want this method to be te implementation of a trait because the
+ +            // `#[must_use]` should be put on the trait definition directly.
+ +            if cx.tcx.trait_id_of_impl(impl_def).is_none();
+ +
+ +            then {
+ +                check_method(cx, decl, fn_def, span, hir_id);
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'tcx>) {
+ +        if let TraitItemKind::Fn(ref sig, _) = item.kind {
+ +            check_method(cx, sig.decl, item.def_id, item.span, item.hir_id());
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/rustc_tools_util/README.md

index 6027538dc4ab22a74ee3a0299a2849667b450dcf,0000000000000000000000000000000000000000..01891b51d3b0fc8f03d41143fc1af92b13ba91ac

mode 100644,000000..100644
--- 1/src/tools/clippy/rustc_tools_util/README.md
--- /dev/null
+++ b/src/tools/clippy/rustc_tools_util/README.md
@@@ -1,62 -1,0 +1,62 @@@
- Copyright 2014-2020 The Rust Project Developers
+ +# rustc_tools_util
+ +
+ +A small tool to help you generate version information
+ +for packages installed from a git repo
+ +
+ +## Usage
+ +
+ +Add a `build.rs` file to your repo and list it in `Cargo.toml`
+ +````
+ +build = "build.rs"
+ +````
+ +
+ +List rustc_tools_util as regular AND build dependency.
+ +````
+ +[dependencies]
+ +rustc_tools_util = "0.1"
+ +
+ +[build-dependencies]
+ +rustc_tools_util = "0.1"
+ +````
+ +
+ +In `build.rs`, generate the data in your `main()`
+ +````rust
+ +fn main() {
+ +    println!(
+ +        "cargo:rustc-env=GIT_HASH={}",
+ +        rustc_tools_util::get_commit_hash().unwrap_or_default()
+ +    );
+ +    println!(
+ +        "cargo:rustc-env=COMMIT_DATE={}",
+ +        rustc_tools_util::get_commit_date().unwrap_or_default()
+ +    );
+ +    println!(
+ +        "cargo:rustc-env=RUSTC_RELEASE_CHANNEL={}",
+ +        rustc_tools_util::get_channel().unwrap_or_default()
+ +    );
+ +}
+ +
+ +````
+ +
+ +Use the version information in your main.rs
+ +````rust
+ +use rustc_tools_util::*;
+ +
+ +fn show_version() {
+ +    let version_info = rustc_tools_util::get_version_info!();
+ +    println!("{}", version_info);
+ +}
+ +````
+ +This gives the following output in clippy:
+ +`clippy 0.0.212 (a416c5e 2018-12-14)`
+ +
+ +
+ +## License
+ +
++Copyright 2014-2022 The Rust Project Developers
+ +
+ +Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+ +http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+ +<LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+ +option. All files in the project carrying such notice may not be
+ +copied, modified, or distributed except according to those terms.
diff --cc src/tools/clippy/tests/ui/cmp_owned/comparison_flip.fixed

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..44e41bdd1148711497a4d8a7928b3650a919e557

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.fixed
@@@ -1,0 -1,0 +1,29 @@@
++// run-rustfix
++
++use std::fmt::{self, Display};
++
++fn main() {
++    let a = Foo;
++
++    if a != "bar" {
++        println!("foo");
++    }
++
++    if a != "bar" {
++        println!("foo");
++    }
++}
++
++struct Foo;
++
++impl Display for Foo {
++    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
++        write!(f, "foo")
++    }
++}
++
++impl PartialEq<&str> for Foo {
++    fn eq(&self, other: &&str) -> bool {
++        "foo" == *other
++    }
++}
diff --cc src/tools/clippy/tests/ui/cmp_owned/comparison_flip.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..662673abb62d9aee94b58b0e36746021a7c24d77

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.rs
@@@ -1,0 -1,0 +1,29 @@@
++// run-rustfix
++
++use std::fmt::{self, Display};
++
++fn main() {
++    let a = Foo;
++
++    if a.to_string() != "bar" {
++        println!("foo");
++    }
++
++    if "bar" != a.to_string() {
++        println!("foo");
++    }
++}
++
++struct Foo;
++
++impl Display for Foo {
++    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
++        write!(f, "foo")
++    }
++}
++
++impl PartialEq<&str> for Foo {
++    fn eq(&self, other: &&str) -> bool {
++        "foo" == *other
++    }
++}
diff --cc src/tools/clippy/tests/ui/cmp_owned/comparison_flip.stderr

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..e4d0d822bb1e341aa8dc0fc9bfbee2e923558b9b

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.stderr
@@@ -1,0 -1,0 +1,18 @@@
++error: this creates an owned instance just for comparison
++  --> $DIR/comparison_flip.rs:8:8
++   |
++LL |     if a.to_string() != "bar" {
++   |        ^^^^^^^^^^^^^ help: try: `a`
++   |
++   = note: `-D clippy::cmp-owned` implied by `-D warnings`
++
++error: this creates an owned instance just for comparison
++  --> $DIR/comparison_flip.rs:12:17
++   |
++LL |     if "bar" != a.to_string() {
++   |        ---------^^^^^^^^^^^^^
++   |        |
++   |        help: try: `a != "bar"`
++
++error: aborting due to 2 previous errors
++
diff --cc src/tools/clippy/tests/ui/format.fixed

index 64cb7b1cfb80f6c33ff5e81f7af29cceb1e8b73d,0000000000000000000000000000000000000000..78d2bfd474e4a18cbd9f687e488a69fd03ef076d

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/format.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/format.fixed
@@@ -1,76 -1,0 +1,82 @@@
+ +// run-rustfix
+ +
+ +#![allow(clippy::print_literal, clippy::redundant_clone, clippy::to_string_in_format_args)]
+ +#![warn(clippy::useless_format)]
+ +
+ +struct Foo(pub String);
+ +
+ +macro_rules! foo {
+ +    ($($t:tt)*) => (Foo(format!($($t)*)))
+ +}
+ +
+ +fn main() {
+ +    "foo".to_string();
+ +    "{}".to_string();
+ +    "{} abc {}".to_string();
+ +    r##"foo {}
+ +" bar"##.to_string();
+ +
+ +    let _ = String::new();
+ +
+ +    "foo".to_string();
+ +    format!("{:?}", "foo"); // Don't warn about `Debug`.
+ +    format!("{:8}", "foo");
+ +    format!("{:width$}", "foo", width = 8);
+ +    "foo".to_string(); // Warn when the format makes no difference.
+ +    "foo".to_string(); // Warn when the format makes no difference.
+ +    format!("foo {}", "bar");
+ +    format!("{} bar", "foo");
+ +
+ +    let arg: String = "".to_owned();
+ +    arg.to_string();
+ +    format!("{:?}", arg); // Don't warn about debug.
+ +    format!("{:8}", arg);
+ +    format!("{:width$}", arg, width = 8);
+ +    arg.to_string(); // Warn when the format makes no difference.
+ +    arg.to_string(); // Warn when the format makes no difference.
+ +    format!("foo {}", arg);
+ +    format!("{} bar", arg);
+ +
+ +    // We don’t want to warn for non-string args; see issue #697.
+ +    format!("{}", 42);
+ +    format!("{:?}", 42);
+ +    format!("{:+}", 42);
+ +    format!("foo {}", 42);
+ +    format!("{} bar", 42);
+ +
+ +    // We only want to warn about `format!` itself.
+ +    println!("foo");
+ +    println!("{}", "foo");
+ +    println!("foo {}", "foo");
+ +    println!("{}", 42);
+ +    println!("foo {}", 42);
+ +
+ +    // A `format!` inside a macro should not trigger a warning.
+ +    foo!("should not warn");
+ +
+ +    // Precision on string means slicing without panicking on size.
+ +    format!("{:.1}", "foo"); // Could be `"foo"[..1]`
+ +    format!("{:.10}", "foo"); // Could not be `"foo"[..10]`
+ +    format!("{:.prec$}", "foo", prec = 1);
+ +    format!("{:.prec$}", "foo", prec = 10);
+ +
+ +    42.to_string();
+ +    let x = std::path::PathBuf::from("/bar/foo/qux");
+ +    x.display().to_string();
+ +
+ +    // False positive
+ +    let a = "foo".to_string();
+ +    let _ = Some(a + "bar");
+ +
+ +    // Wrap it with braces
+ +    let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
+ +    let _s: String = (&*v.join("\n")).to_string();
+ +
+ +    format!("prepend {:+}", "s");
++
++    // Issue #8290
++    let x = "foo";
++    let _ = x.to_string();
++    let _ = format!("{x:?}"); // Don't lint on debug
++    let _ = x.to_string();
+ +}
diff --cc src/tools/clippy/tests/ui/format.rs

index a065b1b5683c1b9ccbfeb81df5cf1b96d7d12c4d,0000000000000000000000000000000000000000..009c1aa216fcd8b6e89f1de0b383c486ce038ec8

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/format.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/format.rs
@@@ -1,78 -1,0 +1,84 @@@
+ +// run-rustfix
+ +
+ +#![allow(clippy::print_literal, clippy::redundant_clone, clippy::to_string_in_format_args)]
+ +#![warn(clippy::useless_format)]
+ +
+ +struct Foo(pub String);
+ +
+ +macro_rules! foo {
+ +    ($($t:tt)*) => (Foo(format!($($t)*)))
+ +}
+ +
+ +fn main() {
+ +    format!("foo");
+ +    format!("{{}}");
+ +    format!("{{}} abc {{}}");
+ +    format!(
+ +        r##"foo {{}}
+ +" bar"##
+ +    );
+ +
+ +    let _ = format!("");
+ +
+ +    format!("{}", "foo");
+ +    format!("{:?}", "foo"); // Don't warn about `Debug`.
+ +    format!("{:8}", "foo");
+ +    format!("{:width$}", "foo", width = 8);
+ +    format!("{:+}", "foo"); // Warn when the format makes no difference.
+ +    format!("{:<}", "foo"); // Warn when the format makes no difference.
+ +    format!("foo {}", "bar");
+ +    format!("{} bar", "foo");
+ +
+ +    let arg: String = "".to_owned();
+ +    format!("{}", arg);
+ +    format!("{:?}", arg); // Don't warn about debug.
+ +    format!("{:8}", arg);
+ +    format!("{:width$}", arg, width = 8);
+ +    format!("{:+}", arg); // Warn when the format makes no difference.
+ +    format!("{:<}", arg); // Warn when the format makes no difference.
+ +    format!("foo {}", arg);
+ +    format!("{} bar", arg);
+ +
+ +    // We don’t want to warn for non-string args; see issue #697.
+ +    format!("{}", 42);
+ +    format!("{:?}", 42);
+ +    format!("{:+}", 42);
+ +    format!("foo {}", 42);
+ +    format!("{} bar", 42);
+ +
+ +    // We only want to warn about `format!` itself.
+ +    println!("foo");
+ +    println!("{}", "foo");
+ +    println!("foo {}", "foo");
+ +    println!("{}", 42);
+ +    println!("foo {}", 42);
+ +
+ +    // A `format!` inside a macro should not trigger a warning.
+ +    foo!("should not warn");
+ +
+ +    // Precision on string means slicing without panicking on size.
+ +    format!("{:.1}", "foo"); // Could be `"foo"[..1]`
+ +    format!("{:.10}", "foo"); // Could not be `"foo"[..10]`
+ +    format!("{:.prec$}", "foo", prec = 1);
+ +    format!("{:.prec$}", "foo", prec = 10);
+ +
+ +    format!("{}", 42.to_string());
+ +    let x = std::path::PathBuf::from("/bar/foo/qux");
+ +    format!("{}", x.display().to_string());
+ +
+ +    // False positive
+ +    let a = "foo".to_string();
+ +    let _ = Some(format!("{}", a + "bar"));
+ +
+ +    // Wrap it with braces
+ +    let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
+ +    let _s: String = format!("{}", &*v.join("\n"));
+ +
+ +    format!("prepend {:+}", "s");
++
++    // Issue #8290
++    let x = "foo";
++    let _ = format!("{x}");
++    let _ = format!("{x:?}"); // Don't lint on debug
++    let _ = format!("{y}", y = x);
+ +}
diff --cc src/tools/clippy/tests/ui/format.stderr

index 58ad7499bb26f530c5202239ac79858ab1aaa79c,0000000000000000000000000000000000000000..660be57585e3710f3839e5f07ab2cea93091e27b

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/format.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/format.stderr
@@@ -1,103 -1,0 +1,115 @@@
- error: aborting due to 15 previous errors
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:13:5
+ +   |
+ +LL |     format!("foo");
+ +   |     ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
+ +   |
+ +   = note: `-D clippy::useless-format` implied by `-D warnings`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:14:5
+ +   |
+ +LL |     format!("{{}}");
+ +   |     ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{}".to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:15:5
+ +   |
+ +LL |     format!("{{}} abc {{}}");
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{} abc {}".to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:16:5
+ +   |
+ +LL | /     format!(
+ +LL | |         r##"foo {{}}
+ +LL | | " bar"##
+ +LL | |     );
+ +   | |_____^
+ +   |
+ +help: consider using `.to_string()`
+ +   |
+ +LL ~     r##"foo {}
+ +LL ~ " bar"##.to_string();
+ +   |
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:21:13
+ +   |
+ +LL |     let _ = format!("");
+ +   |             ^^^^^^^^^^^ help: consider using `String::new()`: `String::new()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:23:5
+ +   |
+ +LL |     format!("{}", "foo");
+ +   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:27:5
+ +   |
+ +LL |     format!("{:+}", "foo"); // Warn when the format makes no difference.
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:28:5
+ +   |
+ +LL |     format!("{:<}", "foo"); // Warn when the format makes no difference.
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:33:5
+ +   |
+ +LL |     format!("{}", arg);
+ +   |     ^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:37:5
+ +   |
+ +LL |     format!("{:+}", arg); // Warn when the format makes no difference.
+ +   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:38:5
+ +   |
+ +LL |     format!("{:<}", arg); // Warn when the format makes no difference.
+ +   |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:65:5
+ +   |
+ +LL |     format!("{}", 42.to_string());
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `42.to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:67:5
+ +   |
+ +LL |     format!("{}", x.display().to_string());
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.display().to_string()`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:71:18
+ +   |
+ +LL |     let _ = Some(format!("{}", a + "bar"));
+ +   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
+ +
+ +error: useless use of `format!`
+ +  --> $DIR/format.rs:75:22
+ +   |
+ +LL |     let _s: String = format!("{}", &*v.join("/n"));
+ +   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("/n")).to_string()`
+ +
++error: useless use of `format!`
++  --> $DIR/format.rs:81:13
++   |
++LL |     let _ = format!("{x}");
++   |             ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
++
++error: useless use of `format!`
++  --> $DIR/format.rs:83:13
++   |
++LL |     let _ = format!("{y}", y = x);
++   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
++
++error: aborting due to 17 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/functions.rs

index 271754cb06ee7eb7ffa4ac7a598d62b41a335a22,0000000000000000000000000000000000000000..5521870eaecf761af9b0f50bdbdd941d63aaa551

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/functions.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/functions.rs
@@@ -1,104 -1,0 +1,112 @@@
+ +#![warn(clippy::all)]
+ +#![allow(dead_code)]
+ +#![allow(unused_unsafe, clippy::missing_safety_doc)]
+ +
+ +// TOO_MANY_ARGUMENTS
+ +fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
+ +
+ +fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
+ +
+ +#[rustfmt::skip]
+ +fn bad_multiline(
+ +    one: u32,
+ +    two: u32,
+ +    three: &str,
+ +    four: bool,
+ +    five: f32,
+ +    six: f32,
+ +    seven: bool,
+ +    eight: ()
+ +) {
+ +    let _one = one;
+ +    let _two = two;
+ +    let _three = three;
+ +    let _four = four;
+ +    let _five = five;
+ +    let _six = six;
+ +    let _seven = seven;
+ +}
+ +
+ +// don't lint extern fns
+ +extern "C" fn extern_fn(
+ +    _one: u32,
+ +    _two: u32,
+ +    _three: *const u8,
+ +    _four: bool,
+ +    _five: f32,
+ +    _six: f32,
+ +    _seven: bool,
+ +    _eight: *const std::ffi::c_void,
+ +) {
+ +}
+ +
+ +pub trait Foo {
+ +    fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool);
+ +    fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ());
+ +
+ +    fn ptr(p: *const u8);
+ +}
+ +
+ +pub struct Bar;
+ +
+ +impl Bar {
+ +    fn good_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
+ +    fn bad_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
+ +}
+ +
+ +// ok, we don’t want to warn implementations
+ +impl Foo for Bar {
+ +    fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
+ +    fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
+ +
+ +    fn ptr(p: *const u8) {
+ +        println!("{}", unsafe { *p });
+ +        println!("{:?}", unsafe { p.as_ref() });
+ +        unsafe { std::ptr::read(p) };
+ +    }
+ +}
+ +
+ +// NOT_UNSAFE_PTR_ARG_DEREF
+ +
+ +fn private(p: *const u8) {
+ +    println!("{}", unsafe { *p });
+ +}
+ +
+ +pub fn public(p: *const u8) {
+ +    println!("{}", unsafe { *p });
+ +    println!("{:?}", unsafe { p.as_ref() });
+ +    unsafe { std::ptr::read(p) };
+ +}
+ +
++type Alias = *const u8;
++
++pub fn type_alias(p: Alias) {
++    println!("{}", unsafe { *p });
++    println!("{:?}", unsafe { p.as_ref() });
++    unsafe { std::ptr::read(p) };
++}
++
+ +impl Bar {
+ +    fn private(self, p: *const u8) {
+ +        println!("{}", unsafe { *p });
+ +    }
+ +
+ +    pub fn public(self, p: *const u8) {
+ +        println!("{}", unsafe { *p });
+ +        println!("{:?}", unsafe { p.as_ref() });
+ +        unsafe { std::ptr::read(p) };
+ +    }
+ +
+ +    pub fn public_ok(self, p: *const u8) {
+ +        if !p.is_null() {
+ +            println!("{:p}", p);
+ +        }
+ +    }
+ +
+ +    pub unsafe fn public_unsafe(self, p: *const u8) {
+ +        println!("{}", unsafe { *p });
+ +        println!("{:?}", unsafe { p.as_ref() });
+ +    }
+ +}
+ +
+ +fn main() {}
diff --cc src/tools/clippy/tests/ui/functions.stderr

index a2b8c2a384b03ac89d2593f0ccc22b6432d20357,0000000000000000000000000000000000000000..8ebd4997f4f6e836983c92a66191a793429dc3ee

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/functions.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/functions.stderr
@@@ -1,90 -1,0 +1,108 @@@
-   --> $DIR/functions.rs:87:34
+ +error: this function has too many arguments (8/7)
+ +  --> $DIR/functions.rs:8:1
+ +   |
+ +LL | fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
+ +   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ +   |
+ +   = note: `-D clippy::too-many-arguments` implied by `-D warnings`
+ +
+ +error: this function has too many arguments (8/7)
+ +  --> $DIR/functions.rs:11:1
+ +   |
+ +LL | / fn bad_multiline(
+ +LL | |     one: u32,
+ +LL | |     two: u32,
+ +LL | |     three: &str,
+ +...  |
+ +LL | |     eight: ()
+ +LL | | ) {
+ +   | |__^
+ +
+ +error: this function has too many arguments (8/7)
+ +  --> $DIR/functions.rs:45:5
+ +   |
+ +LL |     fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ());
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ +
+ +error: this function has too many arguments (8/7)
+ +  --> $DIR/functions.rs:54:5
+ +   |
+ +LL |     fn bad_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
+ +  --> $DIR/functions.rs:63:34
+ +   |
+ +LL |         println!("{}", unsafe { *p });
+ +   |                                  ^
+ +   |
+ +   = note: `-D clippy::not-unsafe-ptr-arg-deref` implied by `-D warnings`
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
+ +  --> $DIR/functions.rs:64:35
+ +   |
+ +LL |         println!("{:?}", unsafe { p.as_ref() });
+ +   |                                   ^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
+ +  --> $DIR/functions.rs:65:33
+ +   |
+ +LL |         unsafe { std::ptr::read(p) };
+ +   |                                 ^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
+ +  --> $DIR/functions.rs:76:30
+ +   |
+ +LL |     println!("{}", unsafe { *p });
+ +   |                              ^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
+ +  --> $DIR/functions.rs:77:31
+ +   |
+ +LL |     println!("{:?}", unsafe { p.as_ref() });
+ +   |                               ^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
+ +  --> $DIR/functions.rs:78:29
+ +   |
+ +LL |     unsafe { std::ptr::read(p) };
+ +   |                             ^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
-   --> $DIR/functions.rs:88:35
++  --> $DIR/functions.rs:84:30
++   |
++LL |     println!("{}", unsafe { *p });
++   |                              ^
++
++error: this public function might dereference a raw pointer but is not marked `unsafe`
++  --> $DIR/functions.rs:85:31
++   |
++LL |     println!("{:?}", unsafe { p.as_ref() });
++   |                               ^
++
++error: this public function might dereference a raw pointer but is not marked `unsafe`
++  --> $DIR/functions.rs:86:29
++   |
++LL |     unsafe { std::ptr::read(p) };
++   |                             ^
++
++error: this public function might dereference a raw pointer but is not marked `unsafe`
++  --> $DIR/functions.rs:95:34
+ +   |
+ +LL |         println!("{}", unsafe { *p });
+ +   |                                  ^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
-   --> $DIR/functions.rs:89:33
++  --> $DIR/functions.rs:96:35
+ +   |
+ +LL |         println!("{:?}", unsafe { p.as_ref() });
+ +   |                                   ^
+ +
+ +error: this public function might dereference a raw pointer but is not marked `unsafe`
- error: aborting due to 13 previous errors
++  --> $DIR/functions.rs:97:33
+ +   |
+ +LL |         unsafe { std::ptr::read(p) };
+ +   |                                 ^
+ +
++error: aborting due to 16 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/if_same_then_else2.rs

index 69189d9e0c00d911637b320ba9e48b83e3716124,0000000000000000000000000000000000000000..0016009a02f5858b39461dba03a777ba713ebf39

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/if_same_then_else2.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/if_same_then_else2.rs
@@@ -1,143 -1,0 +1,160 @@@
+ +#![warn(clippy::if_same_then_else)]
+ +#![allow(
+ +    clippy::blacklisted_name,
+ +    clippy::collapsible_else_if,
+ +    clippy::equatable_if_let,
+ +    clippy::collapsible_if,
+ +    clippy::ifs_same_cond,
+ +    clippy::needless_return,
+ +    clippy::single_element_loop,
+ +    clippy::branches_sharing_code
+ +)]
+ +
+ +fn if_same_then_else2() -> Result<&'static str, ()> {
+ +    if true {
+ +        for _ in &[42] {
+ +            let foo: &Option<_> = &Some::<u8>(42);
+ +            if foo.is_some() {
+ +                break;
+ +            } else {
+ +                continue;
+ +            }
+ +        }
+ +    } else {
+ +        //~ ERROR same body as `if` block
+ +        for _ in &[42] {
+ +            let bar: &Option<_> = &Some::<u8>(42);
+ +            if bar.is_some() {
+ +                break;
+ +            } else {
+ +                continue;
+ +            }
+ +        }
+ +    }
+ +
+ +    if true {
+ +        if let Some(a) = Some(42) {}
+ +    } else {
+ +        //~ ERROR same body as `if` block
+ +        if let Some(a) = Some(42) {}
+ +    }
+ +
+ +    if true {
+ +        if let (1, .., 3) = (1, 2, 3) {}
+ +    } else {
+ +        //~ ERROR same body as `if` block
+ +        if let (1, .., 3) = (1, 2, 3) {}
+ +    }
+ +
+ +    if true {
+ +        if let (1, .., 3) = (1, 2, 3) {}
+ +    } else {
+ +        if let (.., 3) = (1, 2, 3) {}
+ +    }
+ +
+ +    if true {
+ +        if let (1, .., 3) = (1, 2, 3) {}
+ +    } else {
+ +        if let (.., 4) = (1, 2, 3) {}
+ +    }
+ +
+ +    if true {
+ +        if let (1, .., 3) = (1, 2, 3) {}
+ +    } else {
+ +        if let (.., 1, 3) = (1, 2, 3) {}
+ +    }
+ +
+ +    if true {
+ +        if let Some(42) = None {}
+ +    } else {
+ +        if let Option::Some(42) = None {}
+ +    }
+ +
+ +    if true {
+ +        if let Some(42) = None::<u8> {}
+ +    } else {
+ +        if let Some(42) = None {}
+ +    }
+ +
+ +    if true {
+ +        if let Some(42) = None::<u8> {}
+ +    } else {
+ +        if let Some(42) = None::<u32> {}
+ +    }
+ +
+ +    if true {
+ +        if let Some(a) = Some(42) {}
+ +    } else {
+ +        if let Some(a) = Some(43) {}
+ +    }
+ +
+ +    // Same NaNs
+ +    let _ = if true {
+ +        f32::NAN
+ +    } else {
+ +        //~ ERROR same body as `if` block
+ +        f32::NAN
+ +    };
+ +
+ +    if true {
+ +        Ok("foo")?;
+ +    } else {
+ +        //~ ERROR same body as `if` block
+ +        Ok("foo")?;
+ +    }
+ +
+ +    if true {
+ +        let foo = "";
+ +        return Ok(&foo[0..]);
+ +    } else if false {
+ +        let foo = "bar";
+ +        return Ok(&foo[0..]);
+ +    } else {
+ +        let foo = "";
+ +        return Ok(&foo[0..]);
+ +    }
+ +
+ +    if true {
+ +        let foo = "";
+ +        return Ok(&foo[0..]);
+ +    } else if false {
+ +        let foo = "bar";
+ +        return Ok(&foo[0..]);
+ +    } else if true {
+ +        let foo = "";
+ +        return Ok(&foo[0..]);
+ +    } else {
+ +        let foo = "";
+ +        return Ok(&foo[0..]);
+ +    }
+ +
+ +    // False positive `if_same_then_else`: `let (x, y)` vs. `let (y, x)`; see issue #3559.
+ +    if true {
+ +        let foo = "";
+ +        let (x, y) = (1, 2);
+ +        return Ok(&foo[x..y]);
+ +    } else {
+ +        let foo = "";
+ +        let (y, x) = (1, 2);
+ +        return Ok(&foo[x..y]);
+ +    }
++
++    // Issue #7579
++    let _ = if let Some(0) = None { 0 } else { 0 };
++
++    if true {
++        return Err(());
++    } else if let Some(0) = None {
++        return Err(());
++    }
++
++    let _ = if let Some(0) = None {
++        0
++    } else if let Some(1) = None {
++        0
++    } else {
++        0
++    };
+ +}
+ +
+ +fn main() {}
diff --cc src/tools/clippy/tests/ui/implicit_clone.rs

index cef71cf79d79721814cce022ec3ef1a736b31439,0000000000000000000000000000000000000000..639fecb8927bd322b4754c9fb00268107612e793

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/implicit_clone.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/implicit_clone.rs
@@@ -1,108 -1,0 +1,117 @@@
+ +#![warn(clippy::implicit_clone)]
+ +#![allow(clippy::redundant_clone)]
+ +use std::borrow::Borrow;
+ +use std::ffi::{OsStr, OsString};
+ +use std::path::PathBuf;
+ +
+ +fn return_owned_from_slice(slice: &[u32]) -> Vec<u32> {
+ +    slice.to_owned()
+ +}
+ +
+ +pub fn own_same<T>(v: T) -> T
+ +where
+ +    T: ToOwned<Owned = T>,
+ +{
+ +    v.to_owned()
+ +}
+ +
+ +pub fn own_same_from_ref<T>(v: &T) -> T
+ +where
+ +    T: ToOwned<Owned = T>,
+ +{
+ +    v.to_owned()
+ +}
+ +
+ +pub fn own_different<T, U>(v: T) -> U
+ +where
+ +    T: ToOwned<Owned = U>,
+ +{
+ +    v.to_owned()
+ +}
+ +
+ +#[derive(Copy, Clone)]
+ +struct Kitten {}
+ +impl Kitten {
+ +    // badly named method
+ +    fn to_vec(self) -> Kitten {
+ +        Kitten {}
+ +    }
+ +}
+ +impl Borrow<BorrowedKitten> for Kitten {
+ +    fn borrow(&self) -> &BorrowedKitten {
+ +        static VALUE: BorrowedKitten = BorrowedKitten {};
+ +        &VALUE
+ +    }
+ +}
+ +
+ +struct BorrowedKitten {}
+ +impl ToOwned for BorrowedKitten {
+ +    type Owned = Kitten;
+ +    fn to_owned(&self) -> Kitten {
+ +        Kitten {}
+ +    }
+ +}
+ +
+ +mod weird {
+ +    #[allow(clippy::ptr_arg)]
+ +    pub fn to_vec(v: &Vec<u32>) -> Vec<u32> {
+ +        v.clone()
+ +    }
+ +}
+ +
+ +fn main() {
+ +    let vec = vec![5];
+ +    let _ = return_owned_from_slice(&vec);
+ +    let _ = vec.to_owned();
+ +    let _ = vec.to_vec();
+ +
+ +    let vec_ref = &vec;
+ +    let _ = return_owned_from_slice(vec_ref);
+ +    let _ = vec_ref.to_owned();
+ +    let _ = vec_ref.to_vec();
+ +
+ +    // we expect no lint for this
+ +    let _ = weird::to_vec(&vec);
+ +
+ +    // we expect no lints for this
+ +    let slice: &[u32] = &[1, 2, 3, 4, 5];
+ +    let _ = return_owned_from_slice(slice);
+ +    let _ = slice.to_owned();
+ +    let _ = slice.to_vec();
+ +
+ +    let str = "hello world".to_string();
+ +    let _ = str.to_owned();
+ +
+ +    // testing w/ an arbitrary type
+ +    let kitten = Kitten {};
+ +    let _ = kitten.to_owned();
+ +    let _ = own_same_from_ref(&kitten);
+ +    // this shouln't lint
+ +    let _ = kitten.to_vec();
+ +
+ +    // we expect no lints for this
+ +    let borrowed = BorrowedKitten {};
+ +    let _ = borrowed.to_owned();
+ +
+ +    let pathbuf = PathBuf::new();
+ +    let _ = pathbuf.to_owned();
+ +    let _ = pathbuf.to_path_buf();
+ +
+ +    let os_string = OsString::from("foo");
+ +    let _ = os_string.to_owned();
+ +    let _ = os_string.to_os_string();
+ +
+ +    // we expect no lints for this
+ +    let os_str = OsStr::new("foo");
+ +    let _ = os_str.to_owned();
+ +    let _ = os_str.to_os_string();
++
++    // issue #8227
++    let pathbuf_ref = &pathbuf;
++    let pathbuf_ref = &pathbuf_ref;
++    let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&PathBuf`
++    let _ = pathbuf_ref.to_path_buf();
++    let pathbuf_ref = &pathbuf_ref;
++    let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&&PathBuf`
++    let _ = pathbuf_ref.to_path_buf();
+ +}
diff --cc src/tools/clippy/tests/ui/implicit_clone.stderr

index e6f7527b67219d2409f514246af6e3911826e0af,0000000000000000000000000000000000000000..0f4124241907f3b73dd9d38d0d9abac3e885053b

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/implicit_clone.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/implicit_clone.stderr
@@@ -1,64 -1,0 +1,76 @@@
-   --> $DIR/implicit_clone.rs:65:17
+ +error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
-    |                 ^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:65:13
+ +   |
+ +LL |     let _ = vec.to_owned();
-   --> $DIR/implicit_clone.rs:66:17
++   |             ^^^^^^^^^^^^^^ help: consider using: `vec.clone()`
+ +   |
+ +   = note: `-D clippy::implicit-clone` implied by `-D warnings`
+ +
+ +error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
-    |                 ^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:66:13
+ +   |
+ +LL |     let _ = vec.to_vec();
-   --> $DIR/implicit_clone.rs:70:21
++   |             ^^^^^^^^^^^^ help: consider using: `vec.clone()`
+ +
+ +error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
-    |                     ^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:70:13
+ +   |
+ +LL |     let _ = vec_ref.to_owned();
-   --> $DIR/implicit_clone.rs:71:21
++   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `vec_ref.clone()`
+ +
+ +error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
-    |                     ^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:71:13
+ +   |
+ +LL |     let _ = vec_ref.to_vec();
-   --> $DIR/implicit_clone.rs:83:17
++   |             ^^^^^^^^^^^^^^^^ help: consider using: `vec_ref.clone()`
+ +
+ +error: implicitly cloning a `String` by calling `to_owned` on its dereferenced type
-    |                 ^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:83:13
+ +   |
+ +LL |     let _ = str.to_owned();
-   --> $DIR/implicit_clone.rs:87:20
++   |             ^^^^^^^^^^^^^^ help: consider using: `str.clone()`
+ +
+ +error: implicitly cloning a `Kitten` by calling `to_owned` on its dereferenced type
-    |                    ^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:87:13
+ +   |
+ +LL |     let _ = kitten.to_owned();
-   --> $DIR/implicit_clone.rs:97:21
++   |             ^^^^^^^^^^^^^^^^^ help: consider using: `kitten.clone()`
+ +
+ +error: implicitly cloning a `PathBuf` by calling `to_owned` on its dereferenced type
-    |                     ^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:97:13
+ +   |
+ +LL |     let _ = pathbuf.to_owned();
-   --> $DIR/implicit_clone.rs:98:21
++   |             ^^^^^^^^^^^^^^^^^^ help: consider using: `pathbuf.clone()`
+ +
+ +error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
-    |                     ^^^^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:98:13
+ +   |
+ +LL |     let _ = pathbuf.to_path_buf();
-   --> $DIR/implicit_clone.rs:101:23
++   |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `pathbuf.clone()`
+ +
+ +error: implicitly cloning a `OsString` by calling `to_owned` on its dereferenced type
-    |                       ^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:101:13
+ +   |
+ +LL |     let _ = os_string.to_owned();
-   --> $DIR/implicit_clone.rs:102:23
++   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `os_string.clone()`
+ +
+ +error: implicitly cloning a `OsString` by calling `to_os_string` on its dereferenced type
-    |                       ^^^^^^^^^^^^ help: consider using: `clone`
++  --> $DIR/implicit_clone.rs:102:13
+ +   |
+ +LL |     let _ = os_string.to_os_string();
- error: aborting due to 10 previous errors
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `os_string.clone()`
+ +
++error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
++  --> $DIR/implicit_clone.rs:113:13
++   |
++LL |     let _ = pathbuf_ref.to_path_buf();
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(*pathbuf_ref).clone()`
++
++error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
++  --> $DIR/implicit_clone.rs:116:13
++   |
++LL |     let _ = pathbuf_ref.to_path_buf();
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(**pathbuf_ref).clone()`
++
++error: aborting due to 12 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/iter_not_returning_iterator.rs

index 2c91e02e84223cd3257a4b898ac739ac9b675415,0000000000000000000000000000000000000000..cce216fc649b1667d276f9283ea4c273d146c5cb

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/iter_not_returning_iterator.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/iter_not_returning_iterator.rs
@@@ -1,67 -1,0 +1,74 @@@
+ +#![warn(clippy::iter_not_returning_iterator)]
+ +
+ +struct Data {
+ +    begin: u32,
+ +}
+ +
+ +struct Counter {
+ +    count: u32,
+ +}
+ +
+ +impl Data {
+ +    fn iter(&self) -> Counter {
+ +        todo!()
+ +    }
+ +
+ +    fn iter_mut(&self) -> Counter {
+ +        todo!()
+ +    }
+ +}
+ +
+ +struct Data2 {
+ +    begin: u32,
+ +}
+ +
+ +struct Counter2 {
+ +    count: u32,
+ +}
+ +
+ +impl Data2 {
+ +    fn iter(&self) -> Counter2 {
+ +        todo!()
+ +    }
+ +
+ +    fn iter_mut(&self) -> Counter2 {
+ +        todo!()
+ +    }
+ +}
+ +
+ +impl Iterator for Counter {
+ +    type Item = u32;
+ +
+ +    fn next(&mut self) -> Option<Self::Item> {
+ +        todo!()
+ +    }
+ +}
+ +
+ +// Issue #8225
+ +trait Iter {
+ +    type I;
+ +    fn iter(&self) -> Self::I;
+ +}
+ +
+ +impl Iter for () {
+ +    type I = core::slice::Iter<'static, ()>;
+ +    fn iter(&self) -> Self::I {
+ +        [].iter()
+ +    }
+ +}
+ +
+ +struct S;
+ +impl S {
+ +    fn iter(&self) -> <() as Iter>::I {
+ +        ().iter()
+ +    }
+ +}
+ +
++struct S2([u8]);
++impl S2 {
++    fn iter(&self) -> core::slice::Iter<u8> {
++        self.0.iter()
++    }
++}
++
+ +fn main() {}
diff --cc src/tools/clippy/tests/ui/iter_overeager_cloned.fixed

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..a9041671101b5006f437f516f3280545a6f67413

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/iter_overeager_cloned.fixed
@@@ -1,0 -1,0 +1,45 @@@
++// run-rustfix
++#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
++
++fn main() {
++    let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
++
++    let _: Option<String> = vec.iter().last().cloned();
++
++    let _: Option<String> = vec.iter().chain(vec.iter()).next().cloned();
++
++    let _: usize = vec.iter().filter(|x| x == &"2").count();
++
++    let _: Vec<_> = vec.iter().take(2).cloned().collect();
++
++    let _: Vec<_> = vec.iter().skip(2).cloned().collect();
++
++    let _ = vec.iter().filter(|x| x == &"2").nth(2).cloned();
++
++    let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
++        .iter().flatten().cloned();
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().map(|x| x.len());
++
++    // This would fail if changed.
++    let _ = vec.iter().cloned().map(|x| x + "2");
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().find(|x| x == "2");
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().all(|x| x.len() == 1);
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().any(|x| x.len() == 1);
++
++    // Should probably stay as it is.
++    let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
++}
diff --cc src/tools/clippy/tests/ui/iter_overeager_cloned.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..dd04e33a4b3aeedb8901b55a5d7e49f4d611852f

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/iter_overeager_cloned.rs
@@@ -1,0 -1,0 +1,47 @@@
++// run-rustfix
++#![warn(clippy::iter_overeager_cloned, clippy::redundant_clone, clippy::filter_next)]
++
++fn main() {
++    let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
++
++    let _: Option<String> = vec.iter().cloned().last();
++
++    let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
++
++    let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
++
++    let _: Vec<_> = vec.iter().cloned().take(2).collect();
++
++    let _: Vec<_> = vec.iter().cloned().skip(2).collect();
++
++    let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
++
++    let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
++        .iter()
++        .cloned()
++        .flatten();
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().map(|x| x.len());
++
++    // This would fail if changed.
++    let _ = vec.iter().cloned().map(|x| x + "2");
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().find(|x| x == "2");
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().all(|x| x.len() == 1);
++
++    // Not implemented yet
++    let _ = vec.iter().cloned().any(|x| x.len() == 1);
++
++    // Should probably stay as it is.
++    let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
++}
diff --cc src/tools/clippy/tests/ui/iter_overeager_cloned.stderr

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..e36b0e36fbdf98c6f4346682bd3a44df84ffac3a

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/iter_overeager_cloned.stderr
@@@ -1,0 -1,0 +1,58 @@@
++error: called `cloned().last()` on an `Iterator`. It may be more efficient to call `last().cloned()` instead
++  --> $DIR/iter_overeager_cloned.rs:7:29
++   |
++LL |     let _: Option<String> = vec.iter().cloned().last();
++   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().last().cloned()`
++   |
++   = note: `-D clippy::iter-overeager-cloned` implied by `-D warnings`
++
++error: called `cloned().next()` on an `Iterator`. It may be more efficient to call `next().cloned()` instead
++  --> $DIR/iter_overeager_cloned.rs:9:29
++   |
++LL |     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
++   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().chain(vec.iter()).next().cloned()`
++
++error: called `cloned().count()` on an `Iterator`. It may be more efficient to call `count()` instead
++  --> $DIR/iter_overeager_cloned.rs:11:20
++   |
++LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
++   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").count()`
++   |
++   = note: `-D clippy::redundant-clone` implied by `-D warnings`
++
++error: called `cloned().take(...)` on an `Iterator`. It may be more efficient to call `take(...).cloned()` instead
++  --> $DIR/iter_overeager_cloned.rs:13:21
++   |
++LL |     let _: Vec<_> = vec.iter().cloned().take(2).collect();
++   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().take(2).cloned()`
++
++error: called `cloned().skip(...)` on an `Iterator`. It may be more efficient to call `skip(...).cloned()` instead
++  --> $DIR/iter_overeager_cloned.rs:15:21
++   |
++LL |     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
++   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().skip(2).cloned()`
++
++error: called `cloned().nth(...)` on an `Iterator`. It may be more efficient to call `nth(...).cloned()` instead
++  --> $DIR/iter_overeager_cloned.rs:17:13
++   |
++LL |     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `vec.iter().filter(|x| x == &"2").nth(2).cloned()`
++
++error: called `cloned().flatten()` on an `Iterator`. It may be more efficient to call `flatten().cloned()` instead
++  --> $DIR/iter_overeager_cloned.rs:19:13
++   |
++LL |       let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
++   |  _____________^
++LL | |         .iter()
++LL | |         .cloned()
++LL | |         .flatten();
++   | |__________________^
++   |
++help: try this
++   |
++LL ~     let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
++LL ~         .iter().flatten().cloned();
++   |
++
++error: aborting due to 7 previous errors
++
diff --cc src/tools/clippy/tests/ui/or_fun_call.fixed

index 87cdb3ace47cb68176d4f4f6921313f55017cc9e,0000000000000000000000000000000000000000..3208048e0d53c82e87407376138c0d0923db3bef

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/or_fun_call.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/or_fun_call.fixed
@@@ -1,179 -1,0 +1,227 @@@
+ +// run-rustfix
+ +
+ +#![warn(clippy::or_fun_call)]
+ +#![allow(dead_code)]
+ +#![allow(clippy::unnecessary_wraps, clippy::borrow_as_ptr)]
+ +
+ +use std::collections::BTreeMap;
+ +use std::collections::HashMap;
+ +use std::time::Duration;
+ +
+ +/// Checks implementation of the `OR_FUN_CALL` lint.
+ +fn or_fun_call() {
+ +    struct Foo;
+ +
+ +    impl Foo {
+ +        fn new() -> Foo {
+ +            Foo
+ +        }
+ +    }
+ +
+ +    struct FakeDefault;
+ +    impl FakeDefault {
+ +        fn default() -> Self {
+ +            FakeDefault
+ +        }
+ +    }
+ +
+ +    impl Default for FakeDefault {
+ +        fn default() -> Self {
+ +            FakeDefault
+ +        }
+ +    }
+ +
+ +    enum Enum {
+ +        A(i32),
+ +    }
+ +
+ +    fn make<T>() -> T {
+ +        unimplemented!();
+ +    }
+ +
+ +    let with_enum = Some(Enum::A(1));
+ +    with_enum.unwrap_or(Enum::A(5));
+ +
+ +    let with_const_fn = Some(Duration::from_secs(1));
+ +    with_const_fn.unwrap_or(Duration::from_secs(5));
+ +
+ +    let with_constructor = Some(vec![1]);
+ +    with_constructor.unwrap_or_else(make);
+ +
+ +    let with_new = Some(vec![1]);
+ +    with_new.unwrap_or_default();
+ +
+ +    let with_const_args = Some(vec![1]);
+ +    with_const_args.unwrap_or_else(|| Vec::with_capacity(12));
+ +
+ +    let with_err: Result<_, ()> = Ok(vec![1]);
+ +    with_err.unwrap_or_else(|_| make());
+ +
+ +    let with_err_args: Result<_, ()> = Ok(vec![1]);
+ +    with_err_args.unwrap_or_else(|_| Vec::with_capacity(12));
+ +
+ +    let with_default_trait = Some(1);
+ +    with_default_trait.unwrap_or_default();
+ +
+ +    let with_default_type = Some(1);
+ +    with_default_type.unwrap_or_default();
+ +
+ +    let self_default = None::<FakeDefault>;
+ +    self_default.unwrap_or_else(<FakeDefault>::default);
+ +
+ +    let real_default = None::<FakeDefault>;
+ +    real_default.unwrap_or_default();
+ +
+ +    let with_vec = Some(vec![1]);
+ +    with_vec.unwrap_or_default();
+ +
+ +    let without_default = Some(Foo);
+ +    without_default.unwrap_or_else(Foo::new);
+ +
+ +    let mut map = HashMap::<u64, String>::new();
+ +    map.entry(42).or_insert(String::new());
+ +
+ +    let mut map_vec = HashMap::<u64, Vec<i32>>::new();
+ +    map_vec.entry(42).or_insert(vec![]);
+ +
+ +    let mut btree = BTreeMap::<u64, String>::new();
+ +    btree.entry(42).or_insert(String::new());
+ +
+ +    let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
+ +    btree_vec.entry(42).or_insert(vec![]);
+ +
+ +    let stringy = Some(String::from(""));
+ +    let _ = stringy.unwrap_or_else(|| "".to_owned());
+ +
+ +    let opt = Some(1);
+ +    let hello = "Hello";
+ +    let _ = opt.ok_or(format!("{} world.", hello));
+ +
+ +    // index
+ +    let map = HashMap::<u64, u64>::new();
+ +    let _ = Some(1).unwrap_or_else(|| map[&1]);
+ +    let map = BTreeMap::<u64, u64>::new();
+ +    let _ = Some(1).unwrap_or_else(|| map[&1]);
+ +    // don't lint index vec
+ +    let vec = vec![1];
+ +    let _ = Some(1).unwrap_or(vec[1]);
+ +}
+ +
+ +struct Foo(u8);
+ +struct Bar(String, Duration);
+ +#[rustfmt::skip]
+ +fn test_or_with_ctors() {
+ +    let opt = Some(1);
+ +    let opt_opt = Some(Some(1));
+ +    // we also test for const promotion, this makes sure we don't hit that
+ +    let two = 2;
+ +
+ +    let _ = opt_opt.unwrap_or(Some(2));
+ +    let _ = opt_opt.unwrap_or(Some(two));
+ +    let _ = opt.ok_or(Some(2));
+ +    let _ = opt.ok_or(Some(two));
+ +    let _ = opt.ok_or(Foo(2));
+ +    let _ = opt.ok_or(Foo(two));
+ +    let _ = opt.or(Some(2));
+ +    let _ = opt.or(Some(two));
+ +
+ +    let _ = Some("a".to_string()).or_else(|| Some("b".to_string()));
+ +
+ +    let b = "b".to_string();
+ +    let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
+ +        .or(Some(Bar(b, Duration::from_secs(2))));
+ +
+ +    let vec = vec!["foo"];
+ +    let _ = opt.ok_or(vec.len());
+ +
+ +    let array = ["foo"];
+ +    let _ = opt.ok_or(array.len());
+ +
+ +    let slice = &["foo"][..];
+ +    let _ = opt.ok_or(slice.len());
+ +
+ +    let string = "foo";
+ +    let _ = opt.ok_or(string.len());
+ +}
+ +
+ +// Issue 4514 - early return
+ +fn f() -> Option<()> {
+ +    let a = Some(1);
+ +    let b = 1i32;
+ +
+ +    let _ = a.unwrap_or(b.checked_mul(3)?.min(240));
+ +
+ +    Some(())
+ +}
+ +
+ +mod issue6675 {
+ +    unsafe fn ptr_to_ref<'a, T>(p: *const T) -> &'a T {
+ +        #[allow(unused)]
+ +        let x = vec![0; 1000]; // future-proofing, make this function expensive.
+ +        &*p
+ +    }
+ +
+ +    unsafe fn foo() {
+ +        let s = "test".to_owned();
+ +        let s = &s as *const _;
+ +        None.unwrap_or_else(|| ptr_to_ref(s));
+ +    }
+ +
+ +    fn bar() {
+ +        let s = "test".to_owned();
+ +        let s = &s as *const _;
+ +        None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
+ +        #[rustfmt::skip]
+ +        None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
+ +    }
+ +}
+ +
++mod issue8239 {
++    fn more_than_max_suggestion_highest_lines_0() {
++        let frames = Vec::new();
++        frames
++            .iter()
++            .map(|f: &String| f.to_lowercase())
++            .reduce(|mut acc, f| {
++                acc.push_str(&f);
++                acc
++            })
++            .unwrap_or_default();
++    }
++
++    fn more_to_max_suggestion_highest_lines_1() {
++        let frames = Vec::new();
++        let iter = frames.iter();
++        iter.map(|f: &String| f.to_lowercase())
++            .reduce(|mut acc, f| {
++                let _ = "";
++                let _ = "";
++                acc.push_str(&f);
++                acc
++            })
++            .unwrap_or_default();
++    }
++
++    fn equal_to_max_suggestion_highest_lines() {
++        let frames = Vec::new();
++        let iter = frames.iter();
++        iter.map(|f: &String| f.to_lowercase())
++            .reduce(|mut acc, f| {
++                let _ = "";
++                acc.push_str(&f);
++                acc
++            }).unwrap_or_default();
++    }
++
++    fn less_than_max_suggestion_highest_lines() {
++        let frames = Vec::new();
++        let iter = frames.iter();
++        let map = iter.map(|f: &String| f.to_lowercase());
++        map.reduce(|mut acc, f| {
++            acc.push_str(&f);
++            acc
++        }).unwrap_or_default();
++    }
++}
++
+ +fn main() {}
diff --cc src/tools/clippy/tests/ui/or_fun_call.rs

index 3f69cef301c8b1b96d262067a2e719b1b6056735,0000000000000000000000000000000000000000..57ab5f03ee2851318b3ba58d9fcc2c72d23e442e

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/or_fun_call.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/or_fun_call.rs
@@@ -1,179 -1,0 +1,229 @@@
+ +// run-rustfix
+ +
+ +#![warn(clippy::or_fun_call)]
+ +#![allow(dead_code)]
+ +#![allow(clippy::unnecessary_wraps, clippy::borrow_as_ptr)]
+ +
+ +use std::collections::BTreeMap;
+ +use std::collections::HashMap;
+ +use std::time::Duration;
+ +
+ +/// Checks implementation of the `OR_FUN_CALL` lint.
+ +fn or_fun_call() {
+ +    struct Foo;
+ +
+ +    impl Foo {
+ +        fn new() -> Foo {
+ +            Foo
+ +        }
+ +    }
+ +
+ +    struct FakeDefault;
+ +    impl FakeDefault {
+ +        fn default() -> Self {
+ +            FakeDefault
+ +        }
+ +    }
+ +
+ +    impl Default for FakeDefault {
+ +        fn default() -> Self {
+ +            FakeDefault
+ +        }
+ +    }
+ +
+ +    enum Enum {
+ +        A(i32),
+ +    }
+ +
+ +    fn make<T>() -> T {
+ +        unimplemented!();
+ +    }
+ +
+ +    let with_enum = Some(Enum::A(1));
+ +    with_enum.unwrap_or(Enum::A(5));
+ +
+ +    let with_const_fn = Some(Duration::from_secs(1));
+ +    with_const_fn.unwrap_or(Duration::from_secs(5));
+ +
+ +    let with_constructor = Some(vec![1]);
+ +    with_constructor.unwrap_or(make());
+ +
+ +    let with_new = Some(vec![1]);
+ +    with_new.unwrap_or(Vec::new());
+ +
+ +    let with_const_args = Some(vec![1]);
+ +    with_const_args.unwrap_or(Vec::with_capacity(12));
+ +
+ +    let with_err: Result<_, ()> = Ok(vec![1]);
+ +    with_err.unwrap_or(make());
+ +
+ +    let with_err_args: Result<_, ()> = Ok(vec![1]);
+ +    with_err_args.unwrap_or(Vec::with_capacity(12));
+ +
+ +    let with_default_trait = Some(1);
+ +    with_default_trait.unwrap_or(Default::default());
+ +
+ +    let with_default_type = Some(1);
+ +    with_default_type.unwrap_or(u64::default());
+ +
+ +    let self_default = None::<FakeDefault>;
+ +    self_default.unwrap_or(<FakeDefault>::default());
+ +
+ +    let real_default = None::<FakeDefault>;
+ +    real_default.unwrap_or(<FakeDefault as Default>::default());
+ +
+ +    let with_vec = Some(vec![1]);
+ +    with_vec.unwrap_or(vec![]);
+ +
+ +    let without_default = Some(Foo);
+ +    without_default.unwrap_or(Foo::new());
+ +
+ +    let mut map = HashMap::<u64, String>::new();
+ +    map.entry(42).or_insert(String::new());
+ +
+ +    let mut map_vec = HashMap::<u64, Vec<i32>>::new();
+ +    map_vec.entry(42).or_insert(vec![]);
+ +
+ +    let mut btree = BTreeMap::<u64, String>::new();
+ +    btree.entry(42).or_insert(String::new());
+ +
+ +    let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
+ +    btree_vec.entry(42).or_insert(vec![]);
+ +
+ +    let stringy = Some(String::from(""));
+ +    let _ = stringy.unwrap_or("".to_owned());
+ +
+ +    let opt = Some(1);
+ +    let hello = "Hello";
+ +    let _ = opt.ok_or(format!("{} world.", hello));
+ +
+ +    // index
+ +    let map = HashMap::<u64, u64>::new();
+ +    let _ = Some(1).unwrap_or(map[&1]);
+ +    let map = BTreeMap::<u64, u64>::new();
+ +    let _ = Some(1).unwrap_or(map[&1]);
+ +    // don't lint index vec
+ +    let vec = vec![1];
+ +    let _ = Some(1).unwrap_or(vec[1]);
+ +}
+ +
+ +struct Foo(u8);
+ +struct Bar(String, Duration);
+ +#[rustfmt::skip]
+ +fn test_or_with_ctors() {
+ +    let opt = Some(1);
+ +    let opt_opt = Some(Some(1));
+ +    // we also test for const promotion, this makes sure we don't hit that
+ +    let two = 2;
+ +
+ +    let _ = opt_opt.unwrap_or(Some(2));
+ +    let _ = opt_opt.unwrap_or(Some(two));
+ +    let _ = opt.ok_or(Some(2));
+ +    let _ = opt.ok_or(Some(two));
+ +    let _ = opt.ok_or(Foo(2));
+ +    let _ = opt.ok_or(Foo(two));
+ +    let _ = opt.or(Some(2));
+ +    let _ = opt.or(Some(two));
+ +
+ +    let _ = Some("a".to_string()).or(Some("b".to_string()));
+ +
+ +    let b = "b".to_string();
+ +    let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
+ +        .or(Some(Bar(b, Duration::from_secs(2))));
+ +
+ +    let vec = vec!["foo"];
+ +    let _ = opt.ok_or(vec.len());
+ +
+ +    let array = ["foo"];
+ +    let _ = opt.ok_or(array.len());
+ +
+ +    let slice = &["foo"][..];
+ +    let _ = opt.ok_or(slice.len());
+ +
+ +    let string = "foo";
+ +    let _ = opt.ok_or(string.len());
+ +}
+ +
+ +// Issue 4514 - early return
+ +fn f() -> Option<()> {
+ +    let a = Some(1);
+ +    let b = 1i32;
+ +
+ +    let _ = a.unwrap_or(b.checked_mul(3)?.min(240));
+ +
+ +    Some(())
+ +}
+ +
+ +mod issue6675 {
+ +    unsafe fn ptr_to_ref<'a, T>(p: *const T) -> &'a T {
+ +        #[allow(unused)]
+ +        let x = vec![0; 1000]; // future-proofing, make this function expensive.
+ +        &*p
+ +    }
+ +
+ +    unsafe fn foo() {
+ +        let s = "test".to_owned();
+ +        let s = &s as *const _;
+ +        None.unwrap_or(ptr_to_ref(s));
+ +    }
+ +
+ +    fn bar() {
+ +        let s = "test".to_owned();
+ +        let s = &s as *const _;
+ +        None.unwrap_or(unsafe { ptr_to_ref(s) });
+ +        #[rustfmt::skip]
+ +        None.unwrap_or( unsafe { ptr_to_ref(s) }    );
+ +    }
+ +}
+ +
++mod issue8239 {
++    fn more_than_max_suggestion_highest_lines_0() {
++        let frames = Vec::new();
++        frames
++            .iter()
++            .map(|f: &String| f.to_lowercase())
++            .reduce(|mut acc, f| {
++                acc.push_str(&f);
++                acc
++            })
++            .unwrap_or(String::new());
++    }
++
++    fn more_to_max_suggestion_highest_lines_1() {
++        let frames = Vec::new();
++        let iter = frames.iter();
++        iter.map(|f: &String| f.to_lowercase())
++            .reduce(|mut acc, f| {
++                let _ = "";
++                let _ = "";
++                acc.push_str(&f);
++                acc
++            })
++            .unwrap_or(String::new());
++    }
++
++    fn equal_to_max_suggestion_highest_lines() {
++        let frames = Vec::new();
++        let iter = frames.iter();
++        iter.map(|f: &String| f.to_lowercase())
++            .reduce(|mut acc, f| {
++                let _ = "";
++                acc.push_str(&f);
++                acc
++            })
++            .unwrap_or(String::new());
++    }
++
++    fn less_than_max_suggestion_highest_lines() {
++        let frames = Vec::new();
++        let iter = frames.iter();
++        let map = iter.map(|f: &String| f.to_lowercase());
++        map.reduce(|mut acc, f| {
++            acc.push_str(&f);
++            acc
++        })
++        .unwrap_or(String::new());
++    }
++}
++
+ +fn main() {}
diff --cc src/tools/clippy/tests/ui/or_fun_call.stderr

index 9d0c42b10c27f500eaa0469e43d1d1bcbfb0ae65,0000000000000000000000000000000000000000..549b00ae3c45980c75ac3b229d2139e7375e7ccb

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/or_fun_call.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/or_fun_call.stderr
@@@ -1,112 -1,0 +1,164 @@@
- error: aborting due to 18 previous errors
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:49:22
+ +   |
+ +LL |     with_constructor.unwrap_or(make());
+ +   |                      ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(make)`
+ +   |
+ +   = note: `-D clippy::or-fun-call` implied by `-D warnings`
+ +
+ +error: use of `unwrap_or` followed by a call to `new`
+ +  --> $DIR/or_fun_call.rs:52:5
+ +   |
+ +LL |     with_new.unwrap_or(Vec::new());
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_new.unwrap_or_default()`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:55:21
+ +   |
+ +LL |     with_const_args.unwrap_or(Vec::with_capacity(12));
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| Vec::with_capacity(12))`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:58:14
+ +   |
+ +LL |     with_err.unwrap_or(make());
+ +   |              ^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| make())`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:61:19
+ +   |
+ +LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
+ +   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| Vec::with_capacity(12))`
+ +
+ +error: use of `unwrap_or` followed by a call to `default`
+ +  --> $DIR/or_fun_call.rs:64:5
+ +   |
+ +LL |     with_default_trait.unwrap_or(Default::default());
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_trait.unwrap_or_default()`
+ +
+ +error: use of `unwrap_or` followed by a call to `default`
+ +  --> $DIR/or_fun_call.rs:67:5
+ +   |
+ +LL |     with_default_type.unwrap_or(u64::default());
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_default_type.unwrap_or_default()`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:70:18
+ +   |
+ +LL |     self_default.unwrap_or(<FakeDefault>::default());
+ +   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(<FakeDefault>::default)`
+ +
+ +error: use of `unwrap_or` followed by a call to `default`
+ +  --> $DIR/or_fun_call.rs:73:5
+ +   |
+ +LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `real_default.unwrap_or_default()`
+ +
+ +error: use of `unwrap_or` followed by a call to `new`
+ +  --> $DIR/or_fun_call.rs:76:5
+ +   |
+ +LL |     with_vec.unwrap_or(vec![]);
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `with_vec.unwrap_or_default()`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:79:21
+ +   |
+ +LL |     without_default.unwrap_or(Foo::new());
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(Foo::new)`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:94:21
+ +   |
+ +LL |     let _ = stringy.unwrap_or("".to_owned());
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| "".to_owned())`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:102:21
+ +   |
+ +LL |     let _ = Some(1).unwrap_or(map[&1]);
+ +   |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:104:21
+ +   |
+ +LL |     let _ = Some(1).unwrap_or(map[&1]);
+ +   |                     ^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| map[&1])`
+ +
+ +error: use of `or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:128:35
+ +   |
+ +LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
+ +   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `or_else(|| Some("b".to_string()))`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:167:14
+ +   |
+ +LL |         None.unwrap_or(ptr_to_ref(s));
+ +   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| ptr_to_ref(s))`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:173:14
+ +   |
+ +LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
+ +   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
+ +
+ +error: use of `unwrap_or` followed by a function call
+ +  --> $DIR/or_fun_call.rs:175:14
+ +   |
+ +LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
+ +   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
+ +
++error: use of `unwrap_or` followed by a call to `new`
++  --> $DIR/or_fun_call.rs:189:14
++   |
++LL |             .unwrap_or(String::new());
++   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
++
++error: use of `unwrap_or` followed by a call to `new`
++  --> $DIR/or_fun_call.rs:202:14
++   |
++LL |             .unwrap_or(String::new());
++   |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_default()`
++
++error: use of `unwrap_or` followed by a call to `new`
++  --> $DIR/or_fun_call.rs:208:9
++   |
++LL | /         iter.map(|f: &String| f.to_lowercase())
++LL | |             .reduce(|mut acc, f| {
++LL | |                 let _ = "";
++LL | |                 acc.push_str(&f);
++LL | |                 acc
++LL | |             })
++LL | |             .unwrap_or(String::new());
++   | |_____________________________________^
++   |
++help: try this
++   |
++LL ~         iter.map(|f: &String| f.to_lowercase())
++LL +             .reduce(|mut acc, f| {
++LL +                 let _ = "";
++LL +                 acc.push_str(&f);
++LL +                 acc
++LL ~             }).unwrap_or_default();
++   |
++
++error: use of `unwrap_or` followed by a call to `new`
++  --> $DIR/or_fun_call.rs:221:9
++   |
++LL | /         map.reduce(|mut acc, f| {
++LL | |             acc.push_str(&f);
++LL | |             acc
++LL | |         })
++LL | |         .unwrap_or(String::new());
++   | |_________________________________^
++   |
++help: try this
++   |
++LL ~         map.reduce(|mut acc, f| {
++LL +             acc.push_str(&f);
++LL +             acc
++LL ~         }).unwrap_or_default();
++   |
++
++error: aborting due to 22 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/return_self_not_must_use.rs

index 7dd5742dae9f213d5038af6d0422b6b201342db6,0000000000000000000000000000000000000000..9b33ad6d3f6b3f83b26ca2ab4384bea9ee60cf51

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/return_self_not_must_use.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/return_self_not_must_use.rs
@@@ -1,57 -1,0 +1,58 @@@
+ +#![crate_type = "lib"]
++#![warn(clippy::return_self_not_must_use)]
+ +
+ +#[derive(Clone)]
+ +pub struct Bar;
+ +
+ +pub trait Whatever {
+ +    fn what(&self) -> Self;
+ +    // There should be no warning here! (returns a reference)
+ +    fn what2(&self) -> &Self;
+ +}
+ +
+ +impl Bar {
+ +    // There should be no warning here! (note taking a self argument)
+ +    pub fn not_new() -> Self {
+ +        Self
+ +    }
+ +    pub fn foo(&self) -> Self {
+ +        Self
+ +    }
+ +    pub fn bar(self) -> Self {
+ +        self
+ +    }
+ +    // There should be no warning here! (private method)
+ +    fn foo2(&self) -> Self {
+ +        Self
+ +    }
+ +    // There should be no warning here! (returns a reference)
+ +    pub fn foo3(&self) -> &Self {
+ +        self
+ +    }
+ +    // There should be no warning here! (already a `must_use` attribute)
+ +    #[must_use]
+ +    pub fn foo4(&self) -> Self {
+ +        Self
+ +    }
+ +}
+ +
+ +impl Whatever for Bar {
+ +    // There should be no warning here! (comes from the trait)
+ +    fn what(&self) -> Self {
+ +        self.foo2()
+ +    }
+ +    // There should be no warning here! (comes from the trait)
+ +    fn what2(&self) -> &Self {
+ +        self
+ +    }
+ +}
+ +
+ +#[must_use]
+ +pub struct Foo;
+ +
+ +impl Foo {
+ +    // There should be no warning here! (`Foo` already implements `#[must_use]`)
+ +    fn foo(&self) -> Self {
+ +        Self
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/return_self_not_must_use.stderr

index 8af10cb65c40670202da1fd459fea989382ccafc,0000000000000000000000000000000000000000..94be87dfa31c73c85a57a262c203d162252cc098

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/return_self_not_must_use.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/return_self_not_must_use.stderr
@@@ -1,31 -1,0 +1,31 @@@
-   --> $DIR/return_self_not_must_use.rs:7:5
+ +error: missing `#[must_use]` attribute on a method returning `Self`
-   --> $DIR/return_self_not_must_use.rs:17:5
++  --> $DIR/return_self_not_must_use.rs:8:5
+ +   |
+ +LL |     fn what(&self) -> Self;
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^
+ +   |
+ +   = note: `-D clippy::return-self-not-must-use` implied by `-D warnings`
+ +   = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
+ +
+ +error: missing `#[must_use]` attribute on a method returning `Self`
-   --> $DIR/return_self_not_must_use.rs:20:5
++  --> $DIR/return_self_not_must_use.rs:18:5
+ +   |
+ +LL | /     pub fn foo(&self) -> Self {
+ +LL | |         Self
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +   = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
+ +
+ +error: missing `#[must_use]` attribute on a method returning `Self`
++  --> $DIR/return_self_not_must_use.rs:21:5
+ +   |
+ +LL | /     pub fn bar(self) -> Self {
+ +LL | |         self
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +   = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
+ +
+ +error: aborting due to 3 previous errors
+ +
diff --cc src/tools/clippy/util/gh-pages/index.html

index f175700a3f479dcf912db12fcb587ed44ea3d94b,0000000000000000000000000000000000000000..5b7e61a349d979c08b68fc04e994c1b35f018e69

mode 100644,000000..100644
--- 1/src/tools/clippy/util/gh-pages/index.html
--- /dev/null
+++ b/src/tools/clippy/util/gh-pages/index.html
@@@ -1,611 -1,0 +1,611 @@@
-     <script src="https://cdnjs.cloudflare.com/ajax/libs/markdown-it/7.0.0/markdown-it.min.js"></script>
+ +<!DOCTYPE html>
+ +<!--
+ +Welcome to a Clippy's lint list, at least the source code of it. If you are
+ +interested in contributing to this website checkout `util/gh-pages/index.html`
+ +inside the rust-clippy repository.
+ +
+ +Otherwise, have a great day =^.^=
+ +-->
+ +<html lang="en">
+ +<head>
+ +    <meta charset="UTF-8"/>
+ +    <meta name="viewport" content="width=device-width, initial-scale=1"/>
+ +
+ +    <title>Clippy Lints</title>
+ +
+ +    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.6/css/bootstrap.min.css"/>
+ +    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.5.0/styles/github.min.css"/>
+ +
+ +    <!-- The files are not copied over into the Clippy project since they use the MPL-2.0 License -->
+ +    <link rel="stylesheet" href="https://rust-lang.github.io/mdBook/css/variables.css"/>
+ +    <link id="styleHighlight" rel="stylesheet" href="https://rust-lang.github.io/mdBook/highlight.css">
+ +    <link id="styleNight" rel="stylesheet" href="https://rust-lang.github.io/mdBook/tomorrow-night.css" disabled="true">
+ +    <link id="styleAyu" rel="stylesheet" href="https://rust-lang.github.io/mdBook/ayu-highlight.css" disabled="true">
+ +    <style>
+ +        blockquote { font-size: 1em; }
+ +        [ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak { display: none !important; }
+ +
+ +        .form-inline .checkbox { margin-right: 0.6em }
+ +
+ +        .panel-heading { cursor: pointer; }
+ +
+ +        .panel-title { display: flex; flex-wrap: wrap;}
+ +        .panel-title .label { display: inline-block; }
+ +
+ +        .panel-title-name { flex: 1; min-width: 400px;}
+ +        .panel-title-name span { vertical-align: bottom; }
+ +
+ +        .panel .panel-title-name .anchor { display: none; }
+ +        .panel:hover .panel-title-name .anchor { display: inline;}
+ +
+ +        .label {
+ +            padding-top: 0.3em;
+ +            padding-bottom: 0.3em;
+ +        }
+ +
+ +        .label-lint-group {
+ +            min-width: 8em;
+ +        }
+ +        .label-lint-level {
+ +            min-width: 4em;
+ +        }
+ +
+ +        .label-lint-level-allow {
+ +            background-color: #5cb85c;
+ +        }
+ +        .label-lint-level-warn {
+ +            background-color: #f0ad4e;
+ +        }
+ +        .label-lint-level-deny {
+ +            background-color: #d9534f;
+ +        }
+ +        .label-lint-level-none {
+ +            background-color: #777777;
+ +            opacity: 0.5;
+ +        }
+ +
+ +        .label-group-deprecated {
+ +            opacity: 0.5;
+ +        }
+ +
+ +        .label-doc-folding {
+ +            color: #000;
+ +            background-color: #fff;
+ +            border: 1px solid var(--theme-popup-border);
+ +        }
+ +        .label-doc-folding:hover {
+ +            background-color: #e6e6e6;
+ +        }
+ +
+ +        .lint-doc-md > h3 {
+ +            border-top: 1px solid var(--theme-popup-border);
+ +            padding: 10px 15px;
+ +            margin: 0 -15px;
+ +            font-size: 18px;
+ +        }
+ +        .lint-doc-md > h3:first-child {
+ +            border-top: none;
+ +            padding-top: 0px;
+ +        }
+ +
+ +        @media (max-width:749px) {
+ +            .lint-additional-info-container {
+ +                display: flex;
+ +                flex-flow: column;
+ +            }
+ +            .lint-additional-info-item + .lint-additional-info-item {
+ +                border-top: 1px solid var(--theme-popup-border);
+ +            }
+ +        }
+ +        @media (min-width:750px) {
+ +            .lint-additional-info-container {
+ +                display: flex;
+ +                flex-flow: row;
+ +            }
+ +            .lint-additional-info-item + .lint-additional-info-item {
+ +                border-left: 1px solid var(--theme-popup-border);
+ +            }
+ +        }
+ +
+ +        .lint-additional-info-item {
+ +            display: inline-flex;
+ +            min-width: 200px;
+ +            flex-grow: 1;
+ +            padding: 9px 5px 5px 15px;
+ +        }
+ +
+ +        .label-applicability {
+ +            background-color: #777777;
+ +            margin: auto 5px;
+ +        }
+ +
+ +        .label-version {
+ +            background-color: #777777;
+ +            margin: auto 5px;
+ +            font-family: monospace;
+ +        }
+ +    </style>
+ +    <style>
+ +        /* Expanding the mdBoom theme*/
+ +        .light {
+ +            --inline-code-bg: #f6f7f6;
+ +        }
+ +        .rust {
+ +            --inline-code-bg: #f6f7f6;
+ +        }
+ +        .coal {
+ +            --inline-code-bg: #1d1f21;
+ +        }
+ +        .navy {
+ +            --inline-code-bg: #1d1f21;
+ +        }
+ +        .ayu {
+ +            --inline-code-bg: #191f26;
+ +        }
+ +
+ +        /* Applying the mdBook theme */
+ +        .theme-icon {
+ +            position: absolute;
+ +            text-align: center;
+ +            width: 2em;
+ +            height: 2em;
+ +            margin: 0.7em;
+ +            line-height: 2em;
+ +            border: solid 1px var(--icons);
+ +            border-radius: 5px;
+ +            user-select: none;
+ +            cursor: pointer;
+ +        }
+ +        .theme-icon:hover {
+ +            background: var(--theme-hover);
+ +        }
+ +        .theme-choice {
+ +            position: absolute;
+ +            margin-top: calc(2em + 0.7em);
+ +            margin-left: 0.7em;
+ +            list-style: none;
+ +            border: 1px solid var(--theme-popup-border);
+ +            border-radius: 5px;
+ +            color: var(--fg);
+ +            background: var(--theme-popup-bg);
+ +            padding: 0 0;
+ +        }
+ +        .theme-choice > li {
+ +            padding: 5px 10px;
+ +            font-size: 0.8em;
+ +            user-select: none;
+ +            cursor: pointer;
+ +        }
+ +        .theme-choice > li:hover {
+ +            background: var(--theme-hover);
+ +        }
+ +
+ +        .alert {
+ +            color: var(--fg);
+ +            background: var(--theme-hover);
+ +            border: 1px solid var(--theme-popup-border);
+ +        }
+ +        .page-header {
+ +            border-color: var(--theme-popup-border);
+ +        }
+ +        .panel-default > .panel-heading {
+ +            background: var(--theme-hover);
+ +            color: var(--fg);
+ +            border: 1px solid var(--theme-popup-border);
+ +        }
+ +        .panel-default > .panel-heading:hover {
+ +            filter: brightness(90%);
+ +        }
+ +        .list-group-item {
+ +            background: 0%;
+ +            border: 1px solid var(--theme-popup-border);
+ +        }
+ +        .panel, pre, hr {
+ +            background: var(--bg);
+ +            border: 1px solid var(--theme-popup-border);
+ +        }
+ +
+ +        #filter-label, #filter-clear {
+ +            background: var(--searchbar-bg);
+ +            color: var(--searchbar-fg);
+ +            border-color: var(--theme-popup-border);
+ +            filter: brightness(95%);
+ +        }
+ +        #filter-label:hover, #filter-clear:hover {
+ +            filter: brightness(90%);
+ +        }
+ +        #filter-input {
+ +            background: var(--searchbar-bg);
+ +            color: var(--searchbar-fg);
+ +            border-color: var(--theme-popup-border);
+ +        }
+ +
+ +        #filter-input::-webkit-input-placeholder,
+ +        #filter-input::-moz-placeholder {
+ +            color: var(--searchbar-fg);
+ +            opacity: 30%;
+ +        }
+ +
+ +        :not(pre) > code {
+ +            color: var(--inline-code-color);
+ +            background-color: var(--inline-code-bg);
+ +        }
+ +        html {
+ +            scrollbar-color: var(--scrollbar) var(--bg);
+ +        }
+ +        body {
+ +            background: var(--bg);
+ +            color: var(--fg);
+ +        }
+ +
+ +    </style>
+ +</head>
+ +<body>
+ +    <div id="theme-icon" class="theme-icon">&#128396;</div>
+ +    <ul id="theme-menu" class="theme-choice" style="display: none;">
+ +        <li id="light">Light</li>
+ +        <li id="rust">Rust</li>
+ +        <li id="coal">Coal</li>
+ +        <li id="navy">Navy</li>
+ +        <li id="ayu">Ayu</li>
+ +    </ul>
+ +
+ +    <div class="container" ng-app="clippy" ng-controller="lintList">
+ +        <div class="page-header">
+ +            <h1>Clippy Lints</h1>
+ +        </div>
+ +
+ +        <noscript>
+ +            <div class="alert alert-danger" role="alert">
+ +                Sorry, this site only works with JavaScript! :(
+ +            </div>
+ +        </noscript>
+ +
+ +        <div ng-cloak>
+ +
+ +            <div class="alert alert-info" role="alert" ng-if="loading">
+ +                Loading&#x2026;
+ +            </div>
+ +            <div class="alert alert-danger" role="alert" ng-if="error">
+ +                Error loading lints!
+ +            </div>
+ +
+ +            <div class="panel panel-default" ng-show="data">
+ +                <div class="panel-body row filter-panel">
+ +                    <div class="col-md-6 form-inline">
+ +                        <div class="form-group form-group-lg">
+ +                            <p class="h4">
+ +                                Lint levels
+ +                                <a href="https://doc.rust-lang.org/rustc/lints/levels.html">(?)</a>
+ +                            </p>
+ +                            <div class="checkbox" ng-repeat="(level, enabled) in levels">
+ +                                <label class="text-capitalize">
+ +                                    <input type="checkbox" ng-model="levels[level]" />
+ +                                    {{level}}
+ +                                </label>
+ +                            </div>
+ +                        </div>
+ +                    </div>
+ +                    <div class="col-md-6 form-inline">
+ +                        <div class="form-group form-group-lg">
+ +                            <p class="h4">
+ +                                Lint groups
+ +                                <a href="https://github.com/rust-lang/rust-clippy/#clippy">(?)</a>
+ +                            </p>
+ +                            <div class="checkbox" ng-repeat="(group, enabled) in groups">
+ +                                <label class="text-capitalize">
+ +                                    <input type="checkbox" ng-model="groups[group]" />
+ +                                    {{group}}
+ +                                </label>
+ +                            </div>
+ +                        </div>
+ +                    </div>
+ +                </div>
+ +                <div class="panel-body row">
+ +                    <div class="col-md-12 form-horizontal">
+ +                        <div class="input-group">
+ +                            <label class="input-group-addon" id="filter-label" for="filter-input">Filter:</label>
+ +                            <input type="text" class="form-control" placeholder="Keywords or search string" id="filter-input" ng-model="search" ng-model-options="{debounce: 50}"/>
+ +                            <span class="input-group-btn">
+ +                                <button id="filter-clear" class="btn" type="button" ng-click="search = ''">
+ +                                    Clear
+ +                                </button>
+ +                            </span>
+ +                        </div>
+ +                    </div>
+ +                </div>
+ +            </div>
+ +            <!-- The order of the filters should be from most likely to remove a lint to least likely to improve performance. -->
+ +            <article class="panel panel-default" id="{{lint.id}}" ng-repeat="lint in data | filter:bySearch | filter:byGroups | filter:byLevels">
+ +                <header class="panel-heading" ng-click="open[lint.id] = !open[lint.id]">
+ +                    <h2 class="panel-title">
+ +                        <div class="panel-title-name">
+ +                            <span>{{lint.id}}</span>
+ +                            <a href="#{{lint.id}}" class="anchor label label-default" ng-click="open[lint.id] = true; $event.stopPropagation()">&para;</a>
+ +                        </div>
+ +
+ +                        <div class="panel-title-addons">
+ +                            <span class="label label-lint-group label-default label-group-{{lint.group}}">{{lint.group}}</span>
+ +
+ +                            <span class="label label-lint-level label-lint-level-{{lint.level}}">{{lint.level}}</span>
+ +
+ +
+ +                            <span class="label label-doc-folding" ng-show="open[lint.id]">&minus;</span>
+ +                            <span class="label label-doc-folding" ng-hide="open[lint.id]">&plus;</span>
+ +                        </div>
+ +                    </h2>
+ +                </header>
+ +
+ +                <div class="list-group lint-docs" ng-class="{collapse: true, in: open[lint.id]}">
+ +                    <div class="list-group-item lint-doc-md" ng-bind-html="lint.docs | markdown"></div>
+ +                    <div class="lint-additional-info-container">
+ +                        <!-- Applicability -->
+ +                        <div class="lint-additional-info-item">
+ +                            <span> Applicability: </span>
+ +                            <span class="label label-default label-applicability">{{lint.applicability.applicability}}</span>
+ +                            <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint_defs/enum.Applicability.html#variants">(?)</a>
+ +                        </div>
+ +                        <!-- Clippy version -->
+ +                        <div class="lint-additional-info-item">
+ +                            <span>{{lint.group == "deprecated" ? "Deprecated" : "Added"}} in: </span>
+ +                            <span class="label label-default label-version">{{lint.version}}</span>
+ +                        </div>
+ +                        <!-- Open related issues -->
+ +                        <div class="lint-additional-info-item">
+ +                            <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>
+ +                        </div>
+ +                        <!-- Jump to source -->
+ +                        <div class="lint-additional-info-item">
+ +                            <a href="https://github.com/rust-lang/rust-clippy/blob/{{docVersion}}/clippy_lints/{{lint.id_span.path}}#L{{lint.id_span.line}}">View Source</a>
+ +                        </div>
+ +                    </div>
+ +                </div>
+ +            </article>
+ +        </div>
+ +    </div>
+ +
+ +    <a href="https://github.com/rust-lang/rust-clippy">
+ +        <img style="position: absolute; top: 0; right: 0; border: 0;" src="https://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on Github"/>
+ +    </a>
+ +
++    <script src="https://cdnjs.cloudflare.com/ajax/libs/markdown-it/12.3.2/markdown-it.min.js"></script>
+ +    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.5.0/highlight.min.js"></script>
+ +    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.5.0/languages/rust.min.js"></script>
+ +    <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.12/angular.min.js"></script>
+ +    <script>
+ +    (function () {
+ +        var md = window.markdownit({
+ +            html: true,
+ +            linkify: true,
+ +            typographer: true,
+ +            highlight: function (str, lang) {
+ +                if (lang && hljs.getLanguage(lang)) {
+ +                    try {
+ +                        return '<pre class="hljs"><code>' +
+ +                            hljs.highlight(lang, str, true).value +
+ +                            '</code></pre>';
+ +                    } catch (__) {}
+ +                }
+ +
+ +                return '<pre class="hljs"><code>' + md.utils.escapeHtml(str) + '</code></pre>';
+ +            }
+ +        });
+ +
+ +        function scrollToLint(lintId) {
+ +            var target = document.getElementById(lintId);
+ +            if (!target) {
+ +                return;
+ +            }
+ +            target.scrollIntoView();
+ +        }
+ +
+ +        function scrollToLintByURL($scope) {
+ +            var removeListener = $scope.$on('ngRepeatFinished', function(ngRepeatFinishedEvent) {
+ +                scrollToLint(window.location.hash.slice(1));
+ +                removeListener();
+ +            });
+ +        }
+ +
+ +        function selectGroup($scope, selectedGroup) {
+ +            var groups = $scope.groups;
+ +            for (var group in groups) {
+ +                if (groups.hasOwnProperty(group)) {
+ +                    if (group === selectedGroup) {
+ +                        groups[group] = true;
+ +                    } else {
+ +                        groups[group] = false;
+ +                    }
+ +                }
+ +            }
+ +        }
+ +
+ +        angular.module("clippy", [])
+ +        .filter('markdown', function ($sce) {
+ +            return function (text) {
+ +                return $sce.trustAsHtml(
+ +                    md.render(text || '')
+ +                    // Oh deer, what a hack :O
+ +                    .replace('<table', '<table class="table"')
+ +                );
+ +            };
+ +        })
+ +        .directive('onFinishRender', function ($timeout) {
+ +            return {
+ +                restrict: 'A',
+ +                link: function (scope, element, attr) {
+ +                    if (scope.$last === true) {
+ +                        $timeout(function () {
+ +                            scope.$emit(attr.onFinishRender);
+ +                        });
+ +                    }
+ +                }
+ +            };
+ +        })
+ +        .controller("lintList", function ($scope, $http, $timeout) {
+ +            // Level filter
+ +            var LEVEL_FILTERS_DEFAULT = {allow: true, warn: true, deny: true, none: true};
+ +            $scope.levels = LEVEL_FILTERS_DEFAULT;
+ +            $scope.byLevels = function (lint) {
+ +                return $scope.levels[lint.level];
+ +            };
+ +
+ +            var GROUPS_FILTER_DEFAULT = {
+ +                cargo: true,
+ +                complexity: true,
+ +                correctness: true,
+ +                deprecated: false,
+ +                nursery: true,
+ +                pedantic: true,
+ +                perf: true,
+ +                restriction: true,
+ +                style: true,
+ +                suspicious: true,
+ +            };
+ +            $scope.groups = GROUPS_FILTER_DEFAULT;
+ +            $scope.byGroups = function (lint) {
+ +                return $scope.groups[lint.group];
+ +            };
+ +
+ +            $scope.bySearch = function (lint, index, array) {
+ +                let searchStr = $scope.search;
+ +                // It can be `null` I haven't missed this value
+ +                if (searchStr == null || searchStr.length < 3) {
+ +                    return true;
+ +                }
+ +                searchStr = searchStr.toLowerCase();
+ +
+ +                // Search by id
+ +                if (lint.id.indexOf(searchStr.replace("-", "_")) !== -1) {
+ +                    return true;
+ +                }
+ +
+ +                // Search the description
+ +                // The use of `for`-loops instead of `foreach` enables us to return early
+ +                let terms = searchStr.split(" ");
+ +                let docsLowerCase = lint.docs.toLowerCase();
+ +                for (index = 0; index < terms.length; index++) {
+ +                    // This is more likely and will therefor be checked first
+ +                    if (docsLowerCase.indexOf(terms[index]) !== -1) {
+ +                        continue;
+ +                    }
+ +
+ +                    if (lint.id.indexOf(terms[index]) !== -1) {
+ +                        continue;
+ +                    }
+ +
+ +                    return false;
+ +                }
+ +
+ +                return true;
+ +            }
+ +
+ +            // Get data
+ +            $scope.open = {};
+ +            $scope.loading = true;
+ +            // This will be used to jump into the source code of the version that this documentation is for.
+ +            $scope.docVersion = window.location.pathname.split('/')[2] || "master";
+ +
+ +            if (window.location.hash.length > 1) {
+ +                $scope.search = window.location.hash.slice(1);
+ +                $scope.open[window.location.hash.slice(1)] = true;
+ +                scrollToLintByURL($scope);
+ +            }
+ +
+ +            $http.get('./lints.json')
+ +            .success(function (data) {
+ +                $scope.data = data;
+ +                $scope.loading = false;
+ +
+ +                var selectedGroup = getQueryVariable("sel");
+ +                if (selectedGroup) {
+ +                    selectGroup($scope, selectedGroup.toLowerCase());
+ +                }
+ +
+ +                scrollToLintByURL($scope);
+ +            })
+ +            .error(function (data) {
+ +                $scope.error = data;
+ +                $scope.loading = false;
+ +            });
+ +
+ +            window.addEventListener('hashchange', function () {
+ +                // trigger re-render
+ +                $timeout(function () {
+ +                    $scope.levels = LEVEL_FILTERS_DEFAULT;
+ +                    $scope.search = window.location.hash.slice(1);
+ +                    $scope.open[window.location.hash.slice(1)] = true;
+ +
+ +                    scrollToLintByURL($scope);
+ +                });
+ +                return true;
+ +            }, false);
+ +        });
+ +    })();
+ +
+ +    function getQueryVariable(variable) {
+ +        var query = window.location.search.substring(1);
+ +        var vars = query.split('&');
+ +        for (var i = 0; i < vars.length; i++) {
+ +            var pair = vars[i].split('=');
+ +            if (decodeURIComponent(pair[0]) == variable) {
+ +                return decodeURIComponent(pair[1]);
+ +            }
+ +        }
+ +    }
+ +
+ +    function setupListeners() {
+ +        let themeIcon = document.getElementById("theme-icon");
+ +        let themeMenu = document.getElementById("theme-menu");
+ +        themeIcon.addEventListener("click", function(e) {
+ +            if (themeMenu.style.display == "none") {
+ +                themeMenu.style.display = "block";
+ +            } else {
+ +                themeMenu.style.display = "none";
+ +            }
+ +        });
+ +
+ +        let children = themeMenu.children;
+ +        for (let index = 0; index < children.length; index++) {
+ +            let child = children[index];
+ +            child.addEventListener("click", function(e) {
+ +                setTheme(child.id, true);
+ +            });
+ +        }
+ +    }
+ +
+ +    setupListeners();
+ +
+ +    function setTheme(theme, store) {
+ +        let enableHighlight = false;
+ +        let enableNight = false;
+ +        let enableAyu = false;
+ +
+ +        if (theme == "ayu") {
+ +            enableAyu = true;
+ +        } else if (theme == "coal" || theme == "navy") {
+ +            enableNight = true;
+ +        } else if (theme == "rust") {
+ +            enableHighlight = true;
+ +        } else {
+ +            enableHighlight = true;
+ +            // this makes sure that an unknown theme request gets set to a known one
+ +            theme = "light";
+ +        }
+ +        document.getElementsByTagName("body")[0].className = theme;
+ +
+ +        document.getElementById("styleHighlight").disabled = !enableHighlight;
+ +        document.getElementById("styleNight").disabled = !enableNight;
+ +        document.getElementById("styleAyu").disabled = !enableAyu;
+ +
+ +        if (store) {
+ +            try {
+ +                localStorage.setItem('clippy-lint-list-theme', theme);
+ +            } catch (e) { }
+ +        }
+ +    }
+ +
+ +    // loading the theme after the initial load
+ +    setTheme(localStorage.getItem('clippy-lint-list-theme'), false);
+ +    </script>
+ +</body>
+ +</html>
author	flip1995 <philipp.krones@embecosm.com>
	Mon, 17 Jan 2022 12:29:07 +0000 (13:29 +0100)
committer	flip1995 <philipp.krones@embecosm.com>
	Mon, 17 Jan 2022 12:29:07 +0000 (13:29 +0100)
		1	2
src/tools/clippy/CHANGELOG.md	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/COPYRIGHT	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/LICENSE-APACHE	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/LICENSE-MIT	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/README.md	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/bit_mask.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/copies.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/format.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/iter_not_returning_iterator.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/lib.register_all.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/lib.register_lints.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/lib.register_pedantic.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/lib.register_perf.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/lib.register_suspicious.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/methods/mod.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/misc.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/return_self_not_must_use.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/rustc_tools_util/README.md	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/cmp_owned/comparison_flip.fixed	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/cmp_owned/comparison_flip.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/cmp_owned/comparison_flip.stderr	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/format.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/format.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/format.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/functions.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/functions.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/if_same_then_else2.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/implicit_clone.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/implicit_clone.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/iter_not_returning_iterator.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/iter_overeager_cloned.fixed	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/iter_overeager_cloned.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/iter_overeager_cloned.stderr	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/or_fun_call.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/or_fun_call.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/or_fun_call.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/return_self_not_must_use.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/return_self_not_must_use.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/util/gh-pages/index.html	patch \|	diff1 \|	\|	blob \| history