Merge commit '57b3c4b90f4346b3990c1be387c3b3ca7b78412c' into clippyup

author flip1995 <philipp.krones@embecosm.com>

Thu, 10 Feb 2022 17:40:06 +0000 (18:40 +0100)

committer flip1995 <philipp.krones@embecosm.com>

Thu, 10 Feb 2022 17:40:06 +0000 (18:40 +0100)
author flip1995 <philipp.krones@embecosm.com>
Thu, 10 Feb 2022 17:40:06 +0000 (18:40 +0100)
committer flip1995 <philipp.krones@embecosm.com>
Thu, 10 Feb 2022 17:40:06 +0000 (18:40 +0100)
diff --cc src/tools/clippy/CHANGELOG.md

index d66e6cf7fb6596ad20f5cfb1bf9dfba0e409d624,0000000000000000000000000000000000000000..c9adf77c0d639a0560073ea4889d32b06bb60344

mode 100644,000000..100644
--- 1/src/tools/clippy/CHANGELOG.md
--- /dev/null
+++ b/src/tools/clippy/CHANGELOG.md
@@@ -1,3390 -1,0 +1,3563 @@@
- [e181011...master](https://github.com/rust-lang/rust-clippy/compare/e181011...master)
+ +# 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
+ +
- ## Rust 1.58 (beta)
++[0eff589...master](https://github.com/rust-lang/rust-clippy/compare/0eff589...master)
+ +
- Current beta, release 2022-01-13
++## Rust 1.59 (beta)
+ +
- Current stable, released 2021-12-02
++Current beta, release 2022-02-24
++
++[e181011...0eff589](https://github.com/rust-lang/rust-clippy/compare/e181011...0eff589)
++
++### New Lints
++
++* [`index_refutable_slice`]
++  [#7643](https://github.com/rust-lang/rust-clippy/pull/7643)
++* [`needless_splitn`]
++  [#7896](https://github.com/rust-lang/rust-clippy/pull/7896)
++* [`unnecessary_to_owned`]
++  [#7978](https://github.com/rust-lang/rust-clippy/pull/7978)
++* [`needless_late_init`]
++  [#7995](https://github.com/rust-lang/rust-clippy/pull/7995)
++* [`octal_escapes`] [#8007](https://github.com/rust-lang/rust-clippy/pull/8007)
++* [`return_self_not_must_use`]
++  [#8071](https://github.com/rust-lang/rust-clippy/pull/8071)
++* [`init_numbered_fields`]
++  [#8170](https://github.com/rust-lang/rust-clippy/pull/8170)
++
++### Moves and Deprecations
++
++* Move `if_then_panic` to `pedantic` and rename to [`manual_assert`] (now
++  allow-by-default) [#7810](https://github.com/rust-lang/rust-clippy/pull/7810)
++* Rename `disallow_type` to [`disallowed_types`] and `disallowed_method` to
++  [`disallowed_methods`]
++  [#7984](https://github.com/rust-lang/rust-clippy/pull/7984)
++* Move [`map_flatten`] to `complexity` (now warn-by-default)
++  [#8054](https://github.com/rust-lang/rust-clippy/pull/8054)
++
++### Enhancements
++
++* [`match_overlapping_arm`]: Fix false negative where after included ranges,
++  overlapping ranges weren't linted anymore
++  [#7909](https://github.com/rust-lang/rust-clippy/pull/7909)
++* [`deprecated_cfg_attr`]: Now takes the specified MSRV into account
++  [#7944](https://github.com/rust-lang/rust-clippy/pull/7944)
++* [`cast_lossless`]: Now also lints for `bool` to integer casts
++  [#7948](https://github.com/rust-lang/rust-clippy/pull/7948)
++* [`let_underscore_lock`]: Also emit lints for the `parking_lot` crate
++  [#7957](https://github.com/rust-lang/rust-clippy/pull/7957)
++* [`needless_borrow`]
++  [#7977](https://github.com/rust-lang/rust-clippy/pull/7977)
++    * Lint when a borrow is auto-dereffed more than once
++    * Lint in the trailing expression of a block for a match arm
++* [`strlen_on_c_strings`]
++  [8001](https://github.com/rust-lang/rust-clippy/pull/8001)
++    * Lint when used without a fully-qualified path
++    * Suggest removing the surrounding unsafe block when possible
++* [`non_ascii_literal`]: Now also lints on `char`s, not just `string`s
++  [#8034](https://github.com/rust-lang/rust-clippy/pull/8034)
++* [`single_char_pattern`]: Now also lints on `split_inclusive`, `split_once`,
++  `rsplit_once`, `replace`, and `replacen`
++  [#8077](https://github.com/rust-lang/rust-clippy/pull/8077)
++* [`unwrap_or_else_default`]: Now also lints on `std` constructors like
++  `Vec::new`, `HashSet::new`, and `HashMap::new`
++  [#8163](https://github.com/rust-lang/rust-clippy/pull/8163)
++* [`shadow_reuse`]: Now also lints on shadowed `if let` bindings, instead of
++  [`shadow_unrelated`]
++  [#8165](https://github.com/rust-lang/rust-clippy/pull/8165)
++
++### False Positive Fixes
++
++* [`or_fun_call`], [`unnecessary_lazy_evaluations`]: Improve heuristics, so that
++  cheap functions (e.g. calling `.len()` on a `Vec`) won't get linted anymore
++  [#7639](https://github.com/rust-lang/rust-clippy/pull/7639)
++* [`manual_split_once`]: No longer suggests code changing the original behavior
++  [#7896](https://github.com/rust-lang/rust-clippy/pull/7896)
++* Don't show [`no_effect`] or [`unnecessary_operation`] warning for unit struct
++  implementing `FnOnce`
++  [#7898](https://github.com/rust-lang/rust-clippy/pull/7898)
++* [`semicolon_if_nothing_returned`]: Fixed a bug, where the lint wrongly
++  triggered on `let-else` statements
++  [#7955](https://github.com/rust-lang/rust-clippy/pull/7955)
++* [`if_then_some_else_none`]: No longer lints if there is an early return
++  [#7980](https://github.com/rust-lang/rust-clippy/pull/7980)
++* [`needless_collect`]: No longer suggests removal of `collect` when removal
++  would create code requiring mutably borrowing a value multiple times
++  [#7982](https://github.com/rust-lang/rust-clippy/pull/7982)
++* [`shadow_same`]: Fix false positive for `async` function's params
++  [#7997](https://github.com/rust-lang/rust-clippy/pull/7997)
++* [`suboptimal_flops`]: No longer triggers in constant functions
++  [#8009](https://github.com/rust-lang/rust-clippy/pull/8009)
++* [`type_complexity`]: No longer lints on associated types in traits
++  [#8030](https://github.com/rust-lang/rust-clippy/pull/8030)
++* [`question_mark`]: No longer lints if returned object is not local
++  [#8080](https://github.com/rust-lang/rust-clippy/pull/8080)
++* [`option_if_let_else`]: No longer lint on complex sub-patterns
++  [#8086](https://github.com/rust-lang/rust-clippy/pull/8086)
++* [`blocks_in_if_conditions`]: No longer lints on empty closures
++  [#8100](https://github.com/rust-lang/rust-clippy/pull/8100)
++* [`enum_variant_names`]: No longer lint when first prefix is only a substring
++  of a camel-case word
++  [#8127](https://github.com/rust-lang/rust-clippy/pull/8127)
++* [`identity_op`]: Only lint on integral operands
++  [#8183](https://github.com/rust-lang/rust-clippy/pull/8183)
++
++### Suggestion Fixes/Improvements
++
++* [`search_is_some`]: Fix suggestion for `any()` not taking item by reference
++  [#7463](https://github.com/rust-lang/rust-clippy/pull/7463)
++* [`almost_swapped`]: Now detects if there is a `no_std` or `no_core` attribute
++  and adapts the suggestion accordingly
++  [#7877](https://github.com/rust-lang/rust-clippy/pull/7877)
++* [`redundant_pattern_matching`]: Fix suggestion for deref expressions
++  [#7949](https://github.com/rust-lang/rust-clippy/pull/7949)
++* [`explicit_counter_loop`]: Now also produces a suggestion for non-`usize`
++  types [#7950](https://github.com/rust-lang/rust-clippy/pull/7950)
++* [`manual_map`]: Fix suggestion when used with unsafe functions and blocks
++  [#7968](https://github.com/rust-lang/rust-clippy/pull/7968)
++* [`option_map_or_none`]: Suggest `map` over `and_then` when possible
++  [#7971](https://github.com/rust-lang/rust-clippy/pull/7971)
++* [`option_if_let_else`]: No longer expands macros in the suggestion
++  [#7974](https://github.com/rust-lang/rust-clippy/pull/7974)
++* [`iter_cloned_collect`]: Suggest `copied` over `cloned` when possible
++  [#8006](https://github.com/rust-lang/rust-clippy/pull/8006)
++* [`doc_markdown`]: No longer uses inline hints to improve readability of
++  suggestion [#8011](https://github.com/rust-lang/rust-clippy/pull/8011)
++* [`needless_question_mark`]: Now better explains the suggestion
++  [#8028](https://github.com/rust-lang/rust-clippy/pull/8028)
++* [`single_char_pattern`]: Escape backslash `\` in suggestion
++  [#8067](https://github.com/rust-lang/rust-clippy/pull/8067)
++* [`needless_bool`]: Suggest `a != b` over `!(a == b)`
++  [#8117](https://github.com/rust-lang/rust-clippy/pull/8117)
++* [`iter_skip_next`]: Suggest to add a `mut` if it is necessary in order to
++  apply this lints suggestion
++  [#8133](https://github.com/rust-lang/rust-clippy/pull/8133)
++* [`neg_multiply`]: Now produces a suggestion
++  [#8144](https://github.com/rust-lang/rust-clippy/pull/8144)
++* [`needless_return`]: Now suggests the unit type `()` over an empty block `{}`
++  in match arms [#8185](https://github.com/rust-lang/rust-clippy/pull/8185)
++* [`suboptimal_flops`]: Now gives a syntactically correct suggestion for
++  `to_radians` and `to_degrees`
++  [#8187](https://github.com/rust-lang/rust-clippy/pull/8187)
++
++### ICE Fixes
++
++* [`undocumented_unsafe_blocks`]
++  [#7945](https://github.com/rust-lang/rust-clippy/pull/7945)
++  [#7988](https://github.com/rust-lang/rust-clippy/pull/7988)
++* [`unnecessary_cast`]
++  [#8167](https://github.com/rust-lang/rust-clippy/pull/8167)
++
++### Documentation Improvements
++
++* [`print_stdout`], [`print_stderr`], [`dbg_macro`]: Document how the lint level
++  can be changed crate-wide
++  [#8040](https://github.com/rust-lang/rust-clippy/pull/8040)
++* Added a note to the `README` that config changes don't apply to already
++  compiled code [#8175](https://github.com/rust-lang/rust-clippy/pull/8175)
++
++### Others
++
++* [Clippy's lint
++  list](https://rust-lang.github.io/rust-clippy/master/index.html) now displays
++  the version a lint was added. :tada:
++  [#7813](https://github.com/rust-lang/rust-clippy/pull/7813)
++* New and improved issue templates
++  [#8032](https://github.com/rust-lang/rust-clippy/pull/8032)
++* _Dev:_ Add `cargo dev lint` command, to run your modified Clippy version on a
++  file [#7917](https://github.com/rust-lang/rust-clippy/pull/7917)
++
++## Rust 1.58
++
++Current stable, released 2022-01-13
+ +
+ +[00e31fa...e181011](https://github.com/rust-lang/rust-clippy/compare/00e31fa...e181011)
+ +
++### Rust 1.58.1
++
++* Move [`non_send_fields_in_send_ty`] to `nursery` (now allow-by-default)
++  [#8075](https://github.com/rust-lang/rust-clippy/pull/8075)
++* [`useless_format`]: Handle implicit named arguments
++  [#8295](https://github.com/rust-lang/rust-clippy/pull/8295)
++
+ +### 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
+ +
++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
++[`default_union_representation`]: https://rust-lang.github.io/rust-clippy/master/index.html#default_union_representation
+ +[`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_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
++[`transmute_undefined_repr`]: https://rust-lang.github.io/rust-clippy/master/index.html#transmute_undefined_repr
+ +[`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/clippy_dev/src/bless.rs

index dcc2502e4c59a0f2cf4b01ac0f08669fe828c108,0000000000000000000000000000000000000000..b0fb39e8169968aa57624a6d988879a11021b02c

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_dev/src/bless.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_dev/src/bless.rs
@@@ -1,96 -1,0 +1,67 @@@
- use walkdir::WalkDir;
- 
- use crate::clippy_project_root;
+ +//! `bless` updates the reference files in the repo with changed output files
+ +//! from the last test run.
+ +
+ +use std::ffi::OsStr;
+ +use std::fs;
+ +use std::lazy::SyncLazy;
+ +use std::path::{Path, PathBuf};
-     let test_suite_dirs = [
-         clippy_project_root().join("tests").join("ui"),
-         clippy_project_root().join("tests").join("ui-internal"),
-         clippy_project_root().join("tests").join("ui-toml"),
-         clippy_project_root().join("tests").join("ui-cargo"),
-     ];
-     for test_suite_dir in &test_suite_dirs {
-         WalkDir::new(test_suite_dir)
-             .into_iter()
-             .filter_map(Result::ok)
-             .filter(|f| f.path().extension() == Some(OsStr::new("rs")))
-             .for_each(|f| {
-                 let test_name = f.path().strip_prefix(test_suite_dir).unwrap();
-                 for &ext in &["stdout", "stderr", "fixed"] {
-                     let test_name_ext = format!("stage-id.{}", ext);
-                     update_reference_file(
-                         f.path().with_extension(ext),
-                         test_name.with_extension(test_name_ext),
-                         ignore_timestamp,
-                     );
-                 }
-             });
-     }
++use walkdir::{DirEntry, WalkDir};
+ +
+ +#[cfg(not(windows))]
+ +static CARGO_CLIPPY_EXE: &str = "cargo-clippy";
+ +#[cfg(windows)]
+ +static CARGO_CLIPPY_EXE: &str = "cargo-clippy.exe";
+ +
+ +static CLIPPY_BUILD_TIME: SyncLazy<Option<std::time::SystemTime>> = SyncLazy::new(|| {
+ +    let mut path = std::env::current_exe().unwrap();
+ +    path.set_file_name(CARGO_CLIPPY_EXE);
+ +    fs::metadata(path).ok()?.modified().ok()
+ +});
+ +
+ +/// # Panics
+ +///
+ +/// Panics if the path to a test file is broken
+ +pub fn bless(ignore_timestamp: bool) {
- fn update_reference_file(reference_file_path: PathBuf, test_name: PathBuf, ignore_timestamp: bool) {
-     let test_output_path = build_dir().join(test_name);
-     let relative_reference_file_path = reference_file_path.strip_prefix(clippy_project_root()).unwrap();
++    let extensions = ["stdout", "stderr", "fixed"].map(OsStr::new);
++
++    WalkDir::new(build_dir())
++        .into_iter()
++        .map(Result::unwrap)
++        .filter(|entry| entry.path().extension().map_or(false, |ext| extensions.contains(&ext)))
++        .for_each(|entry| update_reference_file(&entry, ignore_timestamp));
+ +}
+ +
-     // If compiletest did not write any changes during the test run,
-     // we don't have to update anything
-     if !test_output_path.exists() {
-         return;
-     }
++fn update_reference_file(test_output_entry: &DirEntry, ignore_timestamp: bool) {
++    let test_output_path = test_output_entry.path();
+ +
-     if !ignore_timestamp && !updated_since_clippy_build(&test_output_path).unwrap_or(true) {
++    let reference_file_name = test_output_entry.file_name().to_str().unwrap().replace(".stage-id", "");
++    let reference_file_path = Path::new("tests")
++        .join(test_output_path.strip_prefix(build_dir()).unwrap())
++        .with_file_name(reference_file_name);
+ +
+ +    // If the test output was not updated since the last clippy build, it may be outdated
-         println!("updating {}", &relative_reference_file_path.display());
++    if !ignore_timestamp && !updated_since_clippy_build(test_output_entry).unwrap_or(true) {
+ +        return;
+ +    }
+ +
+ +    let test_output_file = fs::read(&test_output_path).expect("Unable to read test output file");
+ +    let reference_file = fs::read(&reference_file_path).unwrap_or_default();
+ +
+ +    if test_output_file != reference_file {
+ +        // If a test run caused an output file to change, update the reference file
- 
-         // We need to re-read the file now because it was potentially updated from copying
-         let reference_file = fs::read(&reference_file_path).unwrap_or_default();
- 
-         if reference_file.is_empty() {
-             // If we copied over an empty output file, we remove the now empty reference file
-             println!("removing {}", &relative_reference_file_path.display());
-             fs::remove_file(reference_file_path).expect("Could not remove reference file");
-         }
++        println!("updating {}", reference_file_path.display());
+ +        fs::copy(test_output_path, &reference_file_path).expect("Could not update reference file");
- fn updated_since_clippy_build(path: &Path) -> Option<bool> {
+ +    }
+ +}
+ +
-     let modified = fs::metadata(path).ok()?.modified().ok()?;
++fn updated_since_clippy_build(entry: &DirEntry) -> Option<bool> {
+ +    let clippy_build_time = (*CLIPPY_BUILD_TIME)?;
++    let modified = entry.metadata().ok()?.modified().ok()?;
+ +    Some(modified >= clippy_build_time)
+ +}
+ +
+ +fn build_dir() -> PathBuf {
+ +    let mut path = std::env::current_exe().unwrap();
+ +    path.set_file_name("test");
+ +    path
+ +}
diff --cc src/tools/clippy/clippy_lints/src/blocks_in_if_conditions.rs

index c4956bacf43617a3de0ed2a747e6d377af022430,0000000000000000000000000000000000000000..4c4dd85d518a62ae9db0938d05f56f8fdfed47dc

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/blocks_in_if_conditions.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/blocks_in_if_conditions.rs
@@@ -1,159 -1,0 +1,159 @@@
- use clippy_utils::{differing_macro_contexts, get_parent_expr};
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
++use clippy_utils::get_parent_expr;
+ +use clippy_utils::higher;
+ +use clippy_utils::source::snippet_block_with_applicability;
+ +use clippy_utils::ty::implements_trait;
-                             if expr.span.from_expansion() || differing_macro_contexts(expr.span, ex.span) {
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::intravisit::{walk_expr, Visitor};
+ +use rustc_hir::{BlockCheckMode, Expr, ExprKind};
+ +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;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `if` conditions that use blocks containing an
+ +    /// expression, statements or conditions that use closures with blocks.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Style, using blocks in the condition makes it hard to read.
+ +    ///
+ +    /// ### Examples
+ +    /// ```rust
+ +    /// // Bad
+ +    /// if { true } { /* ... */ }
+ +    ///
+ +    /// // Good
+ +    /// if true { /* ... */ }
+ +    /// ```
+ +    ///
+ +    /// // or
+ +    ///
+ +    /// ```rust
+ +    /// # fn somefunc() -> bool { true };
+ +    /// // Bad
+ +    /// if { let x = somefunc(); x } { /* ... */ }
+ +    ///
+ +    /// // Good
+ +    /// let res = { let x = somefunc(); x };
+ +    /// if res { /* ... */ }
+ +    /// ```
+ +    #[clippy::version = "1.45.0"]
+ +    pub BLOCKS_IN_IF_CONDITIONS,
+ +    style,
+ +    "useless or complex blocks that can be eliminated in conditions"
+ +}
+ +
+ +declare_lint_pass!(BlocksInIfConditions => [BLOCKS_IN_IF_CONDITIONS]);
+ +
+ +struct ExVisitor<'a, 'tcx> {
+ +    found_block: Option<&'tcx Expr<'tcx>>,
+ +    cx: &'a LateContext<'tcx>,
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
+ +    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+ +        if let ExprKind::Closure(_, _, eid, _, _) = expr.kind {
+ +            // do not lint if the closure is called using an iterator (see #1141)
+ +            if_chain! {
+ +                if let Some(parent) = get_parent_expr(self.cx, expr);
+ +                if let ExprKind::MethodCall(_, [self_arg, ..], _) = &parent.kind;
+ +                let caller = self.cx.typeck_results().expr_ty(self_arg);
+ +                if let Some(iter_id) = self.cx.tcx.get_diagnostic_item(sym::Iterator);
+ +                if implements_trait(self.cx, caller, iter_id, &[]);
+ +                then {
+ +                    return;
+ +                }
+ +            }
+ +
+ +            let body = self.cx.tcx.hir().body(eid);
+ +            let ex = &body.value;
+ +            if let ExprKind::Block(block, _) = ex.kind {
+ +                if !body.value.span.from_expansion() && !block.stmts.is_empty() {
+ +                    self.found_block = Some(ex);
+ +                    return;
+ +                }
+ +            }
+ +        }
+ +        walk_expr(self, expr);
+ +    }
+ +}
+ +
+ +const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
+ +const COMPLEX_BLOCK_MESSAGE: &str = "in an `if` condition, avoid complex blocks or closures with blocks; \
+ +                                    instead, move the block or closure higher and bind it with a `let`";
+ +
+ +impl<'tcx> LateLintPass<'tcx> for BlocksInIfConditions {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        if in_external_macro(cx.sess(), expr.span) {
+ +            return;
+ +        }
+ +        if let Some(higher::If { cond, .. }) = higher::If::hir(expr) {
+ +            if let ExprKind::Block(block, _) = &cond.kind {
+ +                if block.rules == BlockCheckMode::DefaultBlock {
+ +                    if block.stmts.is_empty() {
+ +                        if let Some(ex) = &block.expr {
+ +                            // don't dig into the expression here, just suggest that they remove
+ +                            // the block
-                         if span.from_expansion() || differing_macro_contexts(expr.span, span) {
++                            if expr.span.from_expansion() || ex.span.from_expansion() {
+ +                                return;
+ +                            }
+ +                            let mut applicability = Applicability::MachineApplicable;
+ +                            span_lint_and_sugg(
+ +                                cx,
+ +                                BLOCKS_IN_IF_CONDITIONS,
+ +                                cond.span,
+ +                                BRACED_EXPR_MESSAGE,
+ +                                "try",
+ +                                format!(
+ +                                    "{}",
+ +                                    snippet_block_with_applicability(
+ +                                        cx,
+ +                                        ex.span,
+ +                                        "..",
+ +                                        Some(expr.span),
+ +                                        &mut applicability
+ +                                    )
+ +                                ),
+ +                                applicability,
+ +                            );
+ +                        }
+ +                    } else {
+ +                        let span = block.expr.as_ref().map_or_else(|| block.stmts[0].span, |e| e.span);
++                        if span.from_expansion() || expr.span.from_expansion() {
+ +                            return;
+ +                        }
+ +                        // move block higher
+ +                        let mut applicability = Applicability::MachineApplicable;
+ +                        span_lint_and_sugg(
+ +                            cx,
+ +                            BLOCKS_IN_IF_CONDITIONS,
+ +                            expr.span.with_hi(cond.span.hi()),
+ +                            COMPLEX_BLOCK_MESSAGE,
+ +                            "try",
+ +                            format!(
+ +                                "let res = {}; if res",
+ +                                snippet_block_with_applicability(
+ +                                    cx,
+ +                                    block.span,
+ +                                    "..",
+ +                                    Some(expr.span),
+ +                                    &mut applicability
+ +                                ),
+ +                            ),
+ +                            applicability,
+ +                        );
+ +                    }
+ +                }
+ +            } else {
+ +                let mut visitor = ExVisitor { found_block: None, cx };
+ +                walk_expr(&mut visitor, cond);
+ +                if let Some(block) = visitor.found_block {
+ +                    span_lint(cx, BLOCKS_IN_IF_CONDITIONS, block.span, COMPLEX_BLOCK_MESSAGE);
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/default_union_representation.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..9b5da0bd8a66009405623eb817f6c91c10e31709

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
@@@ -1,0 -1,0 +1,105 @@@
++use clippy_utils::diagnostics::span_lint_and_help;
++use rustc_hir::{self as hir, HirId, Item, ItemKind};
++use rustc_lint::{LateContext, LateLintPass};
++use rustc_middle::ty::layout::LayoutOf;
++use rustc_session::{declare_lint_pass, declare_tool_lint};
++use rustc_span::sym;
++use rustc_typeck::hir_ty_to_ty;
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Displays a warning when a union is declared with the default representation (without a `#[repr(C)]` attribute).
++    ///
++    /// ### Why is this bad?
++    /// Unions in Rust have unspecified layout by default, despite many people thinking that they
++    /// lay out each field at the start of the union (like C does). That is, there are no guarantees
++    /// about the offset of the fields for unions with multiple non-ZST fields without an explicitly
++    /// specified layout. These cases may lead to undefined behavior in unsafe blocks.
++    ///
++    /// ### Example
++    /// ```rust
++    /// union Foo {
++    ///     a: i32,
++    ///     b: u32,
++    /// }
++    ///
++    /// fn main() {
++    ///     let _x: u32 = unsafe {
++    ///         Foo { a: 0_i32 }.b // Undefined behaviour: `b` is allowed to be padding
++    ///     };
++    /// }
++    /// ```
++    /// Use instead:
++    /// ```rust
++    /// #[repr(C)]
++    /// union Foo {
++    ///     a: i32,
++    ///     b: u32,
++    /// }
++    ///
++    /// fn main() {
++    ///     let _x: u32 = unsafe {
++    ///         Foo { a: 0_i32 }.b // Now defined behaviour, this is just an i32 -> u32 transmute
++    ///     };
++    /// }
++    /// ```
++    #[clippy::version = "1.60.0"]
++    pub DEFAULT_UNION_REPRESENTATION,
++    restriction,
++    "unions without a `#[repr(C)]` attribute"
++}
++declare_lint_pass!(DefaultUnionRepresentation => [DEFAULT_UNION_REPRESENTATION]);
++
++impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
++    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
++        if is_union_with_two_non_zst_fields(cx, item) && !has_c_repr_attr(cx, item.hir_id()) {
++            span_lint_and_help(
++                cx,
++                DEFAULT_UNION_REPRESENTATION,
++                item.span,
++                "this union has the default representation",
++                None,
++                &format!(
++                    "consider annotating `{}` with `#[repr(C)]` to explicitly specify memory layout",
++                    cx.tcx.def_path_str(item.def_id.to_def_id())
++                ),
++            );
++        }
++    }
++}
++
++/// Returns true if the given item is a union with at least two non-ZST fields.
++fn is_union_with_two_non_zst_fields(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
++    if let ItemKind::Union(data, _) = &item.kind {
++        data.fields().iter().filter(|f| !is_zst(cx, f.ty)).count() >= 2
++    } else {
++        false
++    }
++}
++
++fn is_zst(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>) -> bool {
++    if hir_ty.span.from_expansion() {
++        return false;
++    }
++    let ty = hir_ty_to_ty(cx.tcx, hir_ty);
++    if let Ok(layout) = cx.layout_of(ty) {
++        layout.is_zst()
++    } else {
++        false
++    }
++}
++
++fn has_c_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
++    cx.tcx.hir().attrs(hir_id).iter().any(|attr| {
++        if attr.has_name(sym::repr) {
++            if let Some(items) = attr.meta_item_list() {
++                for item in items {
++                    if item.is_word() && matches!(item.name_or_empty(), sym::C) {
++                        return true;
++                    }
++                }
++            }
++        }
++        false
++    })
++}
diff --cc src/tools/clippy/clippy_lints/src/disallowed_methods.rs

index 73c00d97020bedf2a6badb9b698b89a59ce9b4de,0000000000000000000000000000000000000000..4c12202c84ab39da96a0c1a54e5b7cb78a43f19c

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/disallowed_methods.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/disallowed_methods.rs
@@@ -1,105 -1,0 +1,105 @@@
-             if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &segs) {
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::fn_def_id;
+ +
+ +use rustc_hir::{def::Res, def_id::DefIdMap, Expr};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_session::{declare_tool_lint, impl_lint_pass};
+ +
+ +use crate::utils::conf;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Denies the configured methods and functions in clippy.toml
+ +    ///
+ +    /// Note: Even though this lint is warn-by-default, it will only trigger if
+ +    /// methods are defined in the clippy.toml file.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Some methods are undesirable in certain contexts, and it's beneficial to
+ +    /// lint for them as needed.
+ +    ///
+ +    /// ### Example
+ +    /// An example clippy.toml configuration:
+ +    /// ```toml
+ +    /// # clippy.toml
+ +    /// disallowed-methods = [
+ +    ///     # Can use a string as the path of the disallowed method.
+ +    ///     "std::boxed::Box::new",
+ +    ///     # Can also use an inline table with a `path` key.
+ +    ///     { path = "std::time::Instant::now" },
+ +    ///     # When using an inline table, can add a `reason` for why the method
+ +    ///     # is disallowed.
+ +    ///     { path = "std::vec::Vec::leak", reason = "no leaking memory" },
+ +    /// ]
+ +    /// ```
+ +    ///
+ +    /// ```rust,ignore
+ +    /// // Example code where clippy issues a warning
+ +    /// let xs = vec![1, 2, 3, 4];
+ +    /// xs.leak(); // Vec::leak is disallowed in the config.
+ +    /// // The diagnostic contains the message "no leaking memory".
+ +    ///
+ +    /// let _now = Instant::now(); // Instant::now is disallowed in the config.
+ +    ///
+ +    /// let _box = Box::new(3); // Box::new is disallowed in the config.
+ +    /// ```
+ +    ///
+ +    /// Use instead:
+ +    /// ```rust,ignore
+ +    /// // Example code which does not raise clippy warning
+ +    /// let mut xs = Vec::new(); // Vec::new is _not_ disallowed in the config.
+ +    /// xs.push(123); // Vec::push is _not_ disallowed in the config.
+ +    /// ```
+ +    #[clippy::version = "1.49.0"]
+ +    pub DISALLOWED_METHODS,
+ +    style,
+ +    "use of a disallowed method call"
+ +}
+ +
+ +#[derive(Clone, Debug)]
+ +pub struct DisallowedMethods {
+ +    conf_disallowed: Vec<conf::DisallowedMethod>,
+ +    disallowed: DefIdMap<usize>,
+ +}
+ +
+ +impl DisallowedMethods {
+ +    pub fn new(conf_disallowed: Vec<conf::DisallowedMethod>) -> Self {
+ +        Self {
+ +            conf_disallowed,
+ +            disallowed: DefIdMap::default(),
+ +        }
+ +    }
+ +}
+ +
+ +impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
+ +    fn check_crate(&mut self, cx: &LateContext<'_>) {
+ +        for (index, conf) in self.conf_disallowed.iter().enumerate() {
+ +            let segs: Vec<_> = conf.path().split("::").collect();
++            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &segs) {
+ +                self.disallowed.insert(id, index);
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        let def_id = match fn_def_id(cx, expr) {
+ +            Some(def_id) => def_id,
+ +            None => return,
+ +        };
+ +        let conf = match self.disallowed.get(&def_id) {
+ +            Some(&index) => &self.conf_disallowed[index],
+ +            None => return,
+ +        };
+ +        let msg = format!("use of a disallowed method `{}`", conf.path());
+ +        span_lint_and_then(cx, DISALLOWED_METHODS, expr.span, &msg, |diag| {
+ +            if let conf::DisallowedMethod::WithReason {
+ +                reason: Some(reason), ..
+ +            } = conf
+ +            {
+ +                diag.note(&format!("{} (from clippy.toml)", reason));
+ +            }
+ +        });
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/disallowed_types.rs

index ea4b49b46fe9f6d6e5ca9e6f7e8ee6d3e8f4112b,0000000000000000000000000000000000000000..14f89edce615db9993d811d34e6e8d42d62f8b14

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/disallowed_types.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/disallowed_types.rs
@@@ -1,140 -1,0 +1,140 @@@
-             match clippy_utils::path_to_res(cx, &segs) {
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +
+ +use rustc_data_structures::fx::FxHashMap;
+ +use rustc_hir::{
+ +    def::Res, def_id::DefId, Item, ItemKind, PolyTraitRef, PrimTy, TraitBoundModifier, Ty, TyKind, UseKind,
+ +};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_session::{declare_tool_lint, impl_lint_pass};
+ +use rustc_span::Span;
+ +
+ +use crate::utils::conf;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Denies the configured types in clippy.toml.
+ +    ///
+ +    /// Note: Even though this lint is warn-by-default, it will only trigger if
+ +    /// types are defined in the clippy.toml file.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Some types are undesirable in certain contexts.
+ +    ///
+ +    /// ### Example:
+ +    /// An example clippy.toml configuration:
+ +    /// ```toml
+ +    /// # clippy.toml
+ +    /// disallowed-types = [
+ +    ///     # Can use a string as the path of the disallowed type.
+ +    ///     "std::collections::BTreeMap",
+ +    ///     # Can also use an inline table with a `path` key.
+ +    ///     { path = "std::net::TcpListener" },
+ +    ///     # When using an inline table, can add a `reason` for why the type
+ +    ///     # is disallowed.
+ +    ///     { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
+ +    /// ]
+ +    /// ```
+ +    ///
+ +    /// ```rust,ignore
+ +    /// use std::collections::BTreeMap;
+ +    /// // or its use
+ +    /// let x = std::collections::BTreeMap::new();
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust,ignore
+ +    /// // A similar type that is allowed by the config
+ +    /// use std::collections::HashMap;
+ +    /// ```
+ +    #[clippy::version = "1.55.0"]
+ +    pub DISALLOWED_TYPES,
+ +    style,
+ +    "use of disallowed types"
+ +}
+ +#[derive(Clone, Debug)]
+ +pub struct DisallowedTypes {
+ +    conf_disallowed: Vec<conf::DisallowedType>,
+ +    def_ids: FxHashMap<DefId, Option<String>>,
+ +    prim_tys: FxHashMap<PrimTy, Option<String>>,
+ +}
+ +
+ +impl DisallowedTypes {
+ +    pub fn new(conf_disallowed: Vec<conf::DisallowedType>) -> Self {
+ +        Self {
+ +            conf_disallowed,
+ +            def_ids: FxHashMap::default(),
+ +            prim_tys: FxHashMap::default(),
+ +        }
+ +    }
+ +
+ +    fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
+ +        match res {
+ +            Res::Def(_, did) => {
+ +                if let Some(reason) = self.def_ids.get(did) {
+ +                    emit(cx, &cx.tcx.def_path_str(*did), span, reason.as_deref());
+ +                }
+ +            },
+ +            Res::PrimTy(prim) => {
+ +                if let Some(reason) = self.prim_tys.get(prim) {
+ +                    emit(cx, prim.name_str(), span, reason.as_deref());
+ +                }
+ +            },
+ +            _ => {},
+ +        }
+ +    }
+ +}
+ +
+ +impl_lint_pass!(DisallowedTypes => [DISALLOWED_TYPES]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for DisallowedTypes {
+ +    fn check_crate(&mut self, cx: &LateContext<'_>) {
+ +        for conf in &self.conf_disallowed {
+ +            let (path, reason) = match conf {
+ +                conf::DisallowedType::Simple(path) => (path, None),
+ +                conf::DisallowedType::WithReason { path, reason } => (
+ +                    path,
+ +                    reason.as_ref().map(|reason| format!("{} (from clippy.toml)", reason)),
+ +                ),
+ +            };
+ +            let segs: Vec<_> = path.split("::").collect();
++            match clippy_utils::def_path_res(cx, &segs) {
+ +                Res::Def(_, id) => {
+ +                    self.def_ids.insert(id, reason);
+ +                },
+ +                Res::PrimTy(ty) => {
+ +                    self.prim_tys.insert(ty, reason);
+ +                },
+ +                _ => {},
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+ +        if let ItemKind::Use(path, UseKind::Single) = &item.kind {
+ +            self.check_res_emit(cx, &path.res, item.span);
+ +        }
+ +    }
+ +
+ +    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx>) {
+ +        if let TyKind::Path(path) = &ty.kind {
+ +            self.check_res_emit(cx, &cx.qpath_res(path, ty.hir_id), ty.span);
+ +        }
+ +    }
+ +
+ +    fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx PolyTraitRef<'tcx>, _: TraitBoundModifier) {
+ +        self.check_res_emit(cx, &poly.trait_ref.path.res, poly.trait_ref.path.span);
+ +    }
+ +}
+ +
+ +fn emit(cx: &LateContext<'_>, name: &str, span: Span, reason: Option<&str>) {
+ +    span_lint_and_then(
+ +        cx,
+ +        DISALLOWED_TYPES,
+ +        span,
+ +        &format!("`{}` is not allowed according to config", name),
+ +        |diag| {
+ +            if let Some(reason) = reason {
+ +                diag.note(reason);
+ +            }
+ +        },
+ +    );
+ +}
diff --cc src/tools/clippy/clippy_lints/src/explicit_write.rs

index f326fd83d18e70a16c17de0a8ca5681f5562ee58,0000000000000000000000000000000000000000..3e2217c28da3a0dee72c6d62b567fe6fb3014436

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/explicit_write.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/explicit_write.rs
@@@ -1,107 -1,0 +1,102 @@@
- use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
++use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::macros::FormatArgsExpn;
++use clippy_utils::source::snippet_with_applicability;
+ +use clippy_utils::{is_expn_of, match_function_call, paths};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{Expr, ExprKind};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::sym;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for usage of `write!()` / `writeln()!` which can be
+ +    /// replaced with `(e)print!()` / `(e)println!()`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Using `(e)println! is clearer and more concise
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # use std::io::Write;
+ +    /// # let bar = "furchtbar";
+ +    /// // this would be clearer as `eprintln!("foo: {:?}", bar);`
+ +    /// writeln!(&mut std::io::stderr(), "foo: {:?}", bar).unwrap();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub EXPLICIT_WRITE,
+ +    complexity,
+ +    "using the `write!()` family of functions instead of the `print!()` family of functions, when using the latter would work"
+ +}
+ +
+ +declare_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        if_chain! {
+ +            // match call to unwrap
+ +            if let ExprKind::MethodCall(unwrap_fun, [write_call], _) = expr.kind;
+ +            if unwrap_fun.ident.name == sym::unwrap;
+ +            // match call to write_fmt
+ +            if let ExprKind::MethodCall(write_fun, [write_recv, write_arg], _) = write_call.kind;
+ +            if write_fun.ident.name == sym!(write_fmt);
+ +            // match calls to std::io::stdout() / std::io::stderr ()
+ +            if let Some(dest_name) = if match_function_call(cx, write_recv, &paths::STDOUT).is_some() {
+ +                Some("stdout")
+ +            } else if match_function_call(cx, write_recv, &paths::STDERR).is_some() {
+ +                Some("stderr")
+ +            } else {
+ +                None
+ +            };
+ +            if let Some(format_args) = FormatArgsExpn::parse(cx, write_arg);
+ +            then {
+ +                let calling_macro =
+ +                    // ordering is important here, since `writeln!` uses `write!` internally
+ +                    if is_expn_of(write_call.span, "writeln").is_some() {
+ +                        Some("writeln")
+ +                    } else if is_expn_of(write_call.span, "write").is_some() {
+ +                        Some("write")
+ +                    } else {
+ +                        None
+ +                    };
+ +                let prefix = if dest_name == "stderr" {
+ +                    "e"
+ +                } else {
+ +                    ""
+ +                };
+ +
+ +                // We need to remove the last trailing newline from the string because the
+ +                // underlying `fmt::write` function doesn't know whether `println!` or `print!` was
+ +                // used.
+ +                let (used, sugg_mac) = if let Some(macro_name) = calling_macro {
+ +                    (
+ +                        format!("{}!({}(), ...)", macro_name, dest_name),
+ +                        macro_name.replace("write", "print"),
+ +                    )
+ +                } else {
+ +                    (
+ +                        format!("{}().write_fmt(...)", dest_name),
+ +                        "print".into(),
+ +                    )
+ +                };
-                 let msg = format!("use of `{}.unwrap()`", used);
-                 if let [write_output] = *format_args.format_string_parts {
-                     let mut write_output = write_output.to_string();
-                     if write_output.ends_with('\n') {
-                         write_output.pop();
-                     }
- 
-                     let sugg = format!("{}{}!(\"{}\")", prefix, sugg_mac, write_output.escape_default());
-                     span_lint_and_sugg(
-                         cx,
-                         EXPLICIT_WRITE,
-                         expr.span,
-                         &msg,
-                         "try this",
-                         sugg,
-                         Applicability::MachineApplicable
-                     );
-                 } else {
-                     // We don't have a proper suggestion
-                     let help = format!("consider using `{}{}!` instead", prefix, sugg_mac);
-                     span_lint_and_help(cx, EXPLICIT_WRITE, expr.span, &msg, None, &help);
-                 }
++                let mut applicability = Applicability::MachineApplicable;
++                let inputs_snippet = snippet_with_applicability(
++                    cx,
++                    format_args.inputs_span(),
++                    "..",
++                    &mut applicability,
++                );
++                span_lint_and_sugg(
++                    cx,
++                    EXPLICIT_WRITE,
++                    expr.span,
++                    &format!("use of `{}.unwrap()`", used),
++                    "try this",
++                    format!("{}{}!({})", prefix, sugg_mac, inputs_snippet),
++                    applicability,
++                )
+ +            }
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/formatting.rs

index ae18f8081bcc870d2b90f8a6e0f27a16f68176c5,0000000000000000000000000000000000000000..57964b8d48ea9c4904282e191e097b044b140534

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/formatting.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/formatting.rs
@@@ -1,337 -1,0 +1,335 @@@
- use clippy_utils::differing_macro_contexts;
+ +use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_note};
-         if !differing_macro_contexts(lhs.span, rhs.span) && !lhs.span.from_expansion() {
+ +use clippy_utils::source::snippet_opt;
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::{BinOpKind, Block, Expr, ExprKind, StmtKind, UnOp};
+ +use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+ +use rustc_middle::lint::in_external_macro;
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::source_map::Span;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for use of the non-existent `=*`, `=!` and `=-`
+ +    /// operators.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is either a typo of `*=`, `!=` or `-=` or
+ +    /// confusing.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// a =- 42; // confusing, should it be `a -= 42` or `a = -42`?
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub SUSPICIOUS_ASSIGNMENT_FORMATTING,
+ +    suspicious,
+ +    "suspicious formatting of `*=`, `-=` or `!=`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks the formatting of a unary operator on the right hand side
+ +    /// of a binary operator. It lints if there is no space between the binary and unary operators,
+ +    /// but there is a space between the unary and its operand.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is either a typo in the binary operator or confusing.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// if foo <- 30 { // this should be `foo < -30` but looks like a different operator
+ +    /// }
+ +    ///
+ +    /// if foo &&! bar { // this should be `foo && !bar` but looks like a different operator
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "1.40.0"]
+ +    pub SUSPICIOUS_UNARY_OP_FORMATTING,
+ +    suspicious,
+ +    "suspicious formatting of unary `-` or `!` on the RHS of a BinOp"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for formatting of `else`. It lints if the `else`
+ +    /// is followed immediately by a newline or the `else` seems to be missing.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is probably some refactoring remnant, even if the
+ +    /// code is correct, it might look confusing.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// if foo {
+ +    /// } { // looks like an `else` is missing here
+ +    /// }
+ +    ///
+ +    /// if foo {
+ +    /// } if bar { // looks like an `else` is missing here
+ +    /// }
+ +    ///
+ +    /// if foo {
+ +    /// } else
+ +    ///
+ +    /// { // this is the `else` block of the previous `if`, but should it be?
+ +    /// }
+ +    ///
+ +    /// if foo {
+ +    /// } else
+ +    ///
+ +    /// if bar { // this is the `else` block of the previous `if`, but should it be?
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub SUSPICIOUS_ELSE_FORMATTING,
+ +    suspicious,
+ +    "suspicious formatting of `else`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for possible missing comma in an array. It lints if
+ +    /// an array element is a binary operator expression and it lies on two lines.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This could lead to unexpected results.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// let a = &[
+ +    ///     -1, -2, -3 // <= no comma here
+ +    ///     -4, -5, -6
+ +    /// ];
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub POSSIBLE_MISSING_COMMA,
+ +    correctness,
+ +    "possible missing comma in array"
+ +}
+ +
+ +declare_lint_pass!(Formatting => [
+ +    SUSPICIOUS_ASSIGNMENT_FORMATTING,
+ +    SUSPICIOUS_UNARY_OP_FORMATTING,
+ +    SUSPICIOUS_ELSE_FORMATTING,
+ +    POSSIBLE_MISSING_COMMA
+ +]);
+ +
+ +impl EarlyLintPass for Formatting {
+ +    fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
+ +        for w in block.stmts.windows(2) {
+ +            if let (StmtKind::Expr(first), StmtKind::Expr(second) | StmtKind::Semi(second)) = (&w[0].kind, &w[1].kind) {
+ +                check_missing_else(cx, first, second);
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+ +        check_assign(cx, expr);
+ +        check_unop(cx, expr);
+ +        check_else(cx, expr);
+ +        check_array(cx, expr);
+ +    }
+ +}
+ +
+ +/// Implementation of the `SUSPICIOUS_ASSIGNMENT_FORMATTING` lint.
+ +fn check_assign(cx: &EarlyContext<'_>, expr: &Expr) {
+ +    if let ExprKind::Assign(ref lhs, ref rhs, _) = expr.kind {
-         if !differing_macro_contexts(lhs.span, rhs.span) && !lhs.span.from_expansion();
++        if !lhs.span.from_expansion() && !rhs.span.from_expansion() {
+ +            let eq_span = lhs.span.between(rhs.span);
+ +            if let ExprKind::Unary(op, ref sub_rhs) = rhs.kind {
+ +                if let Some(eq_snippet) = snippet_opt(cx, eq_span) {
+ +                    let op = UnOp::to_string(op);
+ +                    let eqop_span = lhs.span.between(sub_rhs.span);
+ +                    if eq_snippet.ends_with('=') {
+ +                        span_lint_and_note(
+ +                            cx,
+ +                            SUSPICIOUS_ASSIGNMENT_FORMATTING,
+ +                            eqop_span,
+ +                            &format!(
+ +                                "this looks like you are trying to use `.. {op}= ..`, but you \
+ +                                 really are doing `.. = ({op} ..)`",
+ +                                op = op
+ +                            ),
+ +                            None,
+ +                            &format!("to remove this lint, use either `{op}=` or `= {op}`", op = op),
+ +                        );
+ +                    }
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +/// Implementation of the `SUSPICIOUS_UNARY_OP_FORMATTING` lint.
+ +fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) {
+ +    if_chain! {
+ +        if let ExprKind::Binary(ref binop, ref lhs, ref rhs) = expr.kind;
-         if !differing_macro_contexts(then.span, else_.span);
-         if !then.span.from_expansion() && !in_external_macro(cx.sess(), expr.span);
++        if !lhs.span.from_expansion() && !rhs.span.from_expansion();
+ +        // span between BinOp LHS and RHS
+ +        let binop_span = lhs.span.between(rhs.span);
+ +        // if RHS is an UnOp
+ +        if let ExprKind::Unary(op, ref un_rhs) = rhs.kind;
+ +        // from UnOp operator to UnOp operand
+ +        let unop_operand_span = rhs.span.until(un_rhs.span);
+ +        if let Some(binop_snippet) = snippet_opt(cx, binop_span);
+ +        if let Some(unop_operand_snippet) = snippet_opt(cx, unop_operand_span);
+ +        let binop_str = BinOpKind::to_string(&binop.node);
+ +        // no space after BinOp operator and space after UnOp operator
+ +        if binop_snippet.ends_with(binop_str) && unop_operand_snippet.ends_with(' ');
+ +        then {
+ +            let unop_str = UnOp::to_string(op);
+ +            let eqop_span = lhs.span.between(un_rhs.span);
+ +            span_lint_and_help(
+ +                cx,
+ +                SUSPICIOUS_UNARY_OP_FORMATTING,
+ +                eqop_span,
+ +                &format!(
+ +                    "by not having a space between `{binop}` and `{unop}` it looks like \
+ +                     `{binop}{unop}` is a single operator",
+ +                    binop = binop_str,
+ +                    unop = unop_str
+ +                ),
+ +                None,
+ +                &format!(
+ +                    "put a space between `{binop}` and `{unop}` and remove the space after `{unop}`",
+ +                    binop = binop_str,
+ +                    unop = unop_str
+ +                ),
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +/// Implementation of the `SUSPICIOUS_ELSE_FORMATTING` lint for weird `else`.
+ +fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
+ +    if_chain! {
+ +        if let ExprKind::If(_, then, Some(else_)) = &expr.kind;
+ +        if is_block(else_) || is_if(else_);
-                 if has_unary_equivalent(op.node) && !differing_macro_contexts(lhs.span, op.span);
++        if !then.span.from_expansion() && !else_.span.from_expansion();
++        if !in_external_macro(cx.sess(), expr.span);
+ +
+ +        // workaround for rust-lang/rust#43081
+ +        if expr.span.lo().0 != 0 && expr.span.hi().0 != 0;
+ +
+ +        // this will be a span from the closing ‘}’ of the “then” block (excluding) to
+ +        // the “if” of the “else if” block (excluding)
+ +        let else_span = then.span.between(else_.span);
+ +
+ +        // the snippet should look like " else \n    " with maybe comments anywhere
+ +        // it’s bad when there is a ‘\n’ after the “else”
+ +        if let Some(else_snippet) = snippet_opt(cx, else_span);
+ +        if let Some((pre_else, post_else)) = else_snippet.split_once("else");
+ +        if let Some((_, post_else_post_eol)) = post_else.split_once('\n');
+ +
+ +        then {
+ +            // Allow allman style braces `} \n else \n {`
+ +            if_chain! {
+ +                if is_block(else_);
+ +                if let Some((_, pre_else_post_eol)) = pre_else.split_once('\n');
+ +                // Exactly one eol before and after the else
+ +                if !pre_else_post_eol.contains('\n');
+ +                if !post_else_post_eol.contains('\n');
+ +                then {
+ +                    return;
+ +                }
+ +            }
+ +
+ +            let else_desc = if is_if(else_) { "if" } else { "{..}" };
+ +            span_lint_and_note(
+ +                cx,
+ +                SUSPICIOUS_ELSE_FORMATTING,
+ +                else_span,
+ +                &format!("this is an `else {}` but the formatting might hide it", else_desc),
+ +                None,
+ +                &format!(
+ +                    "to remove this lint, remove the `else` or remove the new line between \
+ +                     `else` and `{}`",
+ +                    else_desc,
+ +                ),
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +#[must_use]
+ +fn has_unary_equivalent(bin_op: BinOpKind) -> bool {
+ +    // &, *, -
+ +    bin_op == BinOpKind::And || bin_op == BinOpKind::Mul || bin_op == BinOpKind::Sub
+ +}
+ +
+ +fn indentation(cx: &EarlyContext<'_>, span: Span) -> usize {
+ +    cx.sess().source_map().lookup_char_pos(span.lo()).col.0
+ +}
+ +
+ +/// Implementation of the `POSSIBLE_MISSING_COMMA` lint for array
+ +fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
+ +    if let ExprKind::Array(ref array) = expr.kind {
+ +        for element in array {
+ +            if_chain! {
+ +                if let ExprKind::Binary(ref op, ref lhs, _) = element.kind;
-         if !differing_macro_contexts(first.span, second.span);
-         if !first.span.from_expansion();
++                if has_unary_equivalent(op.node) && lhs.span.ctxt() == op.span.ctxt();
+ +                let space_span = lhs.span.between(op.span);
+ +                if let Some(space_snippet) = snippet_opt(cx, space_span);
+ +                let lint_span = lhs.span.with_lo(lhs.span.hi());
+ +                if space_snippet.contains('\n');
+ +                if indentation(cx, op.span) <= indentation(cx, lhs.span);
+ +                then {
+ +                    span_lint_and_note(
+ +                        cx,
+ +                        POSSIBLE_MISSING_COMMA,
+ +                        lint_span,
+ +                        "possibly missing a comma here",
+ +                        None,
+ +                        "to remove this lint, add a comma or write the expr in a single line",
+ +                    );
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
+ +    if_chain! {
++        if !first.span.from_expansion() && !second.span.from_expansion();
+ +        if let ExprKind::If(cond_expr, ..) = &first.kind;
+ +        if is_block(second) || is_if(second);
+ +
+ +        // Proc-macros can give weird spans. Make sure this is actually an `if`.
+ +        if let Some(if_snip) = snippet_opt(cx, first.span.until(cond_expr.span));
+ +        if if_snip.starts_with("if");
+ +
+ +        // If there is a line break between the two expressions, don't lint.
+ +        // If there is a non-whitespace character, this span came from a proc-macro.
+ +        let else_span = first.span.between(second.span);
+ +        if let Some(else_snippet) = snippet_opt(cx, else_span);
+ +        if !else_snippet.chars().any(|c| c == '\n' || !c.is_whitespace());
+ +        then {
+ +            let (looks_like, next_thing) = if is_if(second) {
+ +                ("an `else if`", "the second `if`")
+ +            } else {
+ +                ("an `else {..}`", "the next block")
+ +            };
+ +
+ +            span_lint_and_note(
+ +                cx,
+ +                SUSPICIOUS_ELSE_FORMATTING,
+ +                else_span,
+ +                &format!("this looks like {} but the `else` is missing", looks_like),
+ +                None,
+ +                &format!(
+ +                    "to remove this lint, add the missing `else` or add a new line before {}",
+ +                    next_thing,
+ +                ),
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +fn is_block(expr: &Expr) -> bool {
+ +    matches!(expr.kind, ExprKind::Block(..))
+ +}
+ +
+ +/// Check if the expression is an `if` or `if let`
+ +fn is_if(expr: &Expr) -> bool {
+ +    matches!(expr.kind, ExprKind::If(..))
+ +}
diff --cc src/tools/clippy/clippy_lints/src/implicit_hasher.rs

index a2f943b03ef42c4f3f2e7518148e68d0ad615bec,0000000000000000000000000000000000000000..5e4cde553b52e954a0bf7e30f2eed0ef0531e21c

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs
@@@ -1,389 -1,0 +1,388 @@@
- use clippy_utils::differing_macro_contexts;
+ +use std::borrow::Cow;
+ +use std::collections::BTreeMap;
+ +
+ +use rustc_errors::DiagnosticBuilder;
+ +use rustc_hir as hir;
+ +use rustc_hir::intravisit::{walk_body, walk_expr, walk_inf, walk_ty, Visitor};
+ +use rustc_hir::{Body, Expr, ExprKind, GenericArg, Item, ItemKind, QPath, TyKind};
+ +use rustc_lint::{LateContext, LateLintPass, LintContext};
+ +use rustc_middle::hir::nested_filter;
+ +use rustc_middle::lint::in_external_macro;
+ +use rustc_middle::ty::{Ty, TypeckResults};
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::source_map::Span;
+ +use rustc_span::symbol::sym;
+ +use rustc_typeck::hir_ty_to_ty;
+ +
+ +use if_chain::if_chain;
+ +
+ +use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
-                     if differing_macro_contexts(item.span, target.span()) {
+ +use clippy_utils::source::{snippet, snippet_opt};
+ +use clippy_utils::ty::is_type_diagnostic_item;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for public `impl` or `fn` missing generalization
+ +    /// over different hashers and implicitly defaulting to the default hashing
+ +    /// algorithm (`SipHash`).
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `HashMap` or `HashSet` with custom hashers cannot be
+ +    /// used with them.
+ +    ///
+ +    /// ### Known problems
+ +    /// Suggestions for replacing constructors can contain
+ +    /// false-positives. Also applying suggestions can require modification of other
+ +    /// pieces of code, possibly including external crates.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # use std::collections::HashMap;
+ +    /// # use std::hash::{Hash, BuildHasher};
+ +    /// # trait Serialize {};
+ +    /// impl<K: Hash + Eq, V> Serialize for HashMap<K, V> { }
+ +    ///
+ +    /// pub fn foo(map: &mut HashMap<i32, i32>) { }
+ +    /// ```
+ +    /// could be rewritten as
+ +    /// ```rust
+ +    /// # use std::collections::HashMap;
+ +    /// # use std::hash::{Hash, BuildHasher};
+ +    /// # trait Serialize {};
+ +    /// impl<K: Hash + Eq, V, S: BuildHasher> Serialize for HashMap<K, V, S> { }
+ +    ///
+ +    /// pub fn foo<S: BuildHasher>(map: &mut HashMap<i32, i32, S>) { }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub IMPLICIT_HASHER,
+ +    pedantic,
+ +    "missing generalization over different hashers"
+ +}
+ +
+ +declare_lint_pass!(ImplicitHasher => [IMPLICIT_HASHER]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
+ +    #[allow(clippy::cast_possible_truncation, clippy::too_many_lines)]
+ +    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+ +        use rustc_span::BytePos;
+ +
+ +        fn suggestion<'tcx>(
+ +            cx: &LateContext<'tcx>,
+ +            diag: &mut DiagnosticBuilder<'_>,
+ +            generics_span: Span,
+ +            generics_suggestion_span: Span,
+ +            target: &ImplicitHasherType<'_>,
+ +            vis: ImplicitHasherConstructorVisitor<'_, '_, '_>,
+ +        ) {
+ +            let generics_snip = snippet(cx, generics_span, "");
+ +            // trim `<` `>`
+ +            let generics_snip = if generics_snip.is_empty() {
+ +                ""
+ +            } else {
+ +                &generics_snip[1..generics_snip.len() - 1]
+ +            };
+ +
+ +            multispan_sugg(
+ +                diag,
+ +                "consider adding a type parameter",
+ +                vec![
+ +                    (
+ +                        generics_suggestion_span,
+ +                        format!(
+ +                            "<{}{}S: ::std::hash::BuildHasher{}>",
+ +                            generics_snip,
+ +                            if generics_snip.is_empty() { "" } else { ", " },
+ +                            if vis.suggestions.is_empty() {
+ +                                ""
+ +                            } else {
+ +                                // request users to add `Default` bound so that generic constructors can be used
+ +                                " + Default"
+ +                            },
+ +                        ),
+ +                    ),
+ +                    (
+ +                        target.span(),
+ +                        format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
+ +                    ),
+ +                ],
+ +            );
+ +
+ +            if !vis.suggestions.is_empty() {
+ +                multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
+ +            }
+ +        }
+ +
+ +        if !cx.access_levels.is_exported(item.def_id) {
+ +            return;
+ +        }
+ +
+ +        match item.kind {
+ +            ItemKind::Impl(ref impl_) => {
+ +                let mut vis = ImplicitHasherTypeVisitor::new(cx);
+ +                vis.visit_ty(impl_.self_ty);
+ +
+ +                for target in &vis.found {
++                    if item.span.ctxt() != target.span().ctxt() {
+ +                        return;
+ +                    }
+ +
+ +                    let generics_suggestion_span = impl_.generics.span.substitute_dummy({
+ +                        let pos = snippet_opt(cx, item.span.until(target.span()))
+ +                            .and_then(|snip| Some(item.span.lo() + BytePos(snip.find("impl")? as u32 + 4)));
+ +                        if let Some(pos) = pos {
+ +                            Span::new(pos, pos, item.span.ctxt(), item.span.parent())
+ +                        } else {
+ +                            return;
+ +                        }
+ +                    });
+ +
+ +                    let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
+ +                    for item in impl_.items.iter().map(|item| cx.tcx.hir().impl_item(item.id)) {
+ +                        ctr_vis.visit_impl_item(item);
+ +                    }
+ +
+ +                    span_lint_and_then(
+ +                        cx,
+ +                        IMPLICIT_HASHER,
+ +                        target.span(),
+ +                        &format!(
+ +                            "impl for `{}` should be generalized over different hashers",
+ +                            target.type_name()
+ +                        ),
+ +                        move |diag| {
+ +                            suggestion(cx, diag, impl_.generics.span, generics_suggestion_span, target, ctr_vis);
+ +                        },
+ +                    );
+ +                }
+ +            },
+ +            ItemKind::Fn(ref sig, ref generics, body_id) => {
+ +                let body = cx.tcx.hir().body(body_id);
+ +
+ +                for ty in sig.decl.inputs {
+ +                    let mut vis = ImplicitHasherTypeVisitor::new(cx);
+ +                    vis.visit_ty(ty);
+ +
+ +                    for target in &vis.found {
+ +                        if in_external_macro(cx.sess(), generics.span) {
+ +                            continue;
+ +                        }
+ +                        let generics_suggestion_span = generics.span.substitute_dummy({
+ +                            let pos = snippet_opt(
+ +                                cx,
+ +                                Span::new(
+ +                                    item.span.lo(),
+ +                                    body.params[0].pat.span.lo(),
+ +                                    item.span.ctxt(),
+ +                                    item.span.parent(),
+ +                                ),
+ +                            )
+ +                            .and_then(|snip| {
+ +                                let i = snip.find("fn")?;
+ +                                Some(item.span.lo() + BytePos((i + snip[i..].find('(')?) as u32))
+ +                            })
+ +                            .expect("failed to create span for type parameters");
+ +                            Span::new(pos, pos, item.span.ctxt(), item.span.parent())
+ +                        });
+ +
+ +                        let mut ctr_vis = ImplicitHasherConstructorVisitor::new(cx, target);
+ +                        ctr_vis.visit_body(body);
+ +
+ +                        span_lint_and_then(
+ +                            cx,
+ +                            IMPLICIT_HASHER,
+ +                            target.span(),
+ +                            &format!(
+ +                                "parameter of type `{}` should be generalized over different hashers",
+ +                                target.type_name()
+ +                            ),
+ +                            move |diag| {
+ +                                suggestion(cx, diag, generics.span, generics_suggestion_span, target, ctr_vis);
+ +                            },
+ +                        );
+ +                    }
+ +                }
+ +            },
+ +            _ => {},
+ +        }
+ +    }
+ +}
+ +
+ +enum ImplicitHasherType<'tcx> {
+ +    HashMap(Span, Ty<'tcx>, Cow<'static, str>, Cow<'static, str>),
+ +    HashSet(Span, Ty<'tcx>, Cow<'static, str>),
+ +}
+ +
+ +impl<'tcx> ImplicitHasherType<'tcx> {
+ +    /// Checks that `ty` is a target type without a `BuildHasher`.
+ +    fn new(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'_>) -> Option<Self> {
+ +        if let TyKind::Path(QPath::Resolved(None, path)) = hir_ty.kind {
+ +            let params: Vec<_> = path
+ +                .segments
+ +                .last()
+ +                .as_ref()?
+ +                .args
+ +                .as_ref()?
+ +                .args
+ +                .iter()
+ +                .filter_map(|arg| match arg {
+ +                    GenericArg::Type(ty) => Some(ty),
+ +                    _ => None,
+ +                })
+ +                .collect();
+ +            let params_len = params.len();
+ +
+ +            let ty = hir_ty_to_ty(cx.tcx, hir_ty);
+ +
+ +            if is_type_diagnostic_item(cx, ty, sym::HashMap) && params_len == 2 {
+ +                Some(ImplicitHasherType::HashMap(
+ +                    hir_ty.span,
+ +                    ty,
+ +                    snippet(cx, params[0].span, "K"),
+ +                    snippet(cx, params[1].span, "V"),
+ +                ))
+ +            } else if is_type_diagnostic_item(cx, ty, sym::HashSet) && params_len == 1 {
+ +                Some(ImplicitHasherType::HashSet(
+ +                    hir_ty.span,
+ +                    ty,
+ +                    snippet(cx, params[0].span, "T"),
+ +                ))
+ +            } else {
+ +                None
+ +            }
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +
+ +    fn type_name(&self) -> &'static str {
+ +        match *self {
+ +            ImplicitHasherType::HashMap(..) => "HashMap",
+ +            ImplicitHasherType::HashSet(..) => "HashSet",
+ +        }
+ +    }
+ +
+ +    fn type_arguments(&self) -> String {
+ +        match *self {
+ +            ImplicitHasherType::HashMap(.., ref k, ref v) => format!("{}, {}", k, v),
+ +            ImplicitHasherType::HashSet(.., ref t) => format!("{}", t),
+ +        }
+ +    }
+ +
+ +    fn ty(&self) -> Ty<'tcx> {
+ +        match *self {
+ +            ImplicitHasherType::HashMap(_, ty, ..) | ImplicitHasherType::HashSet(_, ty, ..) => ty,
+ +        }
+ +    }
+ +
+ +    fn span(&self) -> Span {
+ +        match *self {
+ +            ImplicitHasherType::HashMap(span, ..) | ImplicitHasherType::HashSet(span, ..) => span,
+ +        }
+ +    }
+ +}
+ +
+ +struct ImplicitHasherTypeVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,
+ +    found: Vec<ImplicitHasherType<'tcx>>,
+ +}
+ +
+ +impl<'a, 'tcx> ImplicitHasherTypeVisitor<'a, 'tcx> {
+ +    fn new(cx: &'a LateContext<'tcx>) -> Self {
+ +        Self { cx, found: vec![] }
+ +    }
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'a, 'tcx> {
+ +    fn visit_ty(&mut self, t: &'tcx hir::Ty<'_>) {
+ +        if let Some(target) = ImplicitHasherType::new(self.cx, t) {
+ +            self.found.push(target);
+ +        }
+ +
+ +        walk_ty(self, t);
+ +    }
+ +
+ +    fn visit_infer(&mut self, inf: &'tcx hir::InferArg) {
+ +        if let Some(target) = ImplicitHasherType::new(self.cx, &inf.to_ty()) {
+ +            self.found.push(target);
+ +        }
+ +
+ +        walk_inf(self, inf);
+ +    }
+ +}
+ +
+ +/// Looks for default-hasher-dependent constructors like `HashMap::new`.
+ +struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,
+ +    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
+ +    target: &'b ImplicitHasherType<'tcx>,
+ +    suggestions: BTreeMap<Span, String>,
+ +}
+ +
+ +impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+ +    fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self {
+ +        Self {
+ +            cx,
+ +            maybe_typeck_results: cx.maybe_typeck_results(),
+ +            target,
+ +            suggestions: BTreeMap::new(),
+ +        }
+ +    }
+ +}
+ +
+ +impl<'a, 'b, 'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
+ +    type NestedFilter = nested_filter::OnlyBodies;
+ +
+ +    fn visit_body(&mut self, body: &'tcx Body<'_>) {
+ +        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body.id()));
+ +        walk_body(self, body);
+ +        self.maybe_typeck_results = old_maybe_typeck_results;
+ +    }
+ +
+ +    fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+ +        if_chain! {
+ +            if let ExprKind::Call(fun, args) = e.kind;
+ +            if let ExprKind::Path(QPath::TypeRelative(ty, method)) = fun.kind;
+ +            if let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind;
+ +            if let Some(ty_did) = ty_path.res.opt_def_id();
+ +            then {
+ +                if self.target.ty() != self.maybe_typeck_results.unwrap().expr_ty(e) {
+ +                    return;
+ +                }
+ +
+ +                if self.cx.tcx.is_diagnostic_item(sym::HashMap, ty_did) {
+ +                    if method.ident.name == sym::new {
+ +                        self.suggestions
+ +                            .insert(e.span, "HashMap::default()".to_string());
+ +                    } else if method.ident.name == sym!(with_capacity) {
+ +                        self.suggestions.insert(
+ +                            e.span,
+ +                            format!(
+ +                                "HashMap::with_capacity_and_hasher({}, Default::default())",
+ +                                snippet(self.cx, args[0].span, "capacity"),
+ +                            ),
+ +                        );
+ +                    }
+ +                } else if self.cx.tcx.is_diagnostic_item(sym::HashSet, ty_did) {
+ +                    if method.ident.name == sym::new {
+ +                        self.suggestions
+ +                            .insert(e.span, "HashSet::default()".to_string());
+ +                    } else if method.ident.name == sym!(with_capacity) {
+ +                        self.suggestions.insert(
+ +                            e.span,
+ +                            format!(
+ +                                "HashSet::with_capacity_and_hasher({}, Default::default())",
+ +                                snippet(self.cx, args[0].span, "capacity"),
+ +                            ),
+ +                        );
+ +                    }
+ +                }
+ +            }
+ +        }
+ +
+ +        walk_expr(self, e);
+ +    }
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/infinite_iter.rs

index 3008e86ef8b296da25d2a4e5adc78c614ceed059,0000000000000000000000000000000000000000..b6badef02f58a989e4fa23332fded3c3d3fa7a99

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/infinite_iter.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/infinite_iter.rs
@@@ -1,260 -1,0 +1,256 @@@
- use clippy_utils::{get_trait_def_id, higher, is_qpath_def_path, paths};
+ +use clippy_utils::diagnostics::span_lint;
+ +use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
-         ExprKind::Call(path, _) => {
-             if let ExprKind::Path(ref qpath) = path.kind {
-                 is_qpath_def_path(cx, qpath, path.hir_id, &paths::ITER_REPEAT).into()
-             } else {
-                 Finite
-             }
-         },
++use clippy_utils::{get_trait_def_id, higher, match_def_path, path_def_id, paths};
+ +use rustc_hir::{BorrowKind, Expr, ExprKind};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::symbol::{sym, Symbol};
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for iteration that is guaranteed to be infinite.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// While there may be places where this is acceptable
+ +    /// (e.g., in event streams), in most cases this is simply an error.
+ +    ///
+ +    /// ### Example
+ +    /// ```no_run
+ +    /// use std::iter;
+ +    ///
+ +    /// iter::repeat(1_u8).collect::<Vec<_>>();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub INFINITE_ITER,
+ +    correctness,
+ +    "infinite iteration"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for iteration that may be infinite.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// While there may be places where this is acceptable
+ +    /// (e.g., in event streams), in most cases this is simply an error.
+ +    ///
+ +    /// ### Known problems
+ +    /// The code may have a condition to stop iteration, but
+ +    /// this lint is not clever enough to analyze it.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let infinite_iter = 0..;
+ +    /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub MAYBE_INFINITE_ITER,
+ +    pedantic,
+ +    "possible infinite iteration"
+ +}
+ +
+ +declare_lint_pass!(InfiniteIter => [INFINITE_ITER, MAYBE_INFINITE_ITER]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for InfiniteIter {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        let (lint, msg) = match complete_infinite_iter(cx, expr) {
+ +            Infinite => (INFINITE_ITER, "infinite iteration detected"),
+ +            MaybeInfinite => (MAYBE_INFINITE_ITER, "possible infinite iteration detected"),
+ +            Finite => {
+ +                return;
+ +            },
+ +        };
+ +        span_lint(cx, lint, expr.span, msg);
+ +    }
+ +}
+ +
+ +#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+ +enum Finiteness {
+ +    Infinite,
+ +    MaybeInfinite,
+ +    Finite,
+ +}
+ +
+ +use self::Finiteness::{Finite, Infinite, MaybeInfinite};
+ +
+ +impl Finiteness {
+ +    #[must_use]
+ +    fn and(self, b: Self) -> Self {
+ +        match (self, b) {
+ +            (Finite, _) | (_, Finite) => Finite,
+ +            (MaybeInfinite, _) | (_, MaybeInfinite) => MaybeInfinite,
+ +            _ => Infinite,
+ +        }
+ +    }
+ +
+ +    #[must_use]
+ +    fn or(self, b: Self) -> Self {
+ +        match (self, b) {
+ +            (Infinite, _) | (_, Infinite) => Infinite,
+ +            (MaybeInfinite, _) | (_, MaybeInfinite) => MaybeInfinite,
+ +            _ => Finite,
+ +        }
+ +    }
+ +}
+ +
+ +impl From<bool> for Finiteness {
+ +    #[must_use]
+ +    fn from(b: bool) -> Self {
+ +        if b { Infinite } else { Finite }
+ +    }
+ +}
+ +
+ +/// This tells us what to look for to know if the iterator returned by
+ +/// this method is infinite
+ +#[derive(Copy, Clone)]
+ +enum Heuristic {
+ +    /// infinite no matter what
+ +    Always,
+ +    /// infinite if the first argument is
+ +    First,
+ +    /// infinite if any of the supplied arguments is
+ +    Any,
+ +    /// infinite if all of the supplied arguments are
+ +    All,
+ +}
+ +
+ +use self::Heuristic::{All, Always, Any, First};
+ +
+ +/// a slice of (method name, number of args, heuristic, bounds) tuples
+ +/// that will be used to determine whether the method in question
+ +/// returns an infinite or possibly infinite iterator. The finiteness
+ +/// is an upper bound, e.g., some methods can return a possibly
+ +/// infinite iterator at worst, e.g., `take_while`.
+ +const HEURISTICS: [(&str, usize, Heuristic, Finiteness); 19] = [
+ +    ("zip", 2, All, Infinite),
+ +    ("chain", 2, Any, Infinite),
+ +    ("cycle", 1, Always, Infinite),
+ +    ("map", 2, First, Infinite),
+ +    ("by_ref", 1, First, Infinite),
+ +    ("cloned", 1, First, Infinite),
+ +    ("rev", 1, First, Infinite),
+ +    ("inspect", 1, First, Infinite),
+ +    ("enumerate", 1, First, Infinite),
+ +    ("peekable", 2, First, Infinite),
+ +    ("fuse", 1, First, Infinite),
+ +    ("skip", 2, First, Infinite),
+ +    ("skip_while", 1, First, Infinite),
+ +    ("filter", 2, First, Infinite),
+ +    ("filter_map", 2, First, Infinite),
+ +    ("flat_map", 2, First, Infinite),
+ +    ("unzip", 1, First, Infinite),
+ +    ("take_while", 2, First, MaybeInfinite),
+ +    ("scan", 3, First, MaybeInfinite),
+ +];
+ +
+ +fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
+ +    match expr.kind {
+ +        ExprKind::MethodCall(method, args, _) => {
+ +            for &(name, len, heuristic, cap) in &HEURISTICS {
+ +                if method.ident.name.as_str() == name && args.len() == len {
+ +                    return (match heuristic {
+ +                        Always => Infinite,
+ +                        First => is_infinite(cx, &args[0]),
+ +                        Any => is_infinite(cx, &args[0]).or(is_infinite(cx, &args[1])),
+ +                        All => is_infinite(cx, &args[0]).and(is_infinite(cx, &args[1])),
+ +                    })
+ +                    .and(cap);
+ +                }
+ +            }
+ +            if method.ident.name == sym!(flat_map) && args.len() == 2 {
+ +                if let ExprKind::Closure(_, _, body_id, _, _) = args[1].kind {
+ +                    let body = cx.tcx.hir().body(body_id);
+ +                    return is_infinite(cx, &body.value);
+ +                }
+ +            }
+ +            Finite
+ +        },
+ +        ExprKind::Block(block, _) => block.expr.as_ref().map_or(Finite, |e| is_infinite(cx, e)),
+ +        ExprKind::Box(e) | ExprKind::AddrOf(BorrowKind::Ref, _, e) => is_infinite(cx, e),
++        ExprKind::Call(path, _) => path_def_id(cx, path)
++            .map_or(false, |id| match_def_path(cx, id, &paths::ITER_REPEAT))
++            .into(),
+ +        ExprKind::Struct(..) => higher::Range::hir(expr).map_or(false, |r| r.end.is_none()).into(),
+ +        _ => Finite,
+ +    }
+ +}
+ +
+ +/// the names and argument lengths of methods that *may* exhaust their
+ +/// iterators
+ +const POSSIBLY_COMPLETING_METHODS: [(&str, usize); 6] = [
+ +    ("find", 2),
+ +    ("rfind", 2),
+ +    ("position", 2),
+ +    ("rposition", 2),
+ +    ("any", 2),
+ +    ("all", 2),
+ +];
+ +
+ +/// the names and argument lengths of methods that *always* exhaust
+ +/// their iterators
+ +const COMPLETING_METHODS: [(&str, usize); 12] = [
+ +    ("count", 1),
+ +    ("fold", 3),
+ +    ("for_each", 2),
+ +    ("partition", 2),
+ +    ("max", 1),
+ +    ("max_by", 2),
+ +    ("max_by_key", 2),
+ +    ("min", 1),
+ +    ("min_by", 2),
+ +    ("min_by_key", 2),
+ +    ("sum", 1),
+ +    ("product", 1),
+ +];
+ +
+ +/// the paths of types that are known to be infinitely allocating
+ +const INFINITE_COLLECTORS: &[Symbol] = &[
+ +    sym::BinaryHeap,
+ +    sym::BTreeMap,
+ +    sym::BTreeSet,
+ +    sym::HashMap,
+ +    sym::HashSet,
+ +    sym::LinkedList,
+ +    sym::Vec,
+ +    sym::VecDeque,
+ +];
+ +
+ +fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
+ +    match expr.kind {
+ +        ExprKind::MethodCall(method, args, _) => {
+ +            for &(name, len) in &COMPLETING_METHODS {
+ +                if method.ident.name.as_str() == name && args.len() == len {
+ +                    return is_infinite(cx, &args[0]);
+ +                }
+ +            }
+ +            for &(name, len) in &POSSIBLY_COMPLETING_METHODS {
+ +                if method.ident.name.as_str() == name && args.len() == len {
+ +                    return MaybeInfinite.and(is_infinite(cx, &args[0]));
+ +                }
+ +            }
+ +            if method.ident.name == sym!(last) && args.len() == 1 {
+ +                let not_double_ended = get_trait_def_id(cx, &paths::DOUBLE_ENDED_ITERATOR).map_or(false, |id| {
+ +                    !implements_trait(cx, cx.typeck_results().expr_ty(&args[0]), id, &[])
+ +                });
+ +                if not_double_ended {
+ +                    return is_infinite(cx, &args[0]);
+ +                }
+ +            } else if method.ident.name == sym!(collect) {
+ +                let ty = cx.typeck_results().expr_ty(expr);
+ +                if INFINITE_COLLECTORS
+ +                    .iter()
+ +                    .any(|diag_item| is_type_diagnostic_item(cx, ty, *diag_item))
+ +                {
+ +                    return is_infinite(cx, &args[0]);
+ +                }
+ +            }
+ +        },
+ +        ExprKind::Binary(op, l, r) => {
+ +            if op.node.is_comparison() {
+ +                return is_infinite(cx, l).and(is_infinite(cx, r)).and(MaybeInfinite);
+ +            }
+ +        }, // TODO: ExprKind::Loop + Match
+ +        _ => (),
+ +    }
+ +    Finite
+ +}
diff --cc src/tools/clippy/clippy_lints/src/lib.register_all.rs

index 4721b7f2b472b3ffaab9da2a2e21b8f486cf8457,0000000000000000000000000000000000000000..d93e34e76b492bc9320fd4eb6aa6bf8ce4a3a151

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,316 -1,0 +1,317 @@@
+ +// 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(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::TRANSMUTE_UNDEFINED_REPR),
+ +    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_correctness.rs

index 4217fd3a3ea72c04af802f688f39d34f1f501c7a,0000000000000000000000000000000000000000..d013daa8e082a72eb316681fb421749cf455292c

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.register_correctness.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.register_correctness.rs
@@@ -1,75 -1,0 +1,76 @@@
+ +// 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::correctness", Some("clippy_correctness"), vec![
+ +    LintId::of(absurd_extreme_comparisons::ABSURD_EXTREME_COMPARISONS),
+ +    LintId::of(approx_const::APPROX_CONSTANT),
+ +    LintId::of(async_yields_async::ASYNC_YIELDS_ASYNC),
+ +    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(booleans::LOGIC_BUG),
+ +    LintId::of(casts::CAST_REF_TO_MUT),
+ +    LintId::of(copies::IFS_SAME_COND),
+ +    LintId::of(copies::IF_SAME_THEN_ELSE),
+ +    LintId::of(derive::DERIVE_HASH_XOR_EQ),
+ +    LintId::of(derive::DERIVE_ORD_XOR_PARTIAL_ORD),
+ +    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(enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT),
+ +    LintId::of(eq_op::EQ_OP),
+ +    LintId::of(erasing_op::ERASING_OP),
+ +    LintId::of(formatting::POSSIBLE_MISSING_COMMA),
+ +    LintId::of(functions::NOT_UNSAFE_PTR_ARG_DEREF),
+ +    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_SHADOW_DISPLAY),
+ +    LintId::of(inline_fn_without_body::INLINE_FN_WITHOUT_BODY),
+ +    LintId::of(let_underscore::LET_UNDERSCORE_LOCK),
+ +    LintId::of(literal_representation::MISTYPED_LITERAL_SUFFIXES),
+ +    LintId::of(loops::ITER_NEXT_LOOP),
+ +    LintId::of(loops::NEVER_LOOP),
+ +    LintId::of(loops::WHILE_IMMUTABLE_CONDITION),
+ +    LintId::of(match_str_case_mismatch::MATCH_STR_CASE_MISMATCH),
+ +    LintId::of(mem_replace::MEM_REPLACE_WITH_UNINIT),
+ +    LintId::of(methods::CLONE_DOUBLE_REF),
+ +    LintId::of(methods::ITERATOR_STEP_BY_ZERO),
+ +    LintId::of(methods::SUSPICIOUS_SPLITN),
+ +    LintId::of(methods::UNINIT_ASSUMED_INIT),
+ +    LintId::of(methods::ZST_OFFSET),
+ +    LintId::of(minmax::MIN_MAX),
+ +    LintId::of(misc::CMP_NAN),
+ +    LintId::of(misc::MODULO_ONE),
+ +    LintId::of(non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS),
+ +    LintId::of(open_options::NONSENSICAL_OPEN_OPTIONS),
+ +    LintId::of(option_env_unwrap::OPTION_ENV_UNWRAP),
+ +    LintId::of(ptr::INVALID_NULL_PTR_USAGE),
+ +    LintId::of(ptr::MUT_FROM_REF),
+ +    LintId::of(ranges::REVERSED_EMPTY_RANGES),
+ +    LintId::of(regex::INVALID_REGEX),
+ +    LintId::of(self_assignment::SELF_ASSIGNMENT),
+ +    LintId::of(serde_api::SERDE_API_MISUSE),
+ +    LintId::of(size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT),
+ +    LintId::of(swap::ALMOST_SWAPPED),
+ +    LintId::of(to_string_in_display::TO_STRING_IN_DISPLAY),
++    LintId::of(transmute::TRANSMUTE_UNDEFINED_REPR),
+ +    LintId::of(transmute::UNSOUND_COLLECTION_TRANSMUTE),
+ +    LintId::of(transmute::WRONG_TRANSMUTE),
+ +    LintId::of(transmuting_null::TRANSMUTING_NULL),
+ +    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_CMP),
+ +    LintId::of(unnamed_address::FN_ADDRESS_COMPARISONS),
+ +    LintId::of(unnamed_address::VTABLE_ADDRESS_COMPARISONS),
+ +    LintId::of(unused_io_amount::UNUSED_IO_AMOUNT),
+ +    LintId::of(unwrap::PANICKING_UNWRAP),
+ +    LintId::of(vec_resize_to_zero::VEC_RESIZE_TO_ZERO),
+ +])
diff --cc src/tools/clippy/clippy_lints/src/lib.register_lints.rs

index 2d2693832e9716721feb10b87b1e9fba457e205a,0000000000000000000000000000000000000000..a80320a578f0e7ba609c90fad800c08ab7c8b456

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,537 @@@
+ +// 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,
++    default_union_representation::DEFAULT_UNION_REPRESENTATION,
+ +    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,
+ +    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::TRANSMUTE_UNDEFINED_REPR,
+ +    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_restriction.rs

index e7e2798da7da99785f7b46c6410ee615f00c4bcd,0000000000000000000000000000000000000000..5a89fdb05a9904ab1442fd73bada9b12c7be9a37

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.register_restriction.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.register_restriction.rs
@@@ -1,72 -1,0 +1,73 @@@
+ +// 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::restriction", Some("clippy_restriction"), vec![
+ +    LintId::of(arithmetic::FLOAT_ARITHMETIC),
+ +    LintId::of(arithmetic::INTEGER_ARITHMETIC),
+ +    LintId::of(as_conversions::AS_CONVERSIONS),
+ +    LintId::of(asm_syntax::INLINE_ASM_X86_ATT_SYNTAX),
+ +    LintId::of(asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX),
+ +    LintId::of(casts::FN_TO_NUMERIC_CAST_ANY),
+ +    LintId::of(create_dir::CREATE_DIR),
+ +    LintId::of(dbg_macro::DBG_MACRO),
+ +    LintId::of(default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK),
++    LintId::of(default_union_representation::DEFAULT_UNION_REPRESENTATION),
+ +    LintId::of(disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS),
+ +    LintId::of(else_if_without_else::ELSE_IF_WITHOUT_ELSE),
+ +    LintId::of(exhaustive_items::EXHAUSTIVE_ENUMS),
+ +    LintId::of(exhaustive_items::EXHAUSTIVE_STRUCTS),
+ +    LintId::of(exit::EXIT),
+ +    LintId::of(float_literal::LOSSY_FLOAT_LITERAL),
+ +    LintId::of(if_then_some_else_none::IF_THEN_SOME_ELSE_NONE),
+ +    LintId::of(implicit_return::IMPLICIT_RETURN),
+ +    LintId::of(indexing_slicing::INDEXING_SLICING),
+ +    LintId::of(inherent_impl::MULTIPLE_INHERENT_IMPL),
+ +    LintId::of(integer_division::INTEGER_DIVISION),
+ +    LintId::of(let_underscore::LET_UNDERSCORE_MUST_USE),
+ +    LintId::of(literal_representation::DECIMAL_LITERAL_REPRESENTATION),
+ +    LintId::of(map_err_ignore::MAP_ERR_IGNORE),
+ +    LintId::of(matches::REST_PAT_IN_FULLY_BOUND_STRUCTS),
+ +    LintId::of(matches::WILDCARD_ENUM_MATCH_ARM),
+ +    LintId::of(mem_forget::MEM_FORGET),
+ +    LintId::of(methods::CLONE_ON_REF_PTR),
+ +    LintId::of(methods::EXPECT_USED),
+ +    LintId::of(methods::FILETYPE_IS_FILE),
+ +    LintId::of(methods::GET_UNWRAP),
+ +    LintId::of(methods::UNWRAP_USED),
+ +    LintId::of(misc::FLOAT_CMP_CONST),
+ +    LintId::of(misc_early::SEPARATED_LITERAL_SUFFIX),
+ +    LintId::of(misc_early::UNNEEDED_FIELD_PATTERN),
+ +    LintId::of(misc_early::UNSEPARATED_LITERAL_SUFFIX),
+ +    LintId::of(missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS),
+ +    LintId::of(missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES),
+ +    LintId::of(missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS),
+ +    LintId::of(module_style::MOD_MODULE_FILES),
+ +    LintId::of(module_style::SELF_NAMED_MODULE_FILES),
+ +    LintId::of(modulo_arithmetic::MODULO_ARITHMETIC),
+ +    LintId::of(panic_in_result_fn::PANIC_IN_RESULT_FN),
+ +    LintId::of(panic_unimplemented::PANIC),
+ +    LintId::of(panic_unimplemented::TODO),
+ +    LintId::of(panic_unimplemented::UNIMPLEMENTED),
+ +    LintId::of(panic_unimplemented::UNREACHABLE),
+ +    LintId::of(pattern_type_mismatch::PATTERN_TYPE_MISMATCH),
+ +    LintId::of(same_name_method::SAME_NAME_METHOD),
+ +    LintId::of(shadow::SHADOW_REUSE),
+ +    LintId::of(shadow::SHADOW_SAME),
+ +    LintId::of(shadow::SHADOW_UNRELATED),
+ +    LintId::of(single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES),
+ +    LintId::of(strings::STRING_ADD),
+ +    LintId::of(strings::STRING_SLICE),
+ +    LintId::of(strings::STRING_TO_STRING),
+ +    LintId::of(strings::STR_TO_STRING),
+ +    LintId::of(types::RC_BUFFER),
+ +    LintId::of(types::RC_MUTEX),
+ +    LintId::of(undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS),
+ +    LintId::of(unicode::NON_ASCII_LITERAL),
+ +    LintId::of(unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS),
+ +    LintId::of(unwrap_in_result::UNWRAP_IN_RESULT),
+ +    LintId::of(verbose_file_reads::VERBOSE_FILE_READS),
+ +    LintId::of(write::PRINT_STDERR),
+ +    LintId::of(write::PRINT_STDOUT),
+ +    LintId::of(write::USE_DEBUG),
+ +])
diff --cc src/tools/clippy/clippy_lints/src/lib.rs

index f2a7e925dd3952e698461b003c7347330fc020f0,0000000000000000000000000000000000000000..9999cd3f8243ced36028f32f8cd2196e8a18b774

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/lib.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@@ -1,956 -1,0 +1,961 @@@
+ +// error-pattern:cargo-clippy
+ +
+ +#![feature(binary_heap_into_iter_sorted)]
+ +#![feature(box_patterns)]
+ +#![feature(control_flow_enum)]
+ +#![feature(drain_filter)]
+ +#![feature(iter_intersperse)]
++#![feature(let_chains)]
+ +#![feature(let_else)]
+ +#![feature(once_cell)]
+ +#![feature(rustc_private)]
+ +#![feature(stmt_expr_attributes)]
+ +#![recursion_limit = "512"]
+ +#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+ +#![allow(clippy::missing_docs_in_private_items, clippy::must_use_candidate)]
+ +#![warn(trivial_casts, trivial_numeric_casts)]
+ +// warn on lints, that are included in `rust-lang/rust`s bootstrap
+ +#![warn(rust_2018_idioms, unused_lifetimes)]
+ +// warn on rustc internal lints
+ +#![warn(rustc::internal)]
++// Disable this rustc lint for now, as it was also done in rustc
++#![allow(rustc::potential_query_instability)]
+ +
+ +// FIXME: switch to something more ergonomic here, once available.
+ +// (Currently there is no way to opt into sysroot crates without `extern crate`.)
+ +extern crate rustc_ast;
+ +extern crate rustc_ast_pretty;
+ +extern crate rustc_data_structures;
+ +extern crate rustc_driver;
+ +extern crate rustc_errors;
+ +extern crate rustc_hir;
+ +extern crate rustc_hir_pretty;
+ +extern crate rustc_index;
+ +extern crate rustc_infer;
+ +extern crate rustc_lexer;
+ +extern crate rustc_lint;
+ +extern crate rustc_middle;
+ +extern crate rustc_mir_dataflow;
+ +extern crate rustc_parse;
+ +extern crate rustc_parse_format;
+ +extern crate rustc_session;
+ +extern crate rustc_span;
+ +extern crate rustc_target;
+ +extern crate rustc_trait_selection;
+ +extern crate rustc_typeck;
+ +
+ +#[macro_use]
+ +extern crate clippy_utils;
+ +
+ +use clippy_utils::parse_msrv;
+ +use rustc_data_structures::fx::FxHashSet;
+ +use rustc_lint::LintId;
+ +use rustc_session::Session;
+ +
+ +/// Macro used to declare a Clippy lint.
+ +///
+ +/// Every lint declaration consists of 4 parts:
+ +///
+ +/// 1. The documentation, which is used for the website
+ +/// 2. The `LINT_NAME`. See [lint naming][lint_naming] on lint naming conventions.
+ +/// 3. The `lint_level`, which is a mapping from *one* of our lint groups to `Allow`, `Warn` or
+ +///    `Deny`. The lint level here has nothing to do with what lint groups the lint is a part of.
+ +/// 4. The `description` that contains a short explanation on what's wrong with code where the
+ +///    lint is triggered.
+ +///
+ +/// Currently the categories `style`, `correctness`, `suspicious`, `complexity` and `perf` are
+ +/// enabled by default. As said in the README.md of this repository, if the lint level mapping
+ +/// changes, please update README.md.
+ +///
+ +/// # Example
+ +///
+ +/// ```
+ +/// #![feature(rustc_private)]
+ +/// extern crate rustc_session;
+ +/// use rustc_session::declare_tool_lint;
+ +/// use clippy_lints::declare_clippy_lint;
+ +///
+ +/// declare_clippy_lint! {
+ +///     /// ### What it does
+ +///     /// Checks for ... (describe what the lint matches).
+ +///     ///
+ +///     /// ### Why is this bad?
+ +///     /// Supply the reason for linting the code.
+ +///     ///
+ +///     /// ### Example
+ +///     /// ```rust
+ +///     /// // Bad
+ +///     /// Insert a short example of code that triggers the lint
+ +///     ///
+ +///     /// // Good
+ +///     /// Insert a short example of improved code that doesn't trigger the lint
+ +///     /// ```
+ +///     pub LINT_NAME,
+ +///     pedantic,
+ +///     "description"
+ +/// }
+ +/// ```
+ +/// [lint_naming]: https://rust-lang.github.io/rfcs/0344-conventions-galore.html#lints
+ +#[macro_export]
+ +macro_rules! declare_clippy_lint {
+ +    { $(#[$attr:meta])* pub $name:tt, style, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, correctness, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Deny, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, suspicious, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, complexity, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, perf, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, pedantic, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, restriction, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, cargo, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, nursery, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, internal, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Allow, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +    { $(#[$attr:meta])* pub $name:tt, internal_warn, $description:tt } => {
+ +        declare_tool_lint! {
+ +            $(#[$attr])* pub clippy::$name, Warn, $description, report_in_external_macro: true
+ +        }
+ +    };
+ +}
+ +
+ +#[cfg(feature = "internal")]
+ +mod deprecated_lints;
+ +#[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
+ +mod utils;
+ +
+ +// begin lints modules, do not remove this comment, it’s used in `update_lints`
+ +mod absurd_extreme_comparisons;
+ +mod approx_const;
+ +mod arithmetic;
+ +mod as_conversions;
+ +mod asm_syntax;
+ +mod assertions_on_constants;
+ +mod assign_ops;
+ +mod async_yields_async;
+ +mod attrs;
+ +mod await_holding_invalid;
+ +mod bit_mask;
+ +mod blacklisted_name;
+ +mod blocks_in_if_conditions;
+ +mod bool_assert_comparison;
+ +mod booleans;
+ +mod borrow_as_ptr;
+ +mod bytecount;
+ +mod cargo_common_metadata;
+ +mod case_sensitive_file_extension_comparisons;
+ +mod casts;
+ +mod checked_conversions;
+ +mod cognitive_complexity;
+ +mod collapsible_if;
+ +mod collapsible_match;
+ +mod comparison_chain;
+ +mod copies;
+ +mod copy_iterator;
+ +mod create_dir;
+ +mod dbg_macro;
+ +mod default;
+ +mod default_numeric_fallback;
++mod default_union_representation;
+ +mod dereference;
+ +mod derivable_impls;
+ +mod derive;
+ +mod disallowed_methods;
+ +mod disallowed_script_idents;
+ +mod disallowed_types;
+ +mod doc;
+ +mod double_comparison;
+ +mod double_parens;
+ +mod drop_forget_ref;
+ +mod duration_subsec;
+ +mod else_if_without_else;
+ +mod empty_enum;
+ +mod entry;
+ +mod enum_clike;
+ +mod enum_variants;
+ +mod eq_op;
+ +mod equatable_if_let;
+ +mod erasing_op;
+ +mod escape;
+ +mod eta_reduction;
+ +mod eval_order_dependence;
+ +mod excessive_bools;
+ +mod exhaustive_items;
+ +mod exit;
+ +mod explicit_write;
+ +mod fallible_impl_from;
+ +mod feature_name;
+ +mod float_equality_without_abs;
+ +mod float_literal;
+ +mod floating_point_arithmetic;
+ +mod format;
+ +mod format_args;
+ +mod formatting;
+ +mod from_over_into;
+ +mod from_str_radix_10;
+ +mod functions;
+ +mod future_not_send;
+ +mod get_last_with_len;
+ +mod identity_op;
+ +mod if_let_mutex;
+ +mod if_not_else;
+ +mod if_then_some_else_none;
+ +mod implicit_hasher;
+ +mod implicit_return;
+ +mod implicit_saturating_sub;
+ +mod inconsistent_struct_constructor;
+ +mod index_refutable_slice;
+ +mod indexing_slicing;
+ +mod infinite_iter;
+ +mod inherent_impl;
+ +mod inherent_to_string;
+ +mod init_numbered_fields;
+ +mod inline_fn_without_body;
+ +mod int_plus_one;
+ +mod integer_division;
+ +mod invalid_upcast_comparisons;
+ +mod items_after_statements;
+ +mod iter_not_returning_iterator;
+ +mod large_const_arrays;
+ +mod large_enum_variant;
+ +mod large_stack_arrays;
+ +mod len_zero;
+ +mod let_if_seq;
+ +mod let_underscore;
+ +mod lifetimes;
+ +mod literal_representation;
+ +mod loops;
+ +mod macro_use;
+ +mod main_recursion;
+ +mod manual_assert;
+ +mod manual_async_fn;
+ +mod manual_bits;
+ +mod manual_map;
+ +mod manual_non_exhaustive;
+ +mod manual_ok_or;
+ +mod manual_strip;
+ +mod manual_unwrap_or;
+ +mod map_clone;
+ +mod map_err_ignore;
+ +mod map_unit_fn;
+ +mod match_on_vec_items;
+ +mod match_result_ok;
+ +mod match_str_case_mismatch;
+ +mod matches;
+ +mod mem_forget;
+ +mod mem_replace;
+ +mod methods;
+ +mod minmax;
+ +mod misc;
+ +mod misc_early;
+ +mod missing_const_for_fn;
+ +mod missing_doc;
+ +mod missing_enforced_import_rename;
+ +mod missing_inline;
+ +mod module_style;
+ +mod modulo_arithmetic;
+ +mod multiple_crate_versions;
+ +mod mut_key;
+ +mod mut_mut;
+ +mod mut_mutex_lock;
+ +mod mut_reference;
+ +mod mutable_debug_assertion;
+ +mod mutex_atomic;
+ +mod needless_arbitrary_self_type;
+ +mod needless_bitwise_bool;
+ +mod needless_bool;
+ +mod needless_borrowed_ref;
+ +mod needless_continue;
+ +mod needless_for_each;
+ +mod needless_late_init;
+ +mod needless_option_as_deref;
+ +mod needless_pass_by_value;
+ +mod needless_question_mark;
+ +mod needless_update;
+ +mod neg_cmp_op_on_partial_ord;
+ +mod neg_multiply;
+ +mod new_without_default;
+ +mod no_effect;
+ +mod non_copy_const;
+ +mod non_expressive_names;
+ +mod non_octal_unix_permissions;
+ +mod non_send_fields_in_send_ty;
+ +mod nonstandard_macro_braces;
+ +mod octal_escapes;
+ +mod open_options;
+ +mod option_env_unwrap;
+ +mod option_if_let_else;
+ +mod overflow_check_conditional;
+ +mod panic_in_result_fn;
+ +mod panic_unimplemented;
+ +mod partialeq_ne_impl;
+ +mod pass_by_ref_or_value;
+ +mod path_buf_push_overwrite;
+ +mod pattern_type_mismatch;
+ +mod precedence;
+ +mod ptr;
+ +mod ptr_eq;
+ +mod ptr_offset_with_cast;
+ +mod question_mark;
+ +mod ranges;
+ +mod redundant_clone;
+ +mod redundant_closure_call;
+ +mod redundant_else;
+ +mod redundant_field_names;
+ +mod redundant_pub_crate;
+ +mod redundant_slicing;
+ +mod redundant_static_lifetimes;
+ +mod ref_option_ref;
+ +mod reference;
+ +mod regex;
+ +mod repeat_once;
+ +mod return_self_not_must_use;
+ +mod returns;
+ +mod same_name_method;
+ +mod self_assignment;
+ +mod self_named_constructors;
+ +mod semicolon_if_nothing_returned;
+ +mod serde_api;
+ +mod shadow;
+ +mod single_char_lifetime_names;
+ +mod single_component_path_imports;
+ +mod size_of_in_element_count;
+ +mod slow_vector_initialization;
+ +mod stable_sort_primitive;
+ +mod strings;
+ +mod strlen_on_c_strings;
+ +mod suspicious_operation_groupings;
+ +mod suspicious_trait_impl;
+ +mod swap;
+ +mod tabs_in_doc_comments;
+ +mod temporary_assignment;
+ +mod to_digit_is_some;
+ +mod to_string_in_display;
+ +mod trailing_empty_array;
+ +mod trait_bounds;
+ +mod transmute;
+ +mod transmuting_null;
+ +mod try_err;
+ +mod types;
+ +mod undocumented_unsafe_blocks;
+ +mod undropped_manually_drops;
+ +mod unicode;
+ +mod uninit_vec;
+ +mod unit_hash;
+ +mod unit_return_expecting_ord;
+ +mod unit_types;
+ +mod unnamed_address;
+ +mod unnecessary_self_imports;
+ +mod unnecessary_sort_by;
+ +mod unnecessary_wraps;
+ +mod unnested_or_patterns;
+ +mod unsafe_removed_from_name;
+ +mod unused_async;
+ +mod unused_io_amount;
+ +mod unused_self;
+ +mod unused_unit;
+ +mod unwrap;
+ +mod unwrap_in_result;
+ +mod upper_case_acronyms;
+ +mod use_self;
+ +mod useless_conversion;
+ +mod vec;
+ +mod vec_init_then_push;
+ +mod vec_resize_to_zero;
+ +mod verbose_file_reads;
+ +mod wildcard_dependencies;
+ +mod wildcard_imports;
+ +mod write;
+ +mod zero_div_zero;
+ +mod zero_sized_map_values;
+ +// end lints modules, do not remove this comment, it’s used in `update_lints`
+ +
+ +pub use crate::utils::conf::Conf;
+ +use crate::utils::conf::TryConf;
+ +
+ +/// Register all pre expansion lints
+ +///
+ +/// Pre-expansion lints run before any macro expansion has happened.
+ +///
+ +/// Note that due to the architecture of the compiler, currently `cfg_attr` attributes on crate
+ +/// level (i.e `#![cfg_attr(...)]`) will still be expanded even when using a pre-expansion pass.
+ +///
+ +/// Used in `./src/driver.rs`.
+ +pub fn register_pre_expansion_lints(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
+ +    // NOTE: Do not add any more pre-expansion passes. These should be removed eventually.
+ +
+ +    let msrv = conf.msrv.as_ref().and_then(|s| {
+ +        parse_msrv(s, None, None).or_else(|| {
+ +            sess.err(&format!(
+ +                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
+ +                s
+ +            ));
+ +            None
+ +        })
+ +    });
+ +
+ +    store.register_pre_expansion_pass(|| Box::new(write::Write::default()));
+ +    store.register_pre_expansion_pass(move || Box::new(attrs::EarlyAttributes { msrv }));
+ +    store.register_pre_expansion_pass(|| Box::new(dbg_macro::DbgMacro));
+ +}
+ +
+ +#[doc(hidden)]
+ +pub fn read_conf(sess: &Session) -> Conf {
+ +    let file_name = match utils::conf::lookup_conf_file() {
+ +        Ok(Some(path)) => path,
+ +        Ok(None) => return Conf::default(),
+ +        Err(error) => {
+ +            sess.struct_err(&format!("error finding Clippy's configuration file: {}", error))
+ +                .emit();
+ +            return Conf::default();
+ +        },
+ +    };
+ +
+ +    let TryConf { conf, errors } = utils::conf::read(&file_name);
+ +    // all conf errors are non-fatal, we just use the default conf in case of error
+ +    for error in errors {
+ +        sess.struct_err(&format!(
+ +            "error reading Clippy's configuration file `{}`: {}",
+ +            file_name.display(),
+ +            error
+ +        ))
+ +        .emit();
+ +    }
+ +
+ +    conf
+ +}
+ +
+ +/// Register all lints and lint groups with the rustc plugin registry
+ +///
+ +/// Used in `./src/driver.rs`.
+ +#[allow(clippy::too_many_lines)]
+ +pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: &Conf) {
+ +    register_removed_non_tool_lints(store);
+ +
+ +    include!("lib.deprecated.rs");
+ +
+ +    include!("lib.register_lints.rs");
+ +    include!("lib.register_restriction.rs");
+ +    include!("lib.register_pedantic.rs");
+ +
+ +    #[cfg(feature = "internal")]
+ +    include!("lib.register_internal.rs");
+ +
+ +    include!("lib.register_all.rs");
+ +    include!("lib.register_style.rs");
+ +    include!("lib.register_complexity.rs");
+ +    include!("lib.register_correctness.rs");
+ +    include!("lib.register_suspicious.rs");
+ +    include!("lib.register_perf.rs");
+ +    include!("lib.register_cargo.rs");
+ +    include!("lib.register_nursery.rs");
+ +
+ +    #[cfg(feature = "internal")]
+ +    {
+ +        if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
+ +            store.register_late_pass(|| Box::new(utils::internal_lints::metadata_collector::MetadataCollector::new()));
+ +            return;
+ +        }
+ +    }
+ +
+ +    // all the internal lints
+ +    #[cfg(feature = "internal")]
+ +    {
+ +        store.register_early_pass(|| Box::new(utils::internal_lints::ClippyLintsInternal));
+ +        store.register_early_pass(|| Box::new(utils::internal_lints::ProduceIce));
+ +        store.register_late_pass(|| Box::new(utils::inspector::DeepCodeInspector));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::CollapsibleCalls));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::CompilerLintFunctions::new()));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::IfChainStyle));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::InvalidPaths));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::InterningDefinedSymbol::default()));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::LintWithoutLintPass::default()));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::MatchTypeOnDiagItem));
+ +        store.register_late_pass(|| Box::new(utils::internal_lints::OuterExpnDataPass));
+ +    }
+ +
+ +    store.register_late_pass(|| Box::new(utils::author::Author));
+ +    store.register_late_pass(|| Box::new(await_holding_invalid::AwaitHolding));
+ +    store.register_late_pass(|| Box::new(serde_api::SerdeApi));
+ +    let vec_box_size_threshold = conf.vec_box_size_threshold;
+ +    let type_complexity_threshold = conf.type_complexity_threshold;
+ +    let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
+ +    store.register_late_pass(move || {
+ +        Box::new(types::Types::new(
+ +            vec_box_size_threshold,
+ +            type_complexity_threshold,
+ +            avoid_breaking_exported_api,
+ +        ))
+ +    });
+ +    store.register_late_pass(|| Box::new(booleans::NonminimalBool));
+ +    store.register_late_pass(|| Box::new(needless_bitwise_bool::NeedlessBitwiseBool));
+ +    store.register_late_pass(|| Box::new(eq_op::EqOp));
+ +    store.register_late_pass(|| Box::new(enum_clike::UnportableVariant));
+ +    store.register_late_pass(|| Box::new(float_literal::FloatLiteral));
+ +    let verbose_bit_mask_threshold = conf.verbose_bit_mask_threshold;
+ +    store.register_late_pass(move || Box::new(bit_mask::BitMask::new(verbose_bit_mask_threshold)));
+ +    store.register_late_pass(|| Box::new(ptr::Ptr));
+ +    store.register_late_pass(|| Box::new(ptr_eq::PtrEq));
+ +    store.register_late_pass(|| Box::new(needless_bool::NeedlessBool));
+ +    store.register_late_pass(|| Box::new(needless_option_as_deref::OptionNeedlessDeref));
+ +    store.register_late_pass(|| Box::new(needless_bool::BoolComparison));
+ +    store.register_late_pass(|| Box::new(needless_for_each::NeedlessForEach));
+ +    store.register_late_pass(|| Box::new(misc::MiscLints));
+ +    store.register_late_pass(|| Box::new(eta_reduction::EtaReduction));
+ +    store.register_late_pass(|| Box::new(identity_op::IdentityOp));
+ +    store.register_late_pass(|| Box::new(erasing_op::ErasingOp));
+ +    store.register_late_pass(|| Box::new(mut_mut::MutMut));
+ +    store.register_late_pass(|| Box::new(mut_reference::UnnecessaryMutPassed));
+ +    store.register_late_pass(|| Box::new(len_zero::LenZero));
+ +    store.register_late_pass(|| Box::new(attrs::Attributes));
+ +    store.register_late_pass(|| Box::new(blocks_in_if_conditions::BlocksInIfConditions));
+ +    store.register_late_pass(|| Box::new(collapsible_match::CollapsibleMatch));
+ +    store.register_late_pass(|| Box::new(unicode::Unicode));
+ +    store.register_late_pass(|| Box::new(uninit_vec::UninitVec));
+ +    store.register_late_pass(|| Box::new(unit_hash::UnitHash));
+ +    store.register_late_pass(|| Box::new(unit_return_expecting_ord::UnitReturnExpectingOrd));
+ +    store.register_late_pass(|| Box::new(strings::StringAdd));
+ +    store.register_late_pass(|| Box::new(implicit_return::ImplicitReturn));
+ +    store.register_late_pass(|| Box::new(implicit_saturating_sub::ImplicitSaturatingSub));
+ +    store.register_late_pass(|| Box::new(default_numeric_fallback::DefaultNumericFallback));
+ +    store.register_late_pass(|| Box::new(inconsistent_struct_constructor::InconsistentStructConstructor));
+ +    store.register_late_pass(|| Box::new(non_octal_unix_permissions::NonOctalUnixPermissions));
+ +    store.register_early_pass(|| Box::new(unnecessary_self_imports::UnnecessarySelfImports));
+ +
+ +    let msrv = conf.msrv.as_ref().and_then(|s| {
+ +        parse_msrv(s, None, None).or_else(|| {
+ +            sess.err(&format!(
+ +                "error reading Clippy's configuration file. `{}` is not a valid Rust version",
+ +                s
+ +            ));
+ +            None
+ +        })
+ +    });
+ +
+ +    let avoid_breaking_exported_api = conf.avoid_breaking_exported_api;
+ +    store.register_late_pass(move || Box::new(approx_const::ApproxConstant::new(msrv)));
+ +    store.register_late_pass(move || Box::new(methods::Methods::new(avoid_breaking_exported_api, msrv)));
+ +    store.register_late_pass(move || Box::new(matches::Matches::new(msrv)));
+ +    store.register_early_pass(move || Box::new(manual_non_exhaustive::ManualNonExhaustive::new(msrv)));
+ +    store.register_late_pass(move || Box::new(manual_strip::ManualStrip::new(msrv)));
+ +    store.register_early_pass(move || Box::new(redundant_static_lifetimes::RedundantStaticLifetimes::new(msrv)));
+ +    store.register_early_pass(move || Box::new(redundant_field_names::RedundantFieldNames::new(msrv)));
+ +    store.register_late_pass(move || Box::new(checked_conversions::CheckedConversions::new(msrv)));
+ +    store.register_late_pass(move || Box::new(mem_replace::MemReplace::new(msrv)));
+ +    store.register_late_pass(move || Box::new(ranges::Ranges::new(msrv)));
+ +    store.register_late_pass(move || Box::new(from_over_into::FromOverInto::new(msrv)));
+ +    store.register_late_pass(move || Box::new(use_self::UseSelf::new(msrv)));
+ +    store.register_late_pass(move || Box::new(missing_const_for_fn::MissingConstForFn::new(msrv)));
+ +    store.register_late_pass(move || Box::new(needless_question_mark::NeedlessQuestionMark));
+ +    store.register_late_pass(move || Box::new(casts::Casts::new(msrv)));
+ +    store.register_early_pass(move || Box::new(unnested_or_patterns::UnnestedOrPatterns::new(msrv)));
+ +    store.register_late_pass(move || Box::new(map_clone::MapClone::new(msrv)));
+ +
+ +    store.register_late_pass(|| Box::new(size_of_in_element_count::SizeOfInElementCount));
+ +    store.register_late_pass(|| Box::new(same_name_method::SameNameMethod));
+ +    let max_suggested_slice_pattern_length = conf.max_suggested_slice_pattern_length;
+ +    store.register_late_pass(move || {
+ +        Box::new(index_refutable_slice::IndexRefutableSlice::new(
+ +            max_suggested_slice_pattern_length,
+ +            msrv,
+ +        ))
+ +    });
+ +    store.register_late_pass(|| Box::new(map_err_ignore::MapErrIgnore));
+ +    store.register_late_pass(|| Box::new(shadow::Shadow::default()));
+ +    store.register_late_pass(|| Box::new(unit_types::UnitTypes));
+ +    store.register_late_pass(|| Box::new(loops::Loops));
+ +    store.register_late_pass(|| Box::new(main_recursion::MainRecursion::default()));
+ +    store.register_late_pass(|| Box::new(lifetimes::Lifetimes));
+ +    store.register_late_pass(|| Box::new(entry::HashMapPass));
+ +    store.register_late_pass(|| Box::new(minmax::MinMaxPass));
+ +    store.register_late_pass(|| Box::new(open_options::OpenOptions));
+ +    store.register_late_pass(|| Box::new(zero_div_zero::ZeroDiv));
+ +    store.register_late_pass(|| Box::new(mutex_atomic::Mutex));
+ +    store.register_late_pass(|| Box::new(needless_update::NeedlessUpdate));
+ +    store.register_late_pass(|| Box::new(needless_borrowed_ref::NeedlessBorrowedRef));
+ +    store.register_late_pass(|| Box::new(no_effect::NoEffect));
+ +    store.register_late_pass(|| Box::new(temporary_assignment::TemporaryAssignment));
+ +    store.register_late_pass(|| Box::new(transmute::Transmute));
+ +    let cognitive_complexity_threshold = conf.cognitive_complexity_threshold;
+ +    store.register_late_pass(move || {
+ +        Box::new(cognitive_complexity::CognitiveComplexity::new(
+ +            cognitive_complexity_threshold,
+ +        ))
+ +    });
+ +    let too_large_for_stack = conf.too_large_for_stack;
+ +    store.register_late_pass(move || Box::new(escape::BoxedLocal { too_large_for_stack }));
+ +    store.register_late_pass(move || Box::new(vec::UselessVec { too_large_for_stack }));
+ +    store.register_late_pass(|| Box::new(panic_unimplemented::PanicUnimplemented));
+ +    store.register_late_pass(|| Box::new(strings::StringLitAsBytes));
+ +    store.register_late_pass(|| Box::new(derive::Derive));
+ +    store.register_late_pass(|| Box::new(derivable_impls::DerivableImpls));
+ +    store.register_late_pass(|| Box::new(get_last_with_len::GetLastWithLen));
+ +    store.register_late_pass(|| Box::new(drop_forget_ref::DropForgetRef));
+ +    store.register_late_pass(|| Box::new(empty_enum::EmptyEnum));
+ +    store.register_late_pass(|| Box::new(absurd_extreme_comparisons::AbsurdExtremeComparisons));
+ +    store.register_late_pass(|| Box::new(invalid_upcast_comparisons::InvalidUpcastComparisons));
+ +    store.register_late_pass(|| Box::new(regex::Regex));
+ +    store.register_late_pass(|| Box::new(copies::CopyAndPaste));
+ +    store.register_late_pass(|| Box::new(copy_iterator::CopyIterator));
+ +    store.register_late_pass(|| Box::new(format::UselessFormat));
+ +    store.register_late_pass(|| Box::new(swap::Swap));
+ +    store.register_late_pass(|| Box::new(overflow_check_conditional::OverflowCheckConditional));
+ +    store.register_late_pass(|| Box::new(new_without_default::NewWithoutDefault::default()));
+ +    let blacklisted_names = conf.blacklisted_names.iter().cloned().collect::<FxHashSet<_>>();
+ +    store.register_late_pass(move || Box::new(blacklisted_name::BlacklistedName::new(blacklisted_names.clone())));
+ +    let too_many_arguments_threshold = conf.too_many_arguments_threshold;
+ +    let too_many_lines_threshold = conf.too_many_lines_threshold;
+ +    store.register_late_pass(move || {
+ +        Box::new(functions::Functions::new(
+ +            too_many_arguments_threshold,
+ +            too_many_lines_threshold,
+ +        ))
+ +    });
+ +    let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
+ +    store.register_late_pass(move || Box::new(doc::DocMarkdown::new(doc_valid_idents.clone())));
+ +    store.register_late_pass(|| Box::new(neg_multiply::NegMultiply));
+ +    store.register_late_pass(|| Box::new(mem_forget::MemForget));
+ +    store.register_late_pass(|| Box::new(arithmetic::Arithmetic::default()));
+ +    store.register_late_pass(|| Box::new(assign_ops::AssignOps));
+ +    store.register_late_pass(|| Box::new(let_if_seq::LetIfSeq));
+ +    store.register_late_pass(|| Box::new(eval_order_dependence::EvalOrderDependence));
+ +    store.register_late_pass(|| Box::new(missing_doc::MissingDoc::new()));
+ +    store.register_late_pass(|| Box::new(missing_inline::MissingInline));
+ +    store.register_late_pass(move || Box::new(exhaustive_items::ExhaustiveItems));
+ +    store.register_late_pass(|| Box::new(match_result_ok::MatchResultOk));
+ +    store.register_late_pass(|| Box::new(partialeq_ne_impl::PartialEqNeImpl));
+ +    store.register_late_pass(|| Box::new(unused_io_amount::UnusedIoAmount));
+ +    let enum_variant_size_threshold = conf.enum_variant_size_threshold;
+ +    store.register_late_pass(move || Box::new(large_enum_variant::LargeEnumVariant::new(enum_variant_size_threshold)));
+ +    store.register_late_pass(|| Box::new(explicit_write::ExplicitWrite));
+ +    store.register_late_pass(|| Box::new(needless_pass_by_value::NeedlessPassByValue));
+ +    let pass_by_ref_or_value = pass_by_ref_or_value::PassByRefOrValue::new(
+ +        conf.trivial_copy_size_limit,
+ +        conf.pass_by_value_size_limit,
+ +        conf.avoid_breaking_exported_api,
+ +        &sess.target,
+ +    );
+ +    store.register_late_pass(move || Box::new(pass_by_ref_or_value));
+ +    store.register_late_pass(|| Box::new(ref_option_ref::RefOptionRef));
+ +    store.register_late_pass(|| Box::new(try_err::TryErr));
+ +    store.register_late_pass(|| Box::new(bytecount::ByteCount));
+ +    store.register_late_pass(|| Box::new(infinite_iter::InfiniteIter));
+ +    store.register_late_pass(|| Box::new(inline_fn_without_body::InlineFnWithoutBody));
+ +    store.register_late_pass(|| Box::new(useless_conversion::UselessConversion::default()));
+ +    store.register_late_pass(|| Box::new(implicit_hasher::ImplicitHasher));
+ +    store.register_late_pass(|| Box::new(fallible_impl_from::FallibleImplFrom));
+ +    store.register_late_pass(|| Box::new(double_comparison::DoubleComparisons));
+ +    store.register_late_pass(|| Box::new(question_mark::QuestionMark));
+ +    store.register_early_pass(|| Box::new(suspicious_operation_groupings::SuspiciousOperationGroupings));
+ +    store.register_late_pass(|| Box::new(suspicious_trait_impl::SuspiciousImpl));
+ +    store.register_late_pass(|| Box::new(map_unit_fn::MapUnit));
+ +    store.register_late_pass(|| Box::new(inherent_impl::MultipleInherentImpl));
+ +    store.register_late_pass(|| Box::new(neg_cmp_op_on_partial_ord::NoNegCompOpForPartialOrd));
+ +    store.register_late_pass(|| Box::new(unwrap::Unwrap));
+ +    store.register_late_pass(|| Box::new(duration_subsec::DurationSubsec));
+ +    store.register_late_pass(|| Box::new(indexing_slicing::IndexingSlicing));
+ +    store.register_late_pass(|| Box::new(non_copy_const::NonCopyConst));
+ +    store.register_late_pass(|| Box::new(ptr_offset_with_cast::PtrOffsetWithCast));
+ +    store.register_late_pass(|| Box::new(redundant_clone::RedundantClone));
+ +    store.register_late_pass(|| Box::new(slow_vector_initialization::SlowVectorInit));
+ +    store.register_late_pass(|| Box::new(unnecessary_sort_by::UnnecessarySortBy));
+ +    store.register_late_pass(move || Box::new(unnecessary_wraps::UnnecessaryWraps::new(avoid_breaking_exported_api)));
+ +    store.register_late_pass(|| Box::new(assertions_on_constants::AssertionsOnConstants));
+ +    store.register_late_pass(|| Box::new(transmuting_null::TransmutingNull));
+ +    store.register_late_pass(|| Box::new(path_buf_push_overwrite::PathBufPushOverwrite));
+ +    store.register_late_pass(|| Box::new(integer_division::IntegerDivision));
+ +    store.register_late_pass(|| Box::new(inherent_to_string::InherentToString));
+ +    let max_trait_bounds = conf.max_trait_bounds;
+ +    store.register_late_pass(move || Box::new(trait_bounds::TraitBounds::new(max_trait_bounds)));
+ +    store.register_late_pass(|| Box::new(comparison_chain::ComparisonChain));
+ +    store.register_late_pass(|| Box::new(mut_key::MutableKeyType));
+ +    store.register_late_pass(|| Box::new(modulo_arithmetic::ModuloArithmetic));
+ +    store.register_early_pass(|| Box::new(reference::DerefAddrOf));
+ +    store.register_early_pass(|| Box::new(double_parens::DoubleParens));
+ +    store.register_late_pass(|| Box::new(to_string_in_display::ToStringInDisplay::new()));
+ +    store.register_early_pass(|| Box::new(unsafe_removed_from_name::UnsafeNameRemoval));
+ +    store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
+ +    store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
+ +    store.register_early_pass(|| Box::new(formatting::Formatting));
+ +    store.register_early_pass(|| Box::new(misc_early::MiscEarlyLints));
+ +    store.register_early_pass(|| Box::new(redundant_closure_call::RedundantClosureCall));
+ +    store.register_late_pass(|| Box::new(redundant_closure_call::RedundantClosureCall));
+ +    store.register_early_pass(|| Box::new(unused_unit::UnusedUnit));
+ +    store.register_late_pass(|| Box::new(returns::Return));
+ +    store.register_early_pass(|| Box::new(collapsible_if::CollapsibleIf));
+ +    store.register_early_pass(|| Box::new(items_after_statements::ItemsAfterStatements));
+ +    store.register_early_pass(|| Box::new(precedence::Precedence));
+ +    store.register_early_pass(|| Box::new(needless_continue::NeedlessContinue));
+ +    store.register_early_pass(|| Box::new(redundant_else::RedundantElse));
+ +    store.register_late_pass(|| Box::new(create_dir::CreateDir));
+ +    store.register_early_pass(|| Box::new(needless_arbitrary_self_type::NeedlessArbitrarySelfType));
+ +    let cargo_ignore_publish = conf.cargo_ignore_publish;
+ +    store.register_late_pass(move || Box::new(cargo_common_metadata::CargoCommonMetadata::new(cargo_ignore_publish)));
+ +    store.register_late_pass(|| Box::new(multiple_crate_versions::MultipleCrateVersions));
+ +    store.register_late_pass(|| Box::new(wildcard_dependencies::WildcardDependencies));
+ +    let literal_representation_lint_fraction_readability = conf.unreadable_literal_lint_fractions;
+ +    store.register_early_pass(move || {
+ +        Box::new(literal_representation::LiteralDigitGrouping::new(
+ +            literal_representation_lint_fraction_readability,
+ +        ))
+ +    });
+ +    let literal_representation_threshold = conf.literal_representation_threshold;
+ +    store.register_early_pass(move || {
+ +        Box::new(literal_representation::DecimalLiteralRepresentation::new(
+ +            literal_representation_threshold,
+ +        ))
+ +    });
+ +    let enum_variant_name_threshold = conf.enum_variant_name_threshold;
+ +    store.register_late_pass(move || {
+ +        Box::new(enum_variants::EnumVariantNames::new(
+ +            enum_variant_name_threshold,
+ +            avoid_breaking_exported_api,
+ +        ))
+ +    });
+ +    store.register_early_pass(|| Box::new(tabs_in_doc_comments::TabsInDocComments));
+ +    let upper_case_acronyms_aggressive = conf.upper_case_acronyms_aggressive;
+ +    store.register_late_pass(move || {
+ +        Box::new(upper_case_acronyms::UpperCaseAcronyms::new(
+ +            avoid_breaking_exported_api,
+ +            upper_case_acronyms_aggressive,
+ +        ))
+ +    });
+ +    store.register_late_pass(|| Box::new(default::Default::default()));
+ +    store.register_late_pass(|| Box::new(unused_self::UnusedSelf));
+ +    store.register_late_pass(|| Box::new(mutable_debug_assertion::DebugAssertWithMutCall));
+ +    store.register_late_pass(|| Box::new(exit::Exit));
+ +    store.register_late_pass(|| Box::new(to_digit_is_some::ToDigitIsSome));
+ +    let array_size_threshold = conf.array_size_threshold;
+ +    store.register_late_pass(move || Box::new(large_stack_arrays::LargeStackArrays::new(array_size_threshold)));
+ +    store.register_late_pass(move || Box::new(large_const_arrays::LargeConstArrays::new(array_size_threshold)));
+ +    store.register_late_pass(|| Box::new(floating_point_arithmetic::FloatingPointArithmetic));
+ +    store.register_early_pass(|| Box::new(as_conversions::AsConversions));
+ +    store.register_late_pass(|| Box::new(let_underscore::LetUnderscore));
+ +    store.register_early_pass(|| Box::new(single_component_path_imports::SingleComponentPathImports));
+ +    let max_fn_params_bools = conf.max_fn_params_bools;
+ +    let max_struct_bools = conf.max_struct_bools;
+ +    store.register_early_pass(move || {
+ +        Box::new(excessive_bools::ExcessiveBools::new(
+ +            max_struct_bools,
+ +            max_fn_params_bools,
+ +        ))
+ +    });
+ +    store.register_early_pass(|| Box::new(option_env_unwrap::OptionEnvUnwrap));
+ +    let warn_on_all_wildcard_imports = conf.warn_on_all_wildcard_imports;
+ +    store.register_late_pass(move || Box::new(wildcard_imports::WildcardImports::new(warn_on_all_wildcard_imports)));
+ +    store.register_late_pass(|| Box::new(verbose_file_reads::VerboseFileReads));
+ +    store.register_late_pass(|| Box::new(redundant_pub_crate::RedundantPubCrate::default()));
+ +    store.register_late_pass(|| Box::new(unnamed_address::UnnamedAddress));
+ +    store.register_late_pass(|| Box::new(dereference::Dereferencing::default()));
+ +    store.register_late_pass(|| Box::new(option_if_let_else::OptionIfLetElse));
+ +    store.register_late_pass(|| Box::new(future_not_send::FutureNotSend));
+ +    store.register_late_pass(|| Box::new(if_let_mutex::IfLetMutex));
+ +    store.register_late_pass(|| Box::new(if_not_else::IfNotElse));
+ +    store.register_late_pass(|| Box::new(equatable_if_let::PatternEquality));
+ +    store.register_late_pass(|| Box::new(mut_mutex_lock::MutMutexLock));
+ +    store.register_late_pass(|| Box::new(match_on_vec_items::MatchOnVecItems));
+ +    store.register_late_pass(|| Box::new(manual_async_fn::ManualAsyncFn));
+ +    store.register_late_pass(|| Box::new(vec_resize_to_zero::VecResizeToZero));
+ +    store.register_late_pass(|| Box::new(panic_in_result_fn::PanicInResultFn));
+ +    let single_char_binding_names_threshold = conf.single_char_binding_names_threshold;
+ +    store.register_early_pass(move || {
+ +        Box::new(non_expressive_names::NonExpressiveNames {
+ +            single_char_binding_names_threshold,
+ +        })
+ +    });
+ +    let macro_matcher = conf.standard_macro_braces.iter().cloned().collect::<FxHashSet<_>>();
+ +    store.register_early_pass(move || Box::new(nonstandard_macro_braces::MacroBraces::new(&macro_matcher)));
+ +    store.register_late_pass(|| Box::new(macro_use::MacroUseImports::default()));
+ +    store.register_late_pass(|| Box::new(pattern_type_mismatch::PatternTypeMismatch));
+ +    store.register_late_pass(|| Box::new(stable_sort_primitive::StableSortPrimitive));
+ +    store.register_late_pass(|| Box::new(repeat_once::RepeatOnce));
+ +    store.register_late_pass(|| Box::new(unwrap_in_result::UnwrapInResult));
+ +    store.register_late_pass(|| Box::new(self_assignment::SelfAssignment));
+ +    store.register_late_pass(|| Box::new(manual_unwrap_or::ManualUnwrapOr));
+ +    store.register_late_pass(|| Box::new(manual_ok_or::ManualOkOr));
+ +    store.register_late_pass(|| Box::new(float_equality_without_abs::FloatEqualityWithoutAbs));
+ +    store.register_late_pass(|| Box::new(semicolon_if_nothing_returned::SemicolonIfNothingReturned));
+ +    store.register_late_pass(|| Box::new(async_yields_async::AsyncYieldsAsync));
+ +    let disallowed_methods = conf.disallowed_methods.clone();
+ +    store.register_late_pass(move || Box::new(disallowed_methods::DisallowedMethods::new(disallowed_methods.clone())));
+ +    store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86AttSyntax));
+ +    store.register_early_pass(|| Box::new(asm_syntax::InlineAsmX86IntelSyntax));
+ +    store.register_late_pass(|| Box::new(undropped_manually_drops::UndroppedManuallyDrops));
+ +    store.register_late_pass(|| Box::new(strings::StrToString));
+ +    store.register_late_pass(|| Box::new(strings::StringToString));
+ +    store.register_late_pass(|| Box::new(zero_sized_map_values::ZeroSizedMapValues));
+ +    store.register_late_pass(|| Box::new(vec_init_then_push::VecInitThenPush::default()));
+ +    store.register_late_pass(|| {
+ +        Box::new(case_sensitive_file_extension_comparisons::CaseSensitiveFileExtensionComparisons)
+ +    });
+ +    store.register_late_pass(|| Box::new(redundant_slicing::RedundantSlicing));
+ +    store.register_late_pass(|| Box::new(from_str_radix_10::FromStrRadix10));
+ +    store.register_late_pass(|| Box::new(manual_map::ManualMap));
+ +    store.register_late_pass(move || Box::new(if_then_some_else_none::IfThenSomeElseNone::new(msrv)));
+ +    store.register_late_pass(|| Box::new(bool_assert_comparison::BoolAssertComparison));
+ +    store.register_early_pass(move || Box::new(module_style::ModStyle));
+ +    store.register_late_pass(|| Box::new(unused_async::UnusedAsync));
+ +    let disallowed_types = conf.disallowed_types.clone();
+ +    store.register_late_pass(move || Box::new(disallowed_types::DisallowedTypes::new(disallowed_types.clone())));
+ +    let import_renames = conf.enforced_import_renames.clone();
+ +    store.register_late_pass(move || {
+ +        Box::new(missing_enforced_import_rename::ImportRename::new(
+ +            import_renames.clone(),
+ +        ))
+ +    });
+ +    let scripts = conf.allowed_scripts.clone();
+ +    store.register_early_pass(move || Box::new(disallowed_script_idents::DisallowedScriptIdents::new(&scripts)));
+ +    store.register_late_pass(|| Box::new(strlen_on_c_strings::StrlenOnCStrings));
+ +    store.register_late_pass(move || Box::new(self_named_constructors::SelfNamedConstructors));
+ +    store.register_late_pass(move || Box::new(feature_name::FeatureName));
+ +    store.register_late_pass(move || Box::new(iter_not_returning_iterator::IterNotReturningIterator));
+ +    store.register_late_pass(move || Box::new(manual_assert::ManualAssert));
+ +    let enable_raw_pointer_heuristic_for_send = conf.enable_raw_pointer_heuristic_for_send;
+ +    store.register_late_pass(move || {
+ +        Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(
+ +            enable_raw_pointer_heuristic_for_send,
+ +        ))
+ +    });
+ +    store.register_late_pass(move || Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::default()));
+ +    store.register_late_pass(|| Box::new(match_str_case_mismatch::MatchStrCaseMismatch));
+ +    store.register_late_pass(move || Box::new(format_args::FormatArgs));
+ +    store.register_late_pass(|| Box::new(trailing_empty_array::TrailingEmptyArray));
+ +    store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
+ +    store.register_late_pass(|| Box::new(needless_late_init::NeedlessLateInit));
+ +    store.register_late_pass(|| Box::new(return_self_not_must_use::ReturnSelfNotMustUse));
+ +    store.register_late_pass(|| Box::new(init_numbered_fields::NumberedFields));
+ +    store.register_early_pass(|| Box::new(single_char_lifetime_names::SingleCharLifetimeNames));
+ +    store.register_late_pass(move || Box::new(borrow_as_ptr::BorrowAsPtr::new(msrv)));
+ +    store.register_late_pass(move || Box::new(manual_bits::ManualBits::new(msrv)));
++    store.register_late_pass(|| Box::new(default_union_representation::DefaultUnionRepresentation));
+ +    // add lints here, do not remove this comment, it's used in `new_lint`
+ +}
+ +
+ +#[rustfmt::skip]
+ +fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
+ +    store.register_removed(
+ +        "should_assert_eq",
+ +        "`assert!()` will be more flexible with RFC 2011",
+ +    );
+ +    store.register_removed(
+ +        "extend_from_slice",
+ +        "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
+ +    );
+ +    store.register_removed(
+ +        "range_step_by_zero",
+ +        "`iterator.step_by(0)` panics nowadays",
+ +    );
+ +    store.register_removed(
+ +        "unstable_as_slice",
+ +        "`Vec::as_slice` has been stabilized in 1.7",
+ +    );
+ +    store.register_removed(
+ +        "unstable_as_mut_slice",
+ +        "`Vec::as_mut_slice` has been stabilized in 1.7",
+ +    );
+ +    store.register_removed(
+ +        "misaligned_transmute",
+ +        "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
+ +    );
+ +    store.register_removed(
+ +        "assign_ops",
+ +        "using compound assignment operators (e.g., `+=`) is harmless",
+ +    );
+ +    store.register_removed(
+ +        "if_let_redundant_pattern_matching",
+ +        "this lint has been changed to redundant_pattern_matching",
+ +    );
+ +    store.register_removed(
+ +        "unsafe_vector_initialization",
+ +        "the replacement suggested by this lint had substantially different behavior",
+ +    );
+ +    store.register_removed(
+ +        "reverse_range_loop",
+ +        "this lint is now included in reversed_empty_ranges",
+ +    );
+ +}
+ +
+ +/// Register renamed lints.
+ +///
+ +/// Used in `./src/driver.rs`.
+ +pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
+ +    // NOTE: when renaming a lint, add a corresponding test to tests/ui/rename.rs
+ +    ls.register_renamed("clippy::stutter", "clippy::module_name_repetitions");
+ +    ls.register_renamed("clippy::new_without_default_derive", "clippy::new_without_default");
+ +    ls.register_renamed("clippy::cyclomatic_complexity", "clippy::cognitive_complexity");
+ +    ls.register_renamed("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes");
+ +    ls.register_renamed("clippy::option_and_then_some", "clippy::bind_instead_of_map");
+ +    ls.register_renamed("clippy::box_vec", "clippy::box_collection");
+ +    ls.register_renamed("clippy::block_in_if_condition_expr", "clippy::blocks_in_if_conditions");
+ +    ls.register_renamed("clippy::block_in_if_condition_stmt", "clippy::blocks_in_if_conditions");
+ +    ls.register_renamed("clippy::option_map_unwrap_or", "clippy::map_unwrap_or");
+ +    ls.register_renamed("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or");
+ +    ls.register_renamed("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or");
+ +    ls.register_renamed("clippy::option_unwrap_used", "clippy::unwrap_used");
+ +    ls.register_renamed("clippy::result_unwrap_used", "clippy::unwrap_used");
+ +    ls.register_renamed("clippy::option_expect_used", "clippy::expect_used");
+ +    ls.register_renamed("clippy::result_expect_used", "clippy::expect_used");
+ +    ls.register_renamed("clippy::for_loop_over_option", "clippy::for_loops_over_fallibles");
+ +    ls.register_renamed("clippy::for_loop_over_result", "clippy::for_loops_over_fallibles");
+ +    ls.register_renamed("clippy::identity_conversion", "clippy::useless_conversion");
+ +    ls.register_renamed("clippy::zero_width_space", "clippy::invisible_characters");
+ +    ls.register_renamed("clippy::single_char_push_str", "clippy::single_char_add_str");
+ +    ls.register_renamed("clippy::if_let_some_result", "clippy::match_result_ok");
+ +    ls.register_renamed("clippy::disallowed_type", "clippy::disallowed_types");
+ +    ls.register_renamed("clippy::disallowed_method", "clippy::disallowed_methods");
+ +    ls.register_renamed("clippy::ref_in_deref", "clippy::needless_borrow");
+ +
+ +    // uplifted lints
+ +    ls.register_renamed("clippy::invalid_ref", "invalid_value");
+ +    ls.register_renamed("clippy::into_iter_on_array", "array_into_iter");
+ +    ls.register_renamed("clippy::unused_label", "unused_labels");
+ +    ls.register_renamed("clippy::drop_bounds", "drop_bounds");
+ +    ls.register_renamed("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr");
+ +    ls.register_renamed("clippy::panic_params", "non_fmt_panics");
+ +    ls.register_renamed("clippy::unknown_clippy_lints", "unknown_lints");
+ +    ls.register_renamed("clippy::invalid_atomic_ordering", "invalid_atomic_ordering");
+ +    ls.register_renamed("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums");
+ +}
+ +
+ +// only exists to let the dogfood integration test works.
+ +// Don't run clippy as an executable directly
+ +#[allow(dead_code)]
+ +fn main() {
+ +    panic!("Please use the cargo-clippy executable");
+ +}
diff --cc src/tools/clippy/clippy_lints/src/loops/single_element_loop.rs

index 15f419e4410ca86ccdf83c2843c58b63625122bb,0000000000000000000000000000000000000000..36ecd83f7d643734e0f0f2df0977cd63f3c5ea70

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/loops/single_element_loop.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/loops/single_element_loop.rs
@@@ -1,49 -1,0 +1,45 @@@
- use clippy_utils::single_segment_path;
- use clippy_utils::source::{indent_of, snippet};
+ +use super::SINGLE_ELEMENT_LOOP;
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
- use rustc_hir::{BorrowKind, Expr, ExprKind, Pat, PatKind};
++use clippy_utils::source::{indent_of, snippet_with_applicability};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
-         ExprKind::MethodCall(method, args, _) if args.len() == 1 && method.ident.name == rustc_span::sym::iter => {
-             &args[0]
-         },
++use rustc_hir::{BorrowKind, Expr, ExprKind, Pat};
+ +use rustc_lint::LateContext;
+ +
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    pat: &'tcx Pat<'_>,
+ +    arg: &'tcx Expr<'_>,
+ +    body: &'tcx Expr<'_>,
+ +    expr: &'tcx Expr<'_>,
+ +) {
+ +    let arg_expr = match arg.kind {
+ +        ExprKind::AddrOf(BorrowKind::Ref, _, ref_arg) => ref_arg,
-         if let PatKind::Binding(.., target, _) = pat.kind;
++        ExprKind::MethodCall(method, [arg], _) if method.ident.name == rustc_span::sym::iter => arg,
+ +        _ => return,
+ +    };
+ +    if_chain! {
-         if let ExprKind::Path(ref list_item) = arg_expression.kind;
-         if let Some(list_item_name) = single_segment_path(list_item).map(|ps| ps.ident.name);
+ +        if let ExprKind::Array([arg_expression]) = arg_expr.kind;
- 
+ +        if let ExprKind::Block(block, _) = body.kind;
+ +        if !block.stmts.is_empty();
-             let mut block_str = snippet(cx, block.span, "..").into_owned();
+ +        then {
- 
++            let mut applicability = Applicability::MachineApplicable;
++            let pat_snip = snippet_with_applicability(cx, pat.span, "..", &mut applicability);
++            let arg_snip = snippet_with_applicability(cx, arg_expression.span, "..", &mut applicability);
++            let mut block_str = snippet_with_applicability(cx, block.span, "..", &mut applicability).into_owned();
+ +            block_str.remove(0);
+ +            block_str.pop();
-                 format!("{{\n{}let {} = &{};{}}}", " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0)), target.name, list_item_name, block_str),
-                 Applicability::MachineApplicable
++            let indent = " ".repeat(indent_of(cx, block.stmts[0].span).unwrap_or(0));
+ +
+ +            span_lint_and_sugg(
+ +                cx,
+ +                SINGLE_ELEMENT_LOOP,
+ +                expr.span,
+ +                "for loop over a single element",
+ +                "try",
++                format!("{{\n{}let {} = &{};{}}}", indent, pat_snip, arg_snip, block_str),
++                applicability,
+ +            )
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/loops/utils.rs

index eac0f03b142a821c56ade84d17f2ea5fe8264f04,0000000000000000000000000000000000000000..b6c746d3e397116fd1e6856a8a646f696076ef53

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/loops/utils.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/loops/utils.rs
@@@ -1,355 -1,0 +1,358 @@@
- use rustc_middle::ty::Ty;
+ +use clippy_utils::ty::{has_iter_method, implements_trait};
+ +use clippy_utils::{get_parent_expr, is_integer_const, path_to_local, path_to_local_id, sugg};
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::{LitIntType, LitKind};
+ +use rustc_errors::Applicability;
+ +use rustc_hir::intravisit::{walk_expr, walk_local, walk_pat, walk_stmt, Visitor};
+ +use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, HirId, HirIdMap, Local, Mutability, Pat, PatKind, Stmt};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::hir::nested_filter;
-         match &arg.kind {
-             ExprKind::AddrOf(BorrowKind::Ref, mutability, arg_inner)
-                 if has_iter_method(cx, cx.typeck_results().expr_ty(arg_inner)).is_some() =>
-             {
-                 let meth_name = match mutability {
++use rustc_middle::ty::{self, Ty};
+ +use rustc_span::source_map::Spanned;
+ +use rustc_span::symbol::{sym, Symbol};
+ +use rustc_typeck::hir_ty_to_ty;
+ +use std::iter::Iterator;
+ +
+ +#[derive(Debug, PartialEq)]
+ +enum IncrementVisitorVarState {
+ +    Initial,  // Not examined yet
+ +    IncrOnce, // Incremented exactly once, may be a loop counter
+ +    DontWarn,
+ +}
+ +
+ +/// Scan a for loop for variables that are incremented exactly once and not used after that.
+ +pub(super) struct IncrementVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,                  // context reference
+ +    states: HirIdMap<IncrementVisitorVarState>, // incremented variables
+ +    depth: u32,                                 // depth of conditional expressions
+ +    done: bool,
+ +}
+ +
+ +impl<'a, 'tcx> IncrementVisitor<'a, 'tcx> {
+ +    pub(super) fn new(cx: &'a LateContext<'tcx>) -> Self {
+ +        Self {
+ +            cx,
+ +            states: HirIdMap::default(),
+ +            depth: 0,
+ +            done: false,
+ +        }
+ +    }
+ +
+ +    pub(super) fn into_results(self) -> impl Iterator<Item = HirId> {
+ +        self.states.into_iter().filter_map(|(id, state)| {
+ +            if state == IncrementVisitorVarState::IncrOnce {
+ +                Some(id)
+ +            } else {
+ +                None
+ +            }
+ +        })
+ +    }
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for IncrementVisitor<'a, 'tcx> {
+ +    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+ +        if self.done {
+ +            return;
+ +        }
+ +
+ +        // If node is a variable
+ +        if let Some(def_id) = path_to_local(expr) {
+ +            if let Some(parent) = get_parent_expr(self.cx, expr) {
+ +                let state = self.states.entry(def_id).or_insert(IncrementVisitorVarState::Initial);
+ +                if *state == IncrementVisitorVarState::IncrOnce {
+ +                    *state = IncrementVisitorVarState::DontWarn;
+ +                    return;
+ +                }
+ +
+ +                match parent.kind {
+ +                    ExprKind::AssignOp(op, lhs, rhs) => {
+ +                        if lhs.hir_id == expr.hir_id {
+ +                            *state = if op.node == BinOpKind::Add
+ +                                && is_integer_const(self.cx, rhs, 1)
+ +                                && *state == IncrementVisitorVarState::Initial
+ +                                && self.depth == 0
+ +                            {
+ +                                IncrementVisitorVarState::IncrOnce
+ +                            } else {
+ +                                // Assigned some other value or assigned multiple times
+ +                                IncrementVisitorVarState::DontWarn
+ +                            };
+ +                        }
+ +                    },
+ +                    ExprKind::Assign(lhs, _, _) if lhs.hir_id == expr.hir_id => {
+ +                        *state = IncrementVisitorVarState::DontWarn;
+ +                    },
+ +                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+ +                        *state = IncrementVisitorVarState::DontWarn;
+ +                    },
+ +                    _ => (),
+ +                }
+ +            }
+ +
+ +            walk_expr(self, expr);
+ +        } else if is_loop(expr) || is_conditional(expr) {
+ +            self.depth += 1;
+ +            walk_expr(self, expr);
+ +            self.depth -= 1;
+ +        } else if let ExprKind::Continue(_) = expr.kind {
+ +            self.done = true;
+ +        } else {
+ +            walk_expr(self, expr);
+ +        }
+ +    }
+ +}
+ +
+ +enum InitializeVisitorState<'hir> {
+ +    Initial,                            // Not examined yet
+ +    Declared(Symbol, Option<Ty<'hir>>), // Declared but not (yet) initialized
+ +    Initialized {
+ +        name: Symbol,
+ +        ty: Option<Ty<'hir>>,
+ +        initializer: &'hir Expr<'hir>,
+ +    },
+ +    DontWarn,
+ +}
+ +
+ +/// Checks whether a variable is initialized at the start of a loop and not modified
+ +/// and used after the loop.
+ +pub(super) struct InitializeVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,  // context reference
+ +    end_expr: &'tcx Expr<'tcx>, // the for loop. Stop scanning here.
+ +    var_id: HirId,
+ +    state: InitializeVisitorState<'tcx>,
+ +    depth: u32, // depth of conditional expressions
+ +    past_loop: bool,
+ +}
+ +
+ +impl<'a, 'tcx> InitializeVisitor<'a, 'tcx> {
+ +    pub(super) fn new(cx: &'a LateContext<'tcx>, end_expr: &'tcx Expr<'tcx>, var_id: HirId) -> Self {
+ +        Self {
+ +            cx,
+ +            end_expr,
+ +            var_id,
+ +            state: InitializeVisitorState::Initial,
+ +            depth: 0,
+ +            past_loop: false,
+ +        }
+ +    }
+ +
+ +    pub(super) fn get_result(&self) -> Option<(Symbol, Option<Ty<'tcx>>, &'tcx Expr<'tcx>)> {
+ +        if let InitializeVisitorState::Initialized { name, ty, initializer } = self.state {
+ +            Some((name, ty, initializer))
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
+ +    type NestedFilter = nested_filter::OnlyBodies;
+ +
+ +    fn visit_local(&mut self, l: &'tcx Local<'_>) {
+ +        // Look for declarations of the variable
+ +        if_chain! {
+ +            if l.pat.hir_id == self.var_id;
+ +            if let PatKind::Binding(.., ident, _) = l.pat.kind;
+ +            then {
+ +                let ty = l.ty.map(|ty| hir_ty_to_ty(self.cx.tcx, ty));
+ +
+ +                self.state = l.init.map_or(InitializeVisitorState::Declared(ident.name, ty), |init| {
+ +                    InitializeVisitorState::Initialized {
+ +                        initializer: init,
+ +                        ty,
+ +                        name: ident.name,
+ +                    }
+ +                })
+ +            }
+ +        }
+ +
+ +        walk_local(self, l);
+ +    }
+ +
+ +    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+ +        if matches!(self.state, InitializeVisitorState::DontWarn) {
+ +            return;
+ +        }
+ +        if expr.hir_id == self.end_expr.hir_id {
+ +            self.past_loop = true;
+ +            return;
+ +        }
+ +        // No need to visit expressions before the variable is
+ +        // declared
+ +        if matches!(self.state, InitializeVisitorState::Initial) {
+ +            return;
+ +        }
+ +
+ +        // If node is the desired variable, see how it's used
+ +        if path_to_local_id(expr, self.var_id) {
+ +            if self.past_loop {
+ +                self.state = InitializeVisitorState::DontWarn;
+ +                return;
+ +            }
+ +
+ +            if let Some(parent) = get_parent_expr(self.cx, expr) {
+ +                match parent.kind {
+ +                    ExprKind::AssignOp(_, lhs, _) if lhs.hir_id == expr.hir_id => {
+ +                        self.state = InitializeVisitorState::DontWarn;
+ +                    },
+ +                    ExprKind::Assign(lhs, rhs, _) if lhs.hir_id == expr.hir_id => {
+ +                        self.state = if self.depth == 0 {
+ +                            match self.state {
+ +                                InitializeVisitorState::Declared(name, mut ty) => {
+ +                                    if ty.is_none() {
+ +                                        if let ExprKind::Lit(Spanned {
+ +                                            node: LitKind::Int(_, LitIntType::Unsuffixed),
+ +                                            ..
+ +                                        }) = rhs.kind
+ +                                        {
+ +                                            ty = None;
+ +                                        } else {
+ +                                            ty = self.cx.typeck_results().expr_ty_opt(rhs);
+ +                                        }
+ +                                    }
+ +
+ +                                    InitializeVisitorState::Initialized {
+ +                                        initializer: rhs,
+ +                                        ty,
+ +                                        name,
+ +                                    }
+ +                                },
+ +                                InitializeVisitorState::Initialized { ty, name, .. } => {
+ +                                    InitializeVisitorState::Initialized {
+ +                                        initializer: rhs,
+ +                                        ty,
+ +                                        name,
+ +                                    }
+ +                                },
+ +                                _ => InitializeVisitorState::DontWarn,
+ +                            }
+ +                        } else {
+ +                            InitializeVisitorState::DontWarn
+ +                        }
+ +                    },
+ +                    ExprKind::AddrOf(BorrowKind::Ref, mutability, _) if mutability == Mutability::Mut => {
+ +                        self.state = InitializeVisitorState::DontWarn;
+ +                    },
+ +                    _ => (),
+ +                }
+ +            }
+ +
+ +            walk_expr(self, expr);
+ +        } else if !self.past_loop && is_loop(expr) {
+ +            self.state = InitializeVisitorState::DontWarn;
+ +        } else if is_conditional(expr) {
+ +            self.depth += 1;
+ +            walk_expr(self, expr);
+ +            self.depth -= 1;
+ +        } else {
+ +            walk_expr(self, expr);
+ +        }
+ +    }
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +}
+ +
+ +fn is_loop(expr: &Expr<'_>) -> bool {
+ +    matches!(expr.kind, ExprKind::Loop(..))
+ +}
+ +
+ +fn is_conditional(expr: &Expr<'_>) -> bool {
+ +    matches!(expr.kind, ExprKind::If(..) | ExprKind::Match(..))
+ +}
+ +
+ +#[derive(PartialEq, Eq)]
+ +pub(super) enum Nesting {
+ +    Unknown,     // no nesting detected yet
+ +    RuledOut,    // the iterator is initialized or assigned within scope
+ +    LookFurther, // no nesting detected, no further walk required
+ +}
+ +
+ +use self::Nesting::{LookFurther, RuledOut, Unknown};
+ +
+ +pub(super) struct LoopNestVisitor {
+ +    pub(super) hir_id: HirId,
+ +    pub(super) iterator: HirId,
+ +    pub(super) nesting: Nesting,
+ +}
+ +
+ +impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
+ +    fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
+ +        if stmt.hir_id == self.hir_id {
+ +            self.nesting = LookFurther;
+ +        } else if self.nesting == Unknown {
+ +            walk_stmt(self, stmt);
+ +        }
+ +    }
+ +
+ +    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+ +        if self.nesting != Unknown {
+ +            return;
+ +        }
+ +        if expr.hir_id == self.hir_id {
+ +            self.nesting = LookFurther;
+ +            return;
+ +        }
+ +        match expr.kind {
+ +            ExprKind::Assign(path, _, _) | ExprKind::AssignOp(_, path, _) => {
+ +                if path_to_local_id(path, self.iterator) {
+ +                    self.nesting = RuledOut;
+ +                }
+ +            },
+ +            _ => walk_expr(self, expr),
+ +        }
+ +    }
+ +
+ +    fn visit_pat(&mut self, pat: &'tcx Pat<'_>) {
+ +        if self.nesting != Unknown {
+ +            return;
+ +        }
+ +        if let PatKind::Binding(_, id, ..) = pat.kind {
+ +            if id == self.iterator {
+ +                self.nesting = RuledOut;
+ +                return;
+ +            }
+ +        }
+ +        walk_pat(self, pat);
+ +    }
+ +}
+ +
+ +/// If `arg` was the argument to a `for` loop, return the "cleanest" way of writing the
+ +/// actual `Iterator` that the loop uses.
+ +pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic_ref: &mut Applicability) -> String {
+ +    let impls_iterator = cx.tcx.get_diagnostic_item(sym::Iterator).map_or(false, |id| {
+ +        implements_trait(cx, cx.typeck_results().expr_ty(arg), id, &[])
+ +    });
+ +    if impls_iterator {
+ +        format!(
+ +            "{}",
+ +            sugg::Sugg::hir_with_applicability(cx, arg, "_", applic_ref).maybe_par()
+ +        )
+ +    } else {
+ +        // (&x).into_iter() ==> x.iter()
+ +        // (&mut x).into_iter() ==> x.iter_mut()
-                     sugg::Sugg::hir_with_applicability(cx, arg_inner, "_", applic_ref).maybe_par(),
-                     meth_name,
++        let arg_ty = cx.typeck_results().expr_ty_adjusted(arg);
++        match &arg_ty.kind() {
++            ty::Ref(_, inner_ty, mutbl) if has_iter_method(cx, inner_ty).is_some() => {
++                let method_name = match mutbl {
+ +                    Mutability::Mut => "iter_mut",
+ +                    Mutability::Not => "iter",
+ +                };
++                let caller = match &arg.kind {
++                    ExprKind::AddrOf(BorrowKind::Ref, _, arg_inner) => arg_inner,
++                    _ => arg,
++                };
+ +                format!(
+ +                    "{}.{}()",
++                    sugg::Sugg::hir_with_applicability(cx, caller, "_", applic_ref).maybe_par(),
++                    method_name,
+ +                )
+ +            },
+ +            _ => format!(
+ +                "{}.into_iter()",
+ +                sugg::Sugg::hir_with_applicability(cx, arg, "_", applic_ref).maybe_par()
+ +            ),
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/matches/infalliable_detructuring_match.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..2472acb6f6e8b6f974fcf898010e45140bc021ff

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/infalliable_detructuring_match.rs
@@@ -1,0 -1,0 +1,44 @@@
++use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::source::snippet_with_applicability;
++use clippy_utils::{path_to_local_id, peel_blocks, strip_pat_refs};
++use rustc_errors::Applicability;
++use rustc_hir::{ExprKind, Local, MatchSource, PatKind, QPath};
++use rustc_lint::LateContext;
++
++use super::INFALLIBLE_DESTRUCTURING_MATCH;
++
++pub(crate) fn check(cx: &LateContext<'_>, local: &Local<'_>) -> bool {
++    if_chain! {
++        if !local.span.from_expansion();
++        if let Some(expr) = local.init;
++        if let ExprKind::Match(target, arms, MatchSource::Normal) = expr.kind;
++        if arms.len() == 1 && arms[0].guard.is_none();
++        if let PatKind::TupleStruct(
++            QPath::Resolved(None, variant_name), args, _) = arms[0].pat.kind;
++        if args.len() == 1;
++        if let PatKind::Binding(_, arg, ..) = strip_pat_refs(&args[0]).kind;
++        let body = peel_blocks(arms[0].body);
++        if path_to_local_id(body, arg);
++
++        then {
++            let mut applicability = Applicability::MachineApplicable;
++            span_lint_and_sugg(
++                cx,
++                INFALLIBLE_DESTRUCTURING_MATCH,
++                local.span,
++                "you seem to be trying to use `match` to destructure a single infallible pattern. \
++                Consider using `let`",
++                "try this",
++                format!(
++                    "let {}({}) = {};",
++                    snippet_with_applicability(cx, variant_name.span, "..", &mut applicability),
++                    snippet_with_applicability(cx, local.pat.span, "..", &mut applicability),
++                    snippet_with_applicability(cx, target.span, "..", &mut applicability),
++                ),
++                applicability,
++            );
++            return true;
++        }
++    }
++    false
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..d914eba01716b69e6fb182bcede18001c2e6f94b

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs
@@@ -1,0 -1,0 +1,85 @@@
++use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::source::snippet_with_applicability;
++use clippy_utils::{is_lang_ctor, peel_blocks};
++use rustc_errors::Applicability;
++use rustc_hir::{Arm, BindingAnnotation, Expr, ExprKind, LangItem, PatKind, QPath};
++use rustc_lint::LateContext;
++use rustc_middle::ty;
++
++use super::MATCH_AS_REF;
++
++pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
++    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
++        let arm_ref: Option<BindingAnnotation> = if is_none_arm(cx, &arms[0]) {
++            is_ref_some_arm(cx, &arms[1])
++        } else if is_none_arm(cx, &arms[1]) {
++            is_ref_some_arm(cx, &arms[0])
++        } else {
++            None
++        };
++        if let Some(rb) = arm_ref {
++            let suggestion = if rb == BindingAnnotation::Ref {
++                "as_ref"
++            } else {
++                "as_mut"
++            };
++
++            let output_ty = cx.typeck_results().expr_ty(expr);
++            let input_ty = cx.typeck_results().expr_ty(ex);
++
++            let cast = if_chain! {
++                if let ty::Adt(_, substs) = input_ty.kind();
++                let input_ty = substs.type_at(0);
++                if let ty::Adt(_, substs) = output_ty.kind();
++                let output_ty = substs.type_at(0);
++                if let ty::Ref(_, output_ty, _) = *output_ty.kind();
++                if input_ty != output_ty;
++                then {
++                    ".map(|x| x as _)"
++                } else {
++                    ""
++                }
++            };
++
++            let mut applicability = Applicability::MachineApplicable;
++            span_lint_and_sugg(
++                cx,
++                MATCH_AS_REF,
++                expr.span,
++                &format!("use `{}()` instead", suggestion),
++                "try this",
++                format!(
++                    "{}.{}(){}",
++                    snippet_with_applicability(cx, ex.span, "_", &mut applicability),
++                    suggestion,
++                    cast,
++                ),
++                applicability,
++            );
++        }
++    }
++}
++
++// Checks if arm has the form `None => None`
++fn is_none_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
++    matches!(arm.pat.kind, PatKind::Path(ref qpath) if is_lang_ctor(cx, qpath, LangItem::OptionNone))
++}
++
++// Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
++fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<BindingAnnotation> {
++    if_chain! {
++        if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind;
++        if is_lang_ctor(cx, qpath, LangItem::OptionSome);
++        if let PatKind::Binding(rb, .., ident, _) = first_pat.kind;
++        if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
++        if let ExprKind::Call(e, args) = peel_blocks(arm.body).kind;
++        if let ExprKind::Path(ref some_path) = e.kind;
++        if is_lang_ctor(cx, some_path, LangItem::OptionSome) && args.len() == 1;
++        if let ExprKind::Path(QPath::Resolved(_, path2)) = args[0].kind;
++        if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
++        then {
++            return Some(rb)
++        }
++    }
++    None
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_bool.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..90c50b994d2bfe11245881843feef728b1829ad5

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_bool.rs
@@@ -1,0 -1,0 +1,75 @@@
++use clippy_utils::diagnostics::span_lint_and_then;
++use clippy_utils::is_unit_expr;
++use clippy_utils::source::{expr_block, snippet};
++use clippy_utils::sugg::Sugg;
++use rustc_ast::LitKind;
++use rustc_errors::Applicability;
++use rustc_hir::{Arm, Expr, ExprKind, PatKind};
++use rustc_lint::LateContext;
++use rustc_middle::ty;
++
++use super::MATCH_BOOL;
++
++pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
++    // Type of expression is `bool`.
++    if *cx.typeck_results().expr_ty(ex).kind() == ty::Bool {
++        span_lint_and_then(
++            cx,
++            MATCH_BOOL,
++            expr.span,
++            "you seem to be trying to match on a boolean expression",
++            move |diag| {
++                if arms.len() == 2 {
++                    // no guards
++                    let exprs = if let PatKind::Lit(arm_bool) = arms[0].pat.kind {
++                        if let ExprKind::Lit(ref lit) = arm_bool.kind {
++                            match lit.node {
++                                LitKind::Bool(true) => Some((&*arms[0].body, &*arms[1].body)),
++                                LitKind::Bool(false) => Some((&*arms[1].body, &*arms[0].body)),
++                                _ => None,
++                            }
++                        } else {
++                            None
++                        }
++                    } else {
++                        None
++                    };
++
++                    if let Some((true_expr, false_expr)) = exprs {
++                        let sugg = match (is_unit_expr(true_expr), is_unit_expr(false_expr)) {
++                            (false, false) => Some(format!(
++                                "if {} {} else {}",
++                                snippet(cx, ex.span, "b"),
++                                expr_block(cx, true_expr, None, "..", Some(expr.span)),
++                                expr_block(cx, false_expr, None, "..", Some(expr.span))
++                            )),
++                            (false, true) => Some(format!(
++                                "if {} {}",
++                                snippet(cx, ex.span, "b"),
++                                expr_block(cx, true_expr, None, "..", Some(expr.span))
++                            )),
++                            (true, false) => {
++                                let test = Sugg::hir(cx, ex, "..");
++                                Some(format!(
++                                    "if {} {}",
++                                    !test,
++                                    expr_block(cx, false_expr, None, "..", Some(expr.span))
++                                ))
++                            },
++                            (true, true) => None,
++                        };
++
++                        if let Some(sugg) = sugg {
++                            diag.span_suggestion(
++                                expr.span,
++                                "consider using an `if`/`else` expression",
++                                sugg,
++                                Applicability::HasPlaceholders,
++                            );
++                        }
++                    }
++                }
++            },
++        );
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..d605b6d73c09d8b9684e4d2b83a76a91a19b82f2

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs
@@@ -1,0 -1,0 +1,166 @@@
++use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::source::snippet_with_applicability;
++use clippy_utils::{higher, is_wild};
++use rustc_ast::{Attribute, LitKind};
++use rustc_errors::Applicability;
++use rustc_hir::{BorrowKind, Expr, ExprKind, Guard, MatchSource, Pat};
++use rustc_lint::LateContext;
++use rustc_middle::ty;
++use rustc_span::source_map::Spanned;
++
++use super::MATCH_LIKE_MATCHES_MACRO;
++
++/// Lint a `match` or `if let .. { .. } else { .. }` expr that could be replaced by `matches!`
++pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
++    if let Some(higher::IfLet {
++        let_pat,
++        let_expr,
++        if_then,
++        if_else: Some(if_else),
++    }) = higher::IfLet::hir(cx, expr)
++    {
++        return find_matches_sugg(
++            cx,
++            let_expr,
++            IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
++            expr,
++            true,
++        );
++    }
++
++    if let ExprKind::Match(scrut, arms, MatchSource::Normal) = expr.kind {
++        return find_matches_sugg(
++            cx,
++            scrut,
++            arms.iter().map(|arm| {
++                (
++                    cx.tcx.hir().attrs(arm.hir_id),
++                    Some(arm.pat),
++                    arm.body,
++                    arm.guard.as_ref(),
++                )
++            }),
++            expr,
++            false,
++        );
++    }
++
++    false
++}
++
++/// Lint a `match` or `if let` for replacement by `matches!`
++fn find_matches_sugg<'a, 'b, I>(
++    cx: &LateContext<'_>,
++    ex: &Expr<'_>,
++    mut iter: I,
++    expr: &Expr<'_>,
++    is_if_let: bool,
++) -> bool
++where
++    'b: 'a,
++    I: Clone
++        + DoubleEndedIterator
++        + ExactSizeIterator
++        + Iterator<
++            Item = (
++                &'a [Attribute],
++                Option<&'a Pat<'b>>,
++                &'a Expr<'b>,
++                Option<&'a Guard<'b>>,
++            ),
++        >,
++{
++    if_chain! {
++        if iter.len() >= 2;
++        if cx.typeck_results().expr_ty(expr).is_bool();
++        if let Some((_, last_pat_opt, last_expr, _)) = iter.next_back();
++        let iter_without_last = iter.clone();
++        if let Some((first_attrs, _, first_expr, first_guard)) = iter.next();
++        if let Some(b0) = find_bool_lit(&first_expr.kind, is_if_let);
++        if let Some(b1) = find_bool_lit(&last_expr.kind, is_if_let);
++        if b0 != b1;
++        if first_guard.is_none() || iter.len() == 0;
++        if first_attrs.is_empty();
++        if iter
++            .all(|arm| {
++                find_bool_lit(&arm.2.kind, is_if_let).map_or(false, |b| b == b0) && arm.3.is_none() && arm.0.is_empty()
++            });
++        then {
++            if let Some(last_pat) = last_pat_opt {
++                if !is_wild(last_pat) {
++                    return false;
++                }
++            }
++
++            // The suggestion may be incorrect, because some arms can have `cfg` attributes
++            // evaluated into `false` and so such arms will be stripped before.
++            let mut applicability = Applicability::MaybeIncorrect;
++            let pat = {
++                use itertools::Itertools as _;
++                iter_without_last
++                    .filter_map(|arm| {
++                        let pat_span = arm.1?.span;
++                        Some(snippet_with_applicability(cx, pat_span, "..", &mut applicability))
++                    })
++                    .join(" | ")
++            };
++            let pat_and_guard = if let Some(Guard::If(g)) = first_guard {
++                format!("{} if {}", pat, snippet_with_applicability(cx, g.span, "..", &mut applicability))
++            } else {
++                pat
++            };
++
++            // strip potential borrows (#6503), but only if the type is a reference
++            let mut ex_new = ex;
++            if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = ex.kind {
++                if let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() {
++                    ex_new = ex_inner;
++                }
++            };
++            span_lint_and_sugg(
++                cx,
++                MATCH_LIKE_MATCHES_MACRO,
++                expr.span,
++                &format!("{} expression looks like `matches!` macro", if is_if_let { "if let .. else" } else { "match" }),
++                "try this",
++                format!(
++                    "{}matches!({}, {})",
++                    if b0 { "" } else { "!" },
++                    snippet_with_applicability(cx, ex_new.span, "..", &mut applicability),
++                    pat_and_guard,
++                ),
++                applicability,
++            );
++            true
++        } else {
++            false
++        }
++    }
++}
++
++/// Extract a `bool` or `{ bool }`
++fn find_bool_lit(ex: &ExprKind<'_>, is_if_let: bool) -> Option<bool> {
++    match ex {
++        ExprKind::Lit(Spanned {
++            node: LitKind::Bool(b), ..
++        }) => Some(*b),
++        ExprKind::Block(
++            rustc_hir::Block {
++                stmts: &[],
++                expr: Some(exp),
++                ..
++            },
++            _,
++        ) if is_if_let => {
++            if let ExprKind::Lit(Spanned {
++                node: LitKind::Bool(b), ..
++            }) = exp.kind
++            {
++                Some(b)
++            } else {
++                None
++            }
++        },
++        _ => None,
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..80f964ba1b72c4a246f24ee264d3ce5a508276d4

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs
@@@ -1,0 -1,0 +1,66 @@@
++use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
++use clippy_utils::source::snippet;
++use clippy_utils::sugg::Sugg;
++use core::iter::once;
++use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
++use rustc_lint::LateContext;
++
++use super::MATCH_REF_PATS;
++
++pub(crate) fn check<'a, 'b, I>(cx: &LateContext<'_>, ex: &Expr<'_>, pats: I, expr: &Expr<'_>)
++where
++    'b: 'a,
++    I: Clone + Iterator<Item = &'a Pat<'b>>,
++{
++    if !has_multiple_ref_pats(pats.clone()) {
++        return;
++    }
++
++    let (first_sugg, msg, title);
++    let span = ex.span.source_callsite();
++    if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, inner) = ex.kind {
++        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, inner, "..").to_string()));
++        msg = "try";
++        title = "you don't need to add `&` to both the expression and the patterns";
++    } else {
++        first_sugg = once((span, Sugg::hir_with_macro_callsite(cx, ex, "..").deref().to_string()));
++        msg = "instead of prefixing all patterns with `&`, you can dereference the expression";
++        title = "you don't need to add `&` to all patterns";
++    }
++
++    let remaining_suggs = pats.filter_map(|pat| {
++        if let PatKind::Ref(refp, _) = pat.kind {
++            Some((pat.span, snippet(cx, refp.span, "..").to_string()))
++        } else {
++            None
++        }
++    });
++
++    span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
++        if !expr.span.from_expansion() {
++            multispan_sugg(diag, msg, first_sugg.chain(remaining_suggs));
++        }
++    });
++}
++
++fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool
++where
++    'b: 'a,
++    I: Iterator<Item = &'a Pat<'b>>,
++{
++    let mut ref_count = 0;
++    for opt in pats.map(|pat| match pat.kind {
++        PatKind::Ref(..) => Some(true), // &-patterns
++        PatKind::Wild => Some(false),   // an "anything" wildcard is also fine
++        _ => None,                      // any other pattern is not fine
++    }) {
++        if let Some(inner) = opt {
++            if inner {
++                ref_count += 1;
++            }
++        } else {
++            return false;
++        }
++    }
++    ref_count > 1
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..271a386859555040a8c43990020700447e7b9c9e

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
@@@ -1,0 -1,0 +1,111 @@@
++use clippy_utils::diagnostics::span_lint_and_then;
++use clippy_utils::source::snippet;
++use clippy_utils::{path_to_local, search_same, SpanlessEq, SpanlessHash};
++use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdSet, MatchSource, Pat, PatKind};
++use rustc_lint::LateContext;
++use std::collections::hash_map::Entry;
++
++use super::MATCH_SAME_ARMS;
++
++pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) {
++    if let ExprKind::Match(_, arms, MatchSource::Normal) = expr.kind {
++        let hash = |&(_, arm): &(usize, &Arm<'_>)| -> u64 {
++            let mut h = SpanlessHash::new(cx);
++            h.hash_expr(arm.body);
++            h.finish()
++        };
++
++        let eq = |&(lindex, lhs): &(usize, &Arm<'_>), &(rindex, rhs): &(usize, &Arm<'_>)| -> bool {
++            let min_index = usize::min(lindex, rindex);
++            let max_index = usize::max(lindex, rindex);
++
++            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
++            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
++                if_chain! {
++                    if let Some(a_id) = path_to_local(a);
++                    if let Some(b_id) = path_to_local(b);
++                    let entry = match local_map.entry(a_id) {
++                        Entry::Vacant(entry) => entry,
++                        // check if using the same bindings as before
++                        Entry::Occupied(entry) => return *entry.get() == b_id,
++                    };
++                    // the names technically don't have to match; this makes the lint more conservative
++                    if cx.tcx.hir().name(a_id) == cx.tcx.hir().name(b_id);
++                    if cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b);
++                    if pat_contains_local(lhs.pat, a_id);
++                    if pat_contains_local(rhs.pat, b_id);
++                    then {
++                        entry.insert(b_id);
++                        true
++                    } else {
++                        false
++                    }
++                }
++            };
++            // Arms with a guard are ignored, those can’t always be merged together
++            // This is also the case for arms in-between each there is an arm with a guard
++            (min_index..=max_index).all(|index| arms[index].guard.is_none())
++                && SpanlessEq::new(cx)
++                    .expr_fallback(eq_fallback)
++                    .eq_expr(lhs.body, rhs.body)
++                // these checks could be removed to allow unused bindings
++                && bindings_eq(lhs.pat, local_map.keys().copied().collect())
++                && bindings_eq(rhs.pat, local_map.values().copied().collect())
++        };
++
++        let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
++        for (&(_, i), &(_, j)) in search_same(&indexed_arms, hash, eq) {
++            span_lint_and_then(
++                cx,
++                MATCH_SAME_ARMS,
++                j.body.span,
++                "this `match` has identical arm bodies",
++                |diag| {
++                    diag.span_note(i.body.span, "same as this");
++
++                    // Note: this does not use `span_suggestion` on purpose:
++                    // there is no clean way
++                    // to remove the other arm. Building a span and suggest to replace it to ""
++                    // makes an even more confusing error message. Also in order not to make up a
++                    // span for the whole pattern, the suggestion is only shown when there is only
++                    // one pattern. The user should know about `|` if they are already using it…
++
++                    let lhs = snippet(cx, i.pat.span, "<pat1>");
++                    let rhs = snippet(cx, j.pat.span, "<pat2>");
++
++                    if let PatKind::Wild = j.pat.kind {
++                        // if the last arm is _, then i could be integrated into _
++                        // note that i.pat cannot be _, because that would mean that we're
++                        // hiding all the subsequent arms, and rust won't compile
++                        diag.span_note(
++                            i.body.span,
++                            &format!(
++                                "`{}` has the same arm body as the `_` wildcard, consider removing it",
++                                lhs
++                            ),
++                        );
++                    } else {
++                        diag.span_help(i.pat.span, &format!("consider refactoring into `{} | {}`", lhs, rhs,))
++                            .help("...or consider changing the match arm bodies");
++                    }
++                },
++            );
++        }
++    }
++}
++
++fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
++    let mut result = false;
++    pat.walk_short(|p| {
++        result |= matches!(p.kind, PatKind::Binding(_, binding_id, ..) if binding_id == id);
++        !result
++    });
++    result
++}
++
++/// Returns true if all the bindings in the `Pat` are in `ids` and vice versa
++fn bindings_eq(pat: &Pat<'_>, mut ids: HirIdSet) -> bool {
++    let mut result = true;
++    pat.each_binding_or_first(&mut |_, id, _, _| result &= ids.remove(&id));
++    result && ids.is_empty()
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_single_binding.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..8ae19e03f1a6a5afbfb1016ebd066c4da9d76d0c

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_single_binding.rs
@@@ -1,0 -1,0 +1,166 @@@
++use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::source::{indent_of, snippet_block, snippet_opt, snippet_with_applicability};
++use clippy_utils::sugg::Sugg;
++use clippy_utils::{get_parent_expr, is_refutable, peel_blocks};
++use rustc_errors::Applicability;
++use rustc_hir::{Arm, Expr, ExprKind, Local, Node, PatKind};
++use rustc_lint::LateContext;
++
++use super::MATCH_SINGLE_BINDING;
++
++#[allow(clippy::too_many_lines)]
++pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm<'_>], expr: &Expr<'_>) {
++    if expr.span.from_expansion() || arms.len() != 1 || is_refutable(cx, arms[0].pat) {
++        return;
++    }
++
++    // HACK:
++    // This is a hack to deal with arms that are excluded by macros like `#[cfg]`. It is only used here
++    // to prevent false positives as there is currently no better way to detect if code was excluded by
++    // a macro. See PR #6435
++    if_chain! {
++        if let Some(match_snippet) = snippet_opt(cx, expr.span);
++        if let Some(arm_snippet) = snippet_opt(cx, arms[0].span);
++        if let Some(ex_snippet) = snippet_opt(cx, ex.span);
++        let rest_snippet = match_snippet.replace(&arm_snippet, "").replace(&ex_snippet, "");
++        if rest_snippet.contains("=>");
++        then {
++            // The code it self contains another thick arrow "=>"
++            // -> Either another arm or a comment
++            return;
++        }
++    }
++
++    let matched_vars = ex.span;
++    let bind_names = arms[0].pat.span;
++    let match_body = peel_blocks(arms[0].body);
++    let mut snippet_body = if match_body.span.from_expansion() {
++        Sugg::hir_with_macro_callsite(cx, match_body, "..").to_string()
++    } else {
++        snippet_block(cx, match_body.span, "..", Some(expr.span)).to_string()
++    };
++
++    // Do we need to add ';' to suggestion ?
++    match match_body.kind {
++        ExprKind::Block(block, _) => {
++            // macro + expr_ty(body) == ()
++            if block.span.from_expansion() && cx.typeck_results().expr_ty(match_body).is_unit() {
++                snippet_body.push(';');
++            }
++        },
++        _ => {
++            // expr_ty(body) == ()
++            if cx.typeck_results().expr_ty(match_body).is_unit() {
++                snippet_body.push(';');
++            }
++        },
++    }
++
++    let mut applicability = Applicability::MaybeIncorrect;
++    match arms[0].pat.kind {
++        PatKind::Binding(..) | PatKind::Tuple(_, _) | PatKind::Struct(..) => {
++            // If this match is in a local (`let`) stmt
++            let (target_span, sugg) = if let Some(parent_let_node) = opt_parent_let(cx, ex) {
++                (
++                    parent_let_node.span,
++                    format!(
++                        "let {} = {};\n{}let {} = {};",
++                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
++                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
++                        " ".repeat(indent_of(cx, expr.span).unwrap_or(0)),
++                        snippet_with_applicability(cx, parent_let_node.pat.span, "..", &mut applicability),
++                        snippet_body
++                    ),
++                )
++            } else {
++                // If we are in closure, we need curly braces around suggestion
++                let mut indent = " ".repeat(indent_of(cx, ex.span).unwrap_or(0));
++                let (mut cbrace_start, mut cbrace_end) = ("".to_string(), "".to_string());
++                if let Some(parent_expr) = get_parent_expr(cx, expr) {
++                    if let ExprKind::Closure(..) = parent_expr.kind {
++                        cbrace_end = format!("\n{}}}", indent);
++                        // Fix body indent due to the closure
++                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
++                        cbrace_start = format!("{{\n{}", indent);
++                    }
++                }
++                // If the parent is already an arm, and the body is another match statement,
++                // we need curly braces around suggestion
++                let parent_node_id = cx.tcx.hir().get_parent_node(expr.hir_id);
++                if let Node::Arm(arm) = &cx.tcx.hir().get(parent_node_id) {
++                    if let ExprKind::Match(..) = arm.body.kind {
++                        cbrace_end = format!("\n{}}}", indent);
++                        // Fix body indent due to the match
++                        indent = " ".repeat(indent_of(cx, bind_names).unwrap_or(0));
++                        cbrace_start = format!("{{\n{}", indent);
++                    }
++                }
++                (
++                    expr.span,
++                    format!(
++                        "{}let {} = {};\n{}{}{}",
++                        cbrace_start,
++                        snippet_with_applicability(cx, bind_names, "..", &mut applicability),
++                        snippet_with_applicability(cx, matched_vars, "..", &mut applicability),
++                        indent,
++                        snippet_body,
++                        cbrace_end
++                    ),
++                )
++            };
++            span_lint_and_sugg(
++                cx,
++                MATCH_SINGLE_BINDING,
++                target_span,
++                "this match could be written as a `let` statement",
++                "consider using `let` statement",
++                sugg,
++                applicability,
++            );
++        },
++        PatKind::Wild => {
++            if ex.can_have_side_effects() {
++                let indent = " ".repeat(indent_of(cx, expr.span).unwrap_or(0));
++                let sugg = format!(
++                    "{};\n{}{}",
++                    snippet_with_applicability(cx, ex.span, "..", &mut applicability),
++                    indent,
++                    snippet_body
++                );
++                span_lint_and_sugg(
++                    cx,
++                    MATCH_SINGLE_BINDING,
++                    expr.span,
++                    "this match could be replaced by its scrutinee and body",
++                    "consider using the scrutinee and body instead",
++                    sugg,
++                    applicability,
++                );
++            } else {
++                span_lint_and_sugg(
++                    cx,
++                    MATCH_SINGLE_BINDING,
++                    expr.span,
++                    "this match could be replaced by its body itself",
++                    "consider using the match body instead",
++                    snippet_body,
++                    Applicability::MachineApplicable,
++                );
++            }
++        },
++        _ => (),
++    }
++}
++
++/// Returns true if the `ex` match expression is in a local (`let`) statement
++fn opt_parent_let<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Option<&'a Local<'a>> {
++    let map = &cx.tcx.hir();
++    if_chain! {
++        if let Some(Node::Expr(parent_arm_expr)) = map.find(map.get_parent_node(ex.hir_id));
++        if let Some(Node::Local(parent_let_expr)) = map.find(map.get_parent_node(parent_arm_expr.hir_id));
++        then {
++            return Some(parent_let_expr);
++        }
++    }
++    None
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..3515286d5b4af8e45596abfc7dd98ce51a1b2521

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs
@@@ -1,0 -1,0 +1,198 @@@
++use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::ty::is_type_diagnostic_item;
++use clippy_utils::{is_refutable, peel_hir_pat_refs, recurse_or_patterns};
++use rustc_errors::Applicability;
++use rustc_hir::def::{CtorKind, DefKind, Res};
++use rustc_hir::{Arm, Expr, PatKind, PathSegment, QPath, Ty, TyKind};
++use rustc_lint::LateContext;
++use rustc_middle::ty::{self, VariantDef};
++use rustc_span::sym;
++
++use super::{MATCH_WILDCARD_FOR_SINGLE_VARIANTS, WILDCARD_ENUM_MATCH_ARM};
++
++#[allow(clippy::too_many_lines)]
++pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
++    let ty = cx.typeck_results().expr_ty(ex).peel_refs();
++    let adt_def = match ty.kind() {
++        ty::Adt(adt_def, _)
++            if adt_def.is_enum()
++                && !(is_type_diagnostic_item(cx, ty, sym::Option) || is_type_diagnostic_item(cx, ty, sym::Result)) =>
++        {
++            adt_def
++        },
++        _ => return,
++    };
++
++    // First pass - check for violation, but don't do much book-keeping because this is hopefully
++    // the uncommon case, and the book-keeping is slightly expensive.
++    let mut wildcard_span = None;
++    let mut wildcard_ident = None;
++    let mut has_non_wild = false;
++    for arm in arms {
++        match peel_hir_pat_refs(arm.pat).0.kind {
++            PatKind::Wild => wildcard_span = Some(arm.pat.span),
++            PatKind::Binding(_, _, ident, None) => {
++                wildcard_span = Some(arm.pat.span);
++                wildcard_ident = Some(ident);
++            },
++            _ => has_non_wild = true,
++        }
++    }
++    let wildcard_span = match wildcard_span {
++        Some(x) if has_non_wild => x,
++        _ => return,
++    };
++
++    // Accumulate the variants which should be put in place of the wildcard because they're not
++    // already covered.
++    let has_hidden = adt_def.variants.iter().any(|x| is_hidden(cx, x));
++    let mut missing_variants: Vec<_> = adt_def.variants.iter().filter(|x| !is_hidden(cx, x)).collect();
++
++    let mut path_prefix = CommonPrefixSearcher::None;
++    for arm in arms {
++        // Guards mean that this case probably isn't exhaustively covered. Technically
++        // this is incorrect, as we should really check whether each variant is exhaustively
++        // covered by the set of guards that cover it, but that's really hard to do.
++        recurse_or_patterns(arm.pat, |pat| {
++            let path = match &peel_hir_pat_refs(pat).0.kind {
++                PatKind::Path(path) => {
++                    #[allow(clippy::match_same_arms)]
++                    let id = match cx.qpath_res(path, pat.hir_id) {
++                        Res::Def(
++                            DefKind::Const | DefKind::ConstParam | DefKind::AnonConst | DefKind::InlineConst,
++                            _,
++                        ) => return,
++                        Res::Def(_, id) => id,
++                        _ => return,
++                    };
++                    if arm.guard.is_none() {
++                        missing_variants.retain(|e| e.ctor_def_id != Some(id));
++                    }
++                    path
++                },
++                PatKind::TupleStruct(path, patterns, ..) => {
++                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
++                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p)) {
++                            missing_variants.retain(|e| e.ctor_def_id != Some(id));
++                        }
++                    }
++                    path
++                },
++                PatKind::Struct(path, patterns, ..) => {
++                    if let Some(id) = cx.qpath_res(path, pat.hir_id).opt_def_id() {
++                        if arm.guard.is_none() && patterns.iter().all(|p| !is_refutable(cx, p.pat)) {
++                            missing_variants.retain(|e| e.def_id != id);
++                        }
++                    }
++                    path
++                },
++                _ => return,
++            };
++            match path {
++                QPath::Resolved(_, path) => path_prefix.with_path(path.segments),
++                QPath::TypeRelative(
++                    Ty {
++                        kind: TyKind::Path(QPath::Resolved(_, path)),
++                        ..
++                    },
++                    _,
++                ) => path_prefix.with_prefix(path.segments),
++                _ => (),
++            }
++        });
++    }
++
++    let format_suggestion = |variant: &VariantDef| {
++        format!(
++            "{}{}{}{}",
++            if let Some(ident) = wildcard_ident {
++                format!("{} @ ", ident.name)
++            } else {
++                String::new()
++            },
++            if let CommonPrefixSearcher::Path(path_prefix) = path_prefix {
++                let mut s = String::new();
++                for seg in path_prefix {
++                    s.push_str(seg.ident.as_str());
++                    s.push_str("::");
++                }
++                s
++            } else {
++                let mut s = cx.tcx.def_path_str(adt_def.did);
++                s.push_str("::");
++                s
++            },
++            variant.name,
++            match variant.ctor_kind {
++                CtorKind::Fn if variant.fields.len() == 1 => "(_)",
++                CtorKind::Fn => "(..)",
++                CtorKind::Const => "",
++                CtorKind::Fictive => "{ .. }",
++            }
++        )
++    };
++
++    match missing_variants.as_slice() {
++        [] => (),
++        [x] if !adt_def.is_variant_list_non_exhaustive() && !has_hidden => span_lint_and_sugg(
++            cx,
++            MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
++            wildcard_span,
++            "wildcard matches only a single variant and will also match any future added variants",
++            "try this",
++            format_suggestion(x),
++            Applicability::MaybeIncorrect,
++        ),
++        variants => {
++            let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
++            let message = if adt_def.is_variant_list_non_exhaustive() || has_hidden {
++                suggestions.push("_".into());
++                "wildcard matches known variants and will also match future added variants"
++            } else {
++                "wildcard match will also match any future added variants"
++            };
++
++            span_lint_and_sugg(
++                cx,
++                WILDCARD_ENUM_MATCH_ARM,
++                wildcard_span,
++                message,
++                "try this",
++                suggestions.join(" | "),
++                Applicability::MaybeIncorrect,
++            );
++        },
++    };
++}
++
++enum CommonPrefixSearcher<'a> {
++    None,
++    Path(&'a [PathSegment<'a>]),
++    Mixed,
++}
++impl<'a> CommonPrefixSearcher<'a> {
++    fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
++        match path {
++            [path @ .., _] => self.with_prefix(path),
++            [] => (),
++        }
++    }
++
++    fn with_prefix(&mut self, path: &'a [PathSegment<'a>]) {
++        match self {
++            Self::None => *self = Self::Path(path),
++            Self::Path(self_path)
++                if path
++                    .iter()
++                    .map(|p| p.ident.name)
++                    .eq(self_path.iter().map(|p| p.ident.name)) => {},
++            Self::Path(_) => *self = Self::Mixed,
++            Self::Mixed => (),
++        }
++    }
++}
++
++fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {
++    let attrs = cx.tcx.get_attrs(variant_def.def_id);
++    clippy_utils::attrs::is_doc_hidden(attrs) || clippy_utils::attrs::is_unstable(attrs)
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..bc16f17b6196e420184860ce3dd731f9eeeebdbe

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
@@@ -1,0 -1,0 +1,51 @@@
++use clippy_utils::diagnostics::span_lint_and_note;
++use clippy_utils::macros::{is_panic, root_macro_call};
++use clippy_utils::ty::is_type_diagnostic_item;
++use clippy_utils::visitors::is_local_used;
++use clippy_utils::{is_wild, peel_blocks_with_stmt};
++use rustc_hir::{Arm, Expr, PatKind};
++use rustc_lint::LateContext;
++use rustc_span::symbol::{kw, sym};
++
++use super::MATCH_WILD_ERR_ARM;
++
++pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
++    let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs();
++    if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
++        for arm in arms {
++            if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
++                let path_str = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| s.print_qpath(path, false));
++                if path_str == "Err" {
++                    let mut matching_wild = inner.iter().any(is_wild);
++                    let mut ident_bind_name = kw::Underscore;
++                    if !matching_wild {
++                        // Looking for unused bindings (i.e.: `_e`)
++                        for pat in inner.iter() {
++                            if let PatKind::Binding(_, id, ident, None) = pat.kind {
++                                if ident.as_str().starts_with('_') && !is_local_used(cx, arm.body, id) {
++                                    ident_bind_name = ident.name;
++                                    matching_wild = true;
++                                }
++                            }
++                        }
++                    }
++                    if_chain! {
++                        if matching_wild;
++                        if let Some(macro_call) = root_macro_call(peel_blocks_with_stmt(arm.body).span);
++                        if is_panic(cx, macro_call.def_id);
++                        then {
++                            // `Err(_)` or `Err(_e)` arm with `panic!` found
++                            span_lint_and_note(cx,
++                                MATCH_WILD_ERR_ARM,
++                                arm.pat.span,
++                                &format!("`Err({})` matches all errors", ident_bind_name),
++                                None,
++                                "match each error separately or use the error output, or use `.except(msg)` if the error case is unreachable",
++                            );
++                        }
++                    }
++                }
++            }
++        }
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/mod.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..b5ee4561f06eceeb346ea5f648adf7357ddb9ea6

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/mod.rs
@@@ -1,0 -1,0 +1,646 @@@
++use clippy_utils::{meets_msrv, msrvs};
++use rustc_hir::{Expr, ExprKind, Local, MatchSource, Pat};
++use rustc_lint::{LateContext, LateLintPass};
++use rustc_semver::RustcVersion;
++use rustc_session::{declare_tool_lint, impl_lint_pass};
++
++mod infalliable_detructuring_match;
++mod match_as_ref;
++mod match_bool;
++mod match_like_matches;
++mod match_ref_pats;
++mod match_same_arms;
++mod match_single_binding;
++mod match_wild_enum;
++mod match_wild_err_arm;
++mod overlapping_arms;
++mod redundant_pattern_match;
++mod rest_pat_in_fully_bound_struct;
++mod single_match;
++mod wild_in_or_pats;
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for matches with a single arm where an `if let`
++    /// will usually suffice.
++    ///
++    /// ### Why is this bad?
++    /// Just readability – `if let` nests less than a `match`.
++    ///
++    /// ### Example
++    /// ```rust
++    /// # fn bar(stool: &str) {}
++    /// # let x = Some("abc");
++    /// // Bad
++    /// match x {
++    ///     Some(ref foo) => bar(foo),
++    ///     _ => (),
++    /// }
++    ///
++    /// // Good
++    /// if let Some(ref foo) = x {
++    ///     bar(foo);
++    /// }
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub SINGLE_MATCH,
++    style,
++    "a `match` statement with a single nontrivial arm (i.e., where the other arm is `_ => {}`) instead of `if let`"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for matches with two arms where an `if let else` will
++    /// usually suffice.
++    ///
++    /// ### Why is this bad?
++    /// Just readability – `if let` nests less than a `match`.
++    ///
++    /// ### Known problems
++    /// Personal style preferences may differ.
++    ///
++    /// ### Example
++    /// Using `match`:
++    ///
++    /// ```rust
++    /// # fn bar(foo: &usize) {}
++    /// # let other_ref: usize = 1;
++    /// # let x: Option<&usize> = Some(&1);
++    /// match x {
++    ///     Some(ref foo) => bar(foo),
++    ///     _ => bar(&other_ref),
++    /// }
++    /// ```
++    ///
++    /// Using `if let` with `else`:
++    ///
++    /// ```rust
++    /// # fn bar(foo: &usize) {}
++    /// # let other_ref: usize = 1;
++    /// # let x: Option<&usize> = Some(&1);
++    /// if let Some(ref foo) = x {
++    ///     bar(foo);
++    /// } else {
++    ///     bar(&other_ref);
++    /// }
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub SINGLE_MATCH_ELSE,
++    pedantic,
++    "a `match` statement with two arms where the second arm's pattern is a placeholder instead of a specific match pattern"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for matches where all arms match a reference,
++    /// suggesting to remove the reference and deref the matched expression
++    /// instead. It also checks for `if let &foo = bar` blocks.
++    ///
++    /// ### Why is this bad?
++    /// It just makes the code less readable. That reference
++    /// destructuring adds nothing to the code.
++    ///
++    /// ### Example
++    /// ```rust,ignore
++    /// // Bad
++    /// match x {
++    ///     &A(ref y) => foo(y),
++    ///     &B => bar(),
++    ///     _ => frob(&x),
++    /// }
++    ///
++    /// // Good
++    /// match *x {
++    ///     A(ref y) => foo(y),
++    ///     B => bar(),
++    ///     _ => frob(x),
++    /// }
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub MATCH_REF_PATS,
++    style,
++    "a `match` or `if let` with all arms prefixed with `&` instead of deref-ing the match expression"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for matches where match expression is a `bool`. It
++    /// suggests to replace the expression with an `if...else` block.
++    ///
++    /// ### Why is this bad?
++    /// It makes the code less readable.
++    ///
++    /// ### Example
++    /// ```rust
++    /// # fn foo() {}
++    /// # fn bar() {}
++    /// let condition: bool = true;
++    /// match condition {
++    ///     true => foo(),
++    ///     false => bar(),
++    /// }
++    /// ```
++    /// Use if/else instead:
++    /// ```rust
++    /// # fn foo() {}
++    /// # fn bar() {}
++    /// let condition: bool = true;
++    /// if condition {
++    ///     foo();
++    /// } else {
++    ///     bar();
++    /// }
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub MATCH_BOOL,
++    pedantic,
++    "a `match` on a boolean expression instead of an `if..else` block"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for overlapping match arms.
++    ///
++    /// ### Why is this bad?
++    /// It is likely to be an error and if not, makes the code
++    /// less obvious.
++    ///
++    /// ### Example
++    /// ```rust
++    /// let x = 5;
++    /// match x {
++    ///     1..=10 => println!("1 ... 10"),
++    ///     5..=15 => println!("5 ... 15"),
++    ///     _ => (),
++    /// }
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub MATCH_OVERLAPPING_ARM,
++    style,
++    "a `match` with overlapping arms"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for arm which matches all errors with `Err(_)`
++    /// and take drastic actions like `panic!`.
++    ///
++    /// ### Why is this bad?
++    /// It is generally a bad practice, similar to
++    /// catching all exceptions in java with `catch(Exception)`
++    ///
++    /// ### Example
++    /// ```rust
++    /// let x: Result<i32, &str> = Ok(3);
++    /// match x {
++    ///     Ok(_) => println!("ok"),
++    ///     Err(_) => panic!("err"),
++    /// }
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub MATCH_WILD_ERR_ARM,
++    pedantic,
++    "a `match` with `Err(_)` arm and take drastic actions"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for match which is used to add a reference to an
++    /// `Option` value.
++    ///
++    /// ### Why is this bad?
++    /// Using `as_ref()` or `as_mut()` instead is shorter.
++    ///
++    /// ### Example
++    /// ```rust
++    /// let x: Option<()> = None;
++    ///
++    /// // Bad
++    /// let r: Option<&()> = match x {
++    ///     None => None,
++    ///     Some(ref v) => Some(v),
++    /// };
++    ///
++    /// // Good
++    /// let r: Option<&()> = x.as_ref();
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub MATCH_AS_REF,
++    complexity,
++    "a `match` on an Option value instead of using `as_ref()` or `as_mut`"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for wildcard enum matches using `_`.
++    ///
++    /// ### Why is this bad?
++    /// New enum variants added by library updates can be missed.
++    ///
++    /// ### Known problems
++    /// Suggested replacements may be incorrect if guards exhaustively cover some
++    /// variants, and also may not use correct path to enum if it's not present in the current scope.
++    ///
++    /// ### Example
++    /// ```rust
++    /// # enum Foo { A(usize), B(usize) }
++    /// # let x = Foo::B(1);
++    /// // Bad
++    /// match x {
++    ///     Foo::A(_) => {},
++    ///     _ => {},
++    /// }
++    ///
++    /// // Good
++    /// match x {
++    ///     Foo::A(_) => {},
++    ///     Foo::B(_) => {},
++    /// }
++    /// ```
++    #[clippy::version = "1.34.0"]
++    pub WILDCARD_ENUM_MATCH_ARM,
++    restriction,
++    "a wildcard enum match arm using `_`"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for wildcard enum matches for a single variant.
++    ///
++    /// ### Why is this bad?
++    /// New enum variants added by library updates can be missed.
++    ///
++    /// ### Known problems
++    /// Suggested replacements may not use correct path to enum
++    /// if it's not present in the current scope.
++    ///
++    /// ### Example
++    /// ```rust
++    /// # enum Foo { A, B, C }
++    /// # let x = Foo::B;
++    /// // Bad
++    /// match x {
++    ///     Foo::A => {},
++    ///     Foo::B => {},
++    ///     _ => {},
++    /// }
++    ///
++    /// // Good
++    /// match x {
++    ///     Foo::A => {},
++    ///     Foo::B => {},
++    ///     Foo::C => {},
++    /// }
++    /// ```
++    #[clippy::version = "1.45.0"]
++    pub MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
++    pedantic,
++    "a wildcard enum match for a single variant"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for wildcard pattern used with others patterns in same match arm.
++    ///
++    /// ### Why is this bad?
++    /// Wildcard pattern already covers any other pattern as it will match anyway.
++    /// It makes the code less readable, especially to spot wildcard pattern use in match arm.
++    ///
++    /// ### Example
++    /// ```rust
++    /// // Bad
++    /// match "foo" {
++    ///     "a" => {},
++    ///     "bar" | _ => {},
++    /// }
++    ///
++    /// // Good
++    /// match "foo" {
++    ///     "a" => {},
++    ///     _ => {},
++    /// }
++    /// ```
++    #[clippy::version = "1.42.0"]
++    pub WILDCARD_IN_OR_PATTERNS,
++    complexity,
++    "a wildcard pattern used with others patterns in same match arm"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for matches being used to destructure a single-variant enum
++    /// or tuple struct where a `let` will suffice.
++    ///
++    /// ### Why is this bad?
++    /// Just readability – `let` doesn't nest, whereas a `match` does.
++    ///
++    /// ### Example
++    /// ```rust
++    /// enum Wrapper {
++    ///     Data(i32),
++    /// }
++    ///
++    /// let wrapper = Wrapper::Data(42);
++    ///
++    /// let data = match wrapper {
++    ///     Wrapper::Data(i) => i,
++    /// };
++    /// ```
++    ///
++    /// The correct use would be:
++    /// ```rust
++    /// enum Wrapper {
++    ///     Data(i32),
++    /// }
++    ///
++    /// let wrapper = Wrapper::Data(42);
++    /// let Wrapper::Data(data) = wrapper;
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub INFALLIBLE_DESTRUCTURING_MATCH,
++    style,
++    "a `match` statement with a single infallible arm instead of a `let`"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for useless match that binds to only one value.
++    ///
++    /// ### Why is this bad?
++    /// Readability and needless complexity.
++    ///
++    /// ### Known problems
++    ///  Suggested replacements may be incorrect when `match`
++    /// is actually binding temporary value, bringing a 'dropped while borrowed' error.
++    ///
++    /// ### Example
++    /// ```rust
++    /// # let a = 1;
++    /// # let b = 2;
++    ///
++    /// // Bad
++    /// match (a, b) {
++    ///     (c, d) => {
++    ///         // useless match
++    ///     }
++    /// }
++    ///
++    /// // Good
++    /// let (c, d) = (a, b);
++    /// ```
++    #[clippy::version = "1.43.0"]
++    pub MATCH_SINGLE_BINDING,
++    complexity,
++    "a match with a single binding instead of using `let` statement"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for unnecessary '..' pattern binding on struct when all fields are explicitly matched.
++    ///
++    /// ### Why is this bad?
++    /// Correctness and readability. It's like having a wildcard pattern after
++    /// matching all enum variants explicitly.
++    ///
++    /// ### Example
++    /// ```rust
++    /// # struct A { a: i32 }
++    /// let a = A { a: 5 };
++    ///
++    /// // Bad
++    /// match a {
++    ///     A { a: 5, .. } => {},
++    ///     _ => {},
++    /// }
++    ///
++    /// // Good
++    /// match a {
++    ///     A { a: 5 } => {},
++    ///     _ => {},
++    /// }
++    /// ```
++    #[clippy::version = "1.43.0"]
++    pub REST_PAT_IN_FULLY_BOUND_STRUCTS,
++    restriction,
++    "a match on a struct that binds all fields but still uses the wildcard pattern"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Lint for redundant pattern matching over `Result`, `Option`,
++    /// `std::task::Poll` or `std::net::IpAddr`
++    ///
++    /// ### Why is this bad?
++    /// It's more concise and clear to just use the proper
++    /// utility function
++    ///
++    /// ### Known problems
++    /// This will change the drop order for the matched type. Both `if let` and
++    /// `while let` will drop the value at the end of the block, both `if` and `while` will drop the
++    /// value before entering the block. For most types this change will not matter, but for a few
++    /// types this will not be an acceptable change (e.g. locks). See the
++    /// [reference](https://doc.rust-lang.org/reference/destructors.html#drop-scopes) for more about
++    /// drop order.
++    ///
++    /// ### Example
++    /// ```rust
++    /// # use std::task::Poll;
++    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
++    /// if let Ok(_) = Ok::<i32, i32>(42) {}
++    /// if let Err(_) = Err::<i32, i32>(42) {}
++    /// if let None = None::<()> {}
++    /// if let Some(_) = Some(42) {}
++    /// if let Poll::Pending = Poll::Pending::<()> {}
++    /// if let Poll::Ready(_) = Poll::Ready(42) {}
++    /// if let IpAddr::V4(_) = IpAddr::V4(Ipv4Addr::LOCALHOST) {}
++    /// if let IpAddr::V6(_) = IpAddr::V6(Ipv6Addr::LOCALHOST) {}
++    /// match Ok::<i32, i32>(42) {
++    ///     Ok(_) => true,
++    ///     Err(_) => false,
++    /// };
++    /// ```
++    ///
++    /// The more idiomatic use would be:
++    ///
++    /// ```rust
++    /// # use std::task::Poll;
++    /// # use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
++    /// if Ok::<i32, i32>(42).is_ok() {}
++    /// if Err::<i32, i32>(42).is_err() {}
++    /// if None::<()>.is_none() {}
++    /// if Some(42).is_some() {}
++    /// if Poll::Pending::<()>.is_pending() {}
++    /// if Poll::Ready(42).is_ready() {}
++    /// if IpAddr::V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
++    /// if IpAddr::V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
++    /// Ok::<i32, i32>(42).is_ok();
++    /// ```
++    #[clippy::version = "1.31.0"]
++    pub REDUNDANT_PATTERN_MATCHING,
++    style,
++    "use the proper utility function avoiding an `if let`"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for `match`  or `if let` expressions producing a
++    /// `bool` that could be written using `matches!`
++    ///
++    /// ### Why is this bad?
++    /// Readability and needless complexity.
++    ///
++    /// ### Known problems
++    /// This lint falsely triggers, if there are arms with
++    /// `cfg` attributes that remove an arm evaluating to `false`.
++    ///
++    /// ### Example
++    /// ```rust
++    /// let x = Some(5);
++    ///
++    /// // Bad
++    /// let a = match x {
++    ///     Some(0) => true,
++    ///     _ => false,
++    /// };
++    ///
++    /// let a = if let Some(0) = x {
++    ///     true
++    /// } else {
++    ///     false
++    /// };
++    ///
++    /// // Good
++    /// let a = matches!(x, Some(0));
++    /// ```
++    #[clippy::version = "1.47.0"]
++    pub MATCH_LIKE_MATCHES_MACRO,
++    style,
++    "a match that could be written with the matches! macro"
++}
++
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for `match` with identical arm bodies.
++    ///
++    /// ### Why is this bad?
++    /// This is probably a copy & paste error. If arm bodies
++    /// are the same on purpose, you can factor them
++    /// [using `|`](https://doc.rust-lang.org/book/patterns.html#multiple-patterns).
++    ///
++    /// ### Known problems
++    /// False positive possible with order dependent `match`
++    /// (see issue
++    /// [#860](https://github.com/rust-lang/rust-clippy/issues/860)).
++    ///
++    /// ### Example
++    /// ```rust,ignore
++    /// match foo {
++    ///     Bar => bar(),
++    ///     Quz => quz(),
++    ///     Baz => bar(), // <= oops
++    /// }
++    /// ```
++    ///
++    /// This should probably be
++    /// ```rust,ignore
++    /// match foo {
++    ///     Bar => bar(),
++    ///     Quz => quz(),
++    ///     Baz => baz(), // <= fixed
++    /// }
++    /// ```
++    ///
++    /// or if the original code was not a typo:
++    /// ```rust,ignore
++    /// match foo {
++    ///     Bar | Baz => bar(), // <= shows the intent better
++    ///     Quz => quz(),
++    /// }
++    /// ```
++    #[clippy::version = "pre 1.29.0"]
++    pub MATCH_SAME_ARMS,
++    pedantic,
++    "`match` with identical arm bodies"
++}
++
++#[derive(Default)]
++pub struct Matches {
++    msrv: Option<RustcVersion>,
++    infallible_destructuring_match_linted: bool,
++}
++
++impl Matches {
++    #[must_use]
++    pub fn new(msrv: Option<RustcVersion>) -> Self {
++        Self {
++            msrv,
++            ..Matches::default()
++        }
++    }
++}
++
++impl_lint_pass!(Matches => [
++    SINGLE_MATCH,
++    MATCH_REF_PATS,
++    MATCH_BOOL,
++    SINGLE_MATCH_ELSE,
++    MATCH_OVERLAPPING_ARM,
++    MATCH_WILD_ERR_ARM,
++    MATCH_AS_REF,
++    WILDCARD_ENUM_MATCH_ARM,
++    MATCH_WILDCARD_FOR_SINGLE_VARIANTS,
++    WILDCARD_IN_OR_PATTERNS,
++    MATCH_SINGLE_BINDING,
++    INFALLIBLE_DESTRUCTURING_MATCH,
++    REST_PAT_IN_FULLY_BOUND_STRUCTS,
++    REDUNDANT_PATTERN_MATCHING,
++    MATCH_LIKE_MATCHES_MACRO,
++    MATCH_SAME_ARMS,
++]);
++
++impl<'tcx> LateLintPass<'tcx> for Matches {
++    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
++        if expr.span.from_expansion() {
++            return;
++        }
++
++        redundant_pattern_match::check(cx, expr);
++
++        if meets_msrv(self.msrv.as_ref(), &msrvs::MATCHES_MACRO) {
++            if !match_like_matches::check(cx, expr) {
++                match_same_arms::check(cx, expr);
++            }
++        } else {
++            match_same_arms::check(cx, expr);
++        }
++
++        if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind {
++            single_match::check(cx, ex, arms, expr);
++            match_bool::check(cx, ex, arms, expr);
++            overlapping_arms::check(cx, ex, arms);
++            match_wild_err_arm::check(cx, ex, arms);
++            match_wild_enum::check(cx, ex, arms);
++            match_as_ref::check(cx, ex, arms, expr);
++            wild_in_or_pats::check(cx, arms);
++
++            if self.infallible_destructuring_match_linted {
++                self.infallible_destructuring_match_linted = false;
++            } else {
++                match_single_binding::check(cx, ex, arms, expr);
++            }
++        }
++        if let ExprKind::Match(ex, arms, _) = expr.kind {
++            match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
++        }
++    }
++
++    fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx Local<'_>) {
++        self.infallible_destructuring_match_linted |= infalliable_detructuring_match::check(cx, local);
++    }
++
++    fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
++        rest_pat_in_fully_bound_struct::check(cx, pat);
++    }
++
++    extract_msrv_attr!(LateContext);
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..7e658126690299787f1410a713533a78d8c60a06

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs
@@@ -1,0 -1,0 +1,181 @@@
++use clippy_utils::consts::{constant, constant_full_int, miri_to_const, FullInt};
++use clippy_utils::diagnostics::span_lint_and_note;
++use core::cmp::Ordering;
++use rustc_hir::{Arm, Expr, PatKind, RangeEnd};
++use rustc_lint::LateContext;
++use rustc_middle::ty::Ty;
++use rustc_span::Span;
++
++use super::MATCH_OVERLAPPING_ARM;
++
++pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) {
++    if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() {
++        let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex));
++        if !ranges.is_empty() {
++            if let Some((start, end)) = overlapping(&ranges) {
++                span_lint_and_note(
++                    cx,
++                    MATCH_OVERLAPPING_ARM,
++                    start.span,
++                    "some ranges overlap",
++                    Some(end.span),
++                    "overlaps with this",
++                );
++            }
++        }
++    }
++}
++
++/// Gets the ranges for each range pattern arm. Applies `ty` bounds for open ranges.
++fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) -> Vec<SpannedRange<FullInt>> {
++    arms.iter()
++        .filter_map(|arm| {
++            if let Arm { pat, guard: None, .. } = *arm {
++                if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
++                    let lhs_const = match lhs {
++                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?.0,
++                        None => miri_to_const(ty.numeric_min_val(cx.tcx)?)?,
++                    };
++                    let rhs_const = match rhs {
++                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?.0,
++                        None => miri_to_const(ty.numeric_max_val(cx.tcx)?)?,
++                    };
++
++                    let lhs_val = lhs_const.int_value(cx, ty)?;
++                    let rhs_val = rhs_const.int_value(cx, ty)?;
++
++                    let rhs_bound = match range_end {
++                        RangeEnd::Included => EndBound::Included(rhs_val),
++                        RangeEnd::Excluded => EndBound::Excluded(rhs_val),
++                    };
++                    return Some(SpannedRange {
++                        span: pat.span,
++                        node: (lhs_val, rhs_bound),
++                    });
++                }
++
++                if let PatKind::Lit(value) = pat.kind {
++                    let value = constant_full_int(cx, cx.typeck_results(), value)?;
++                    return Some(SpannedRange {
++                        span: pat.span,
++                        node: (value, EndBound::Included(value)),
++                    });
++                }
++            }
++            None
++        })
++        .collect()
++}
++
++#[derive(Clone, Copy, Debug, Eq, PartialEq)]
++pub enum EndBound<T> {
++    Included(T),
++    Excluded(T),
++}
++
++#[derive(Debug, Eq, PartialEq)]
++struct SpannedRange<T> {
++    pub span: Span,
++    pub node: (T, EndBound<T>),
++}
++
++fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &SpannedRange<T>)>
++where
++    T: Copy + Ord,
++{
++    #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
++    enum BoundKind {
++        EndExcluded,
++        Start,
++        EndIncluded,
++    }
++
++    #[derive(Copy, Clone, Debug, Eq, PartialEq)]
++    struct RangeBound<'a, T>(T, BoundKind, &'a SpannedRange<T>);
++
++    impl<'a, T: Copy + Ord> PartialOrd for RangeBound<'a, T> {
++        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
++            Some(self.cmp(other))
++        }
++    }
++
++    impl<'a, T: Copy + Ord> Ord for RangeBound<'a, T> {
++        fn cmp(&self, RangeBound(other_value, other_kind, _): &Self) -> Ordering {
++            let RangeBound(self_value, self_kind, _) = *self;
++            (self_value, self_kind).cmp(&(*other_value, *other_kind))
++        }
++    }
++
++    let mut values = Vec::with_capacity(2 * ranges.len());
++
++    for r @ SpannedRange { node: (start, end), .. } in ranges {
++        values.push(RangeBound(*start, BoundKind::Start, r));
++        values.push(match end {
++            EndBound::Excluded(val) => RangeBound(*val, BoundKind::EndExcluded, r),
++            EndBound::Included(val) => RangeBound(*val, BoundKind::EndIncluded, r),
++        });
++    }
++
++    values.sort();
++
++    let mut started = vec![];
++
++    for RangeBound(_, kind, range) in values {
++        match kind {
++            BoundKind::Start => started.push(range),
++            BoundKind::EndExcluded | BoundKind::EndIncluded => {
++                let mut overlap = None;
++
++                while let Some(last_started) = started.pop() {
++                    if last_started == range {
++                        break;
++                    }
++                    overlap = Some(last_started);
++                }
++
++                if let Some(first_overlapping) = overlap {
++                    return Some((range, first_overlapping));
++                }
++            },
++        }
++    }
++
++    None
++}
++
++#[test]
++fn test_overlapping() {
++    use rustc_span::source_map::DUMMY_SP;
++
++    let sp = |s, e| SpannedRange {
++        span: DUMMY_SP,
++        node: (s, e),
++    };
++
++    assert_eq!(None, overlapping::<u8>(&[]));
++    assert_eq!(None, overlapping(&[sp(1, EndBound::Included(4))]));
++    assert_eq!(
++        None,
++        overlapping(&[sp(1, EndBound::Included(4)), sp(5, EndBound::Included(6))])
++    );
++    assert_eq!(
++        None,
++        overlapping(&[
++            sp(1, EndBound::Included(4)),
++            sp(5, EndBound::Included(6)),
++            sp(10, EndBound::Included(11))
++        ],)
++    );
++    assert_eq!(
++        Some((&sp(1, EndBound::Included(4)), &sp(3, EndBound::Included(6)))),
++        overlapping(&[sp(1, EndBound::Included(4)), sp(3, EndBound::Included(6))])
++    );
++    assert_eq!(
++        Some((&sp(5, EndBound::Included(6)), &sp(6, EndBound::Included(11)))),
++        overlapping(&[
++            sp(1, EndBound::Included(4)),
++            sp(5, EndBound::Included(6)),
++            sp(6, EndBound::Included(11))
++        ],)
++    );
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..61c5fa0872f6a4527e3a5ef3db62986fb5d2b191

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs
@@@ -1,0 -1,0 +1,436 @@@
++use super::REDUNDANT_PATTERN_MATCHING;
++use clippy_utils::diagnostics::span_lint_and_then;
++use clippy_utils::source::snippet;
++use clippy_utils::sugg::Sugg;
++use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, is_type_lang_item, match_type};
++use clippy_utils::{higher, match_def_path};
++use clippy_utils::{is_lang_ctor, is_trait_method, paths};
++use if_chain::if_chain;
++use rustc_ast::ast::LitKind;
++use rustc_data_structures::fx::FxHashSet;
++use rustc_errors::Applicability;
++use rustc_hir::LangItem::{OptionNone, PollPending};
++use rustc_hir::{
++    intravisit::{walk_expr, Visitor},
++    Arm, Block, Expr, ExprKind, LangItem, MatchSource, Node, Pat, PatKind, QPath, UnOp,
++};
++use rustc_lint::LateContext;
++use rustc_middle::ty::{self, subst::GenericArgKind, DefIdTree, Ty};
++use rustc_span::sym;
++
++pub fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
++    if let Some(higher::IfLet {
++        if_else,
++        let_pat,
++        let_expr,
++        ..
++    }) = higher::IfLet::hir(cx, expr)
++    {
++        find_sugg_for_if_let(cx, expr, let_pat, let_expr, "if", if_else.is_some());
++    }
++    if let ExprKind::Match(op, arms, MatchSource::Normal) = &expr.kind {
++        find_sugg_for_match(cx, expr, op, arms);
++    }
++    if let Some(higher::WhileLet { let_pat, let_expr, .. }) = higher::WhileLet::hir(expr) {
++        find_sugg_for_if_let(cx, expr, let_pat, let_expr, "while", false);
++    }
++}
++
++/// Checks if the drop order for a type matters. Some std types implement drop solely to
++/// deallocate memory. For these types, and composites containing them, changing the drop order
++/// won't result in any observable side effects.
++fn type_needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
++    type_needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
++}
++
++fn type_needs_ordered_drop_inner<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
++    if !seen.insert(ty) {
++        return false;
++    }
++    if !ty.needs_drop(cx.tcx, cx.param_env) {
++        false
++    } else if !cx
++        .tcx
++        .lang_items()
++        .drop_trait()
++        .map_or(false, |id| implements_trait(cx, ty, id, &[]))
++    {
++        // This type doesn't implement drop, so no side effects here.
++        // Check if any component type has any.
++        match ty.kind() {
++            ty::Tuple(_) => ty.tuple_fields().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
++            ty::Array(ty, _) => type_needs_ordered_drop_inner(cx, ty, seen),
++            ty::Adt(adt, subs) => adt
++                .all_fields()
++                .map(|f| f.ty(cx.tcx, subs))
++                .any(|ty| type_needs_ordered_drop_inner(cx, ty, seen)),
++            _ => true,
++        }
++    }
++    // Check for std types which implement drop, but only for memory allocation.
++    else if is_type_diagnostic_item(cx, ty, sym::Vec)
++        || is_type_lang_item(cx, ty, LangItem::OwnedBox)
++        || is_type_diagnostic_item(cx, ty, sym::Rc)
++        || is_type_diagnostic_item(cx, ty, sym::Arc)
++        || is_type_diagnostic_item(cx, ty, sym::cstring_type)
++        || is_type_diagnostic_item(cx, ty, sym::BTreeMap)
++        || is_type_diagnostic_item(cx, ty, sym::LinkedList)
++        || match_type(cx, ty, &paths::WEAK_RC)
++        || match_type(cx, ty, &paths::WEAK_ARC)
++    {
++        // Check all of the generic arguments.
++        if let ty::Adt(_, subs) = ty.kind() {
++            subs.types().any(|ty| type_needs_ordered_drop_inner(cx, ty, seen))
++        } else {
++            true
++        }
++    } else {
++        true
++    }
++}
++
++// Extract the generic arguments out of a type
++fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
++    if_chain! {
++        if let ty::Adt(_, subs) = ty.kind();
++        if let Some(sub) = subs.get(index);
++        if let GenericArgKind::Type(sub_ty) = sub.unpack();
++        then {
++            Some(sub_ty)
++        } else {
++            None
++        }
++    }
++}
++
++// Checks if there are any temporaries created in the given expression for which drop order
++// matters.
++fn temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
++    struct V<'a, 'tcx> {
++        cx: &'a LateContext<'tcx>,
++        res: bool,
++    }
++    impl<'a, 'tcx> Visitor<'tcx> for V<'a, 'tcx> {
++        fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
++            match expr.kind {
++                // Taking the reference of a value leaves a temporary
++                // e.g. In `&String::new()` the string is a temporary value.
++                // Remaining fields are temporary values
++                // e.g. In `(String::new(), 0).1` the string is a temporary value.
++                ExprKind::AddrOf(_, _, expr) | ExprKind::Field(expr, _) => {
++                    if !matches!(expr.kind, ExprKind::Path(_)) {
++                        if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(expr)) {
++                            self.res = true;
++                        } else {
++                            self.visit_expr(expr);
++                        }
++                    }
++                },
++                // the base type is alway taken by reference.
++                // e.g. In `(vec![0])[0]` the vector is a temporary value.
++                ExprKind::Index(base, index) => {
++                    if !matches!(base.kind, ExprKind::Path(_)) {
++                        if type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(base)) {
++                            self.res = true;
++                        } else {
++                            self.visit_expr(base);
++                        }
++                    }
++                    self.visit_expr(index);
++                },
++                // Method calls can take self by reference.
++                // e.g. In `String::new().len()` the string is a temporary value.
++                ExprKind::MethodCall(_, [self_arg, args @ ..], _) => {
++                    if !matches!(self_arg.kind, ExprKind::Path(_)) {
++                        let self_by_ref = self
++                            .cx
++                            .typeck_results()
++                            .type_dependent_def_id(expr.hir_id)
++                            .map_or(false, |id| self.cx.tcx.fn_sig(id).skip_binder().inputs()[0].is_ref());
++                        if self_by_ref && type_needs_ordered_drop(self.cx, self.cx.typeck_results().expr_ty(self_arg)) {
++                            self.res = true;
++                        } else {
++                            self.visit_expr(self_arg);
++                        }
++                    }
++                    args.iter().for_each(|arg| self.visit_expr(arg));
++                },
++                // Either explicitly drops values, or changes control flow.
++                ExprKind::DropTemps(_)
++                | ExprKind::Ret(_)
++                | ExprKind::Break(..)
++                | ExprKind::Yield(..)
++                | ExprKind::Block(Block { expr: None, .. }, _)
++                | ExprKind::Loop(..) => (),
++
++                // Only consider the final expression.
++                ExprKind::Block(Block { expr: Some(expr), .. }, _) => self.visit_expr(expr),
++
++                _ => walk_expr(self, expr),
++            }
++        }
++    }
++
++    let mut v = V { cx, res: false };
++    v.visit_expr(expr);
++    v.res
++}
++
++fn find_sugg_for_if_let<'tcx>(
++    cx: &LateContext<'tcx>,
++    expr: &'tcx Expr<'_>,
++    let_pat: &Pat<'_>,
++    let_expr: &'tcx Expr<'_>,
++    keyword: &'static str,
++    has_else: bool,
++) {
++    // also look inside refs
++    // if we have &None for example, peel it so we can detect "if let None = x"
++    let check_pat = match let_pat.kind {
++        PatKind::Ref(inner, _mutability) => inner,
++        _ => let_pat,
++    };
++    let op_ty = cx.typeck_results().expr_ty(let_expr);
++    // Determine which function should be used, and the type contained by the corresponding
++    // variant.
++    let (good_method, inner_ty) = match check_pat.kind {
++        PatKind::TupleStruct(ref qpath, [sub_pat], _) => {
++            if let PatKind::Wild = sub_pat.kind {
++                let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id);
++                let Some(id) = res.opt_def_id().and_then(|ctor_id| cx.tcx.parent(ctor_id)) else { return };
++                let lang_items = cx.tcx.lang_items();
++                if Some(id) == lang_items.result_ok_variant() {
++                    ("is_ok()", try_get_generic_ty(op_ty, 0).unwrap_or(op_ty))
++                } else if Some(id) == lang_items.result_err_variant() {
++                    ("is_err()", try_get_generic_ty(op_ty, 1).unwrap_or(op_ty))
++                } else if Some(id) == lang_items.option_some_variant() {
++                    ("is_some()", op_ty)
++                } else if Some(id) == lang_items.poll_ready_variant() {
++                    ("is_ready()", op_ty)
++                } else if match_def_path(cx, id, &paths::IPADDR_V4) {
++                    ("is_ipv4()", op_ty)
++                } else if match_def_path(cx, id, &paths::IPADDR_V6) {
++                    ("is_ipv6()", op_ty)
++                } else {
++                    return;
++                }
++            } else {
++                return;
++            }
++        },
++        PatKind::Path(ref path) => {
++            let method = if is_lang_ctor(cx, path, OptionNone) {
++                "is_none()"
++            } else if is_lang_ctor(cx, path, PollPending) {
++                "is_pending()"
++            } else {
++                return;
++            };
++            // `None` and `Pending` don't have an inner type.
++            (method, cx.tcx.types.unit)
++        },
++        _ => return,
++    };
++
++    // If this is the last expression in a block or there is an else clause then the whole
++    // type needs to be considered, not just the inner type of the branch being matched on.
++    // Note the last expression in a block is dropped after all local bindings.
++    let check_ty = if has_else
++        || (keyword == "if" && matches!(cx.tcx.hir().parent_iter(expr.hir_id).next(), Some((_, Node::Block(..)))))
++    {
++        op_ty
++    } else {
++        inner_ty
++    };
++
++    // All temporaries created in the scrutinee expression are dropped at the same time as the
++    // scrutinee would be, so they have to be considered as well.
++    // e.g. in `if let Some(x) = foo.lock().unwrap().baz.as_ref() { .. }` the lock will be held
++    // for the duration if body.
++    let needs_drop = type_needs_ordered_drop(cx, check_ty) || temporaries_need_ordered_drop(cx, let_expr);
++
++    // check that `while_let_on_iterator` lint does not trigger
++    if_chain! {
++        if keyword == "while";
++        if let ExprKind::MethodCall(method_path, _, _) = let_expr.kind;
++        if method_path.ident.name == sym::next;
++        if is_trait_method(cx, let_expr, sym::Iterator);
++        then {
++            return;
++        }
++    }
++
++    let result_expr = match &let_expr.kind {
++        ExprKind::AddrOf(_, _, borrowed) => borrowed,
++        ExprKind::Unary(UnOp::Deref, deref) => deref,
++        _ => let_expr,
++    };
++
++    span_lint_and_then(
++        cx,
++        REDUNDANT_PATTERN_MATCHING,
++        let_pat.span,
++        &format!("redundant pattern matching, consider using `{}`", good_method),
++        |diag| {
++            // if/while let ... = ... { ... }
++            // ^^^^^^^^^^^^^^^^^^^^^^^^^^^
++            let expr_span = expr.span;
++
++            // if/while let ... = ... { ... }
++            //                 ^^^
++            let op_span = result_expr.span.source_callsite();
++
++            // if/while let ... = ... { ... }
++            // ^^^^^^^^^^^^^^^^^^^
++            let span = expr_span.until(op_span.shrink_to_hi());
++
++            let app = if needs_drop {
++                Applicability::MaybeIncorrect
++            } else {
++                Applicability::MachineApplicable
++            };
++
++            let sugg = Sugg::hir_with_macro_callsite(cx, result_expr, "_")
++                .maybe_par()
++                .to_string();
++
++            diag.span_suggestion(span, "try this", format!("{} {}.{}", keyword, sugg, good_method), app);
++
++            if needs_drop {
++                diag.note("this will change drop order of the result, as well as all temporaries");
++                diag.note("add `#[allow(clippy::redundant_pattern_matching)]` if this is important");
++            }
++        },
++    );
++}
++
++fn find_sugg_for_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op: &Expr<'_>, arms: &[Arm<'_>]) {
++    if arms.len() == 2 {
++        let node_pair = (&arms[0].pat.kind, &arms[1].pat.kind);
++
++        let found_good_method = match node_pair {
++            (
++                PatKind::TupleStruct(ref path_left, patterns_left, _),
++                PatKind::TupleStruct(ref path_right, patterns_right, _),
++            ) if patterns_left.len() == 1 && patterns_right.len() == 1 => {
++                if let (PatKind::Wild, PatKind::Wild) = (&patterns_left[0].kind, &patterns_right[0].kind) {
++                    find_good_method_for_match(
++                        cx,
++                        arms,
++                        path_left,
++                        path_right,
++                        &paths::RESULT_OK,
++                        &paths::RESULT_ERR,
++                        "is_ok()",
++                        "is_err()",
++                    )
++                    .or_else(|| {
++                        find_good_method_for_match(
++                            cx,
++                            arms,
++                            path_left,
++                            path_right,
++                            &paths::IPADDR_V4,
++                            &paths::IPADDR_V6,
++                            "is_ipv4()",
++                            "is_ipv6()",
++                        )
++                    })
++                } else {
++                    None
++                }
++            },
++            (PatKind::TupleStruct(ref path_left, patterns, _), PatKind::Path(ref path_right))
++            | (PatKind::Path(ref path_left), PatKind::TupleStruct(ref path_right, patterns, _))
++                if patterns.len() == 1 =>
++            {
++                if let PatKind::Wild = patterns[0].kind {
++                    find_good_method_for_match(
++                        cx,
++                        arms,
++                        path_left,
++                        path_right,
++                        &paths::OPTION_SOME,
++                        &paths::OPTION_NONE,
++                        "is_some()",
++                        "is_none()",
++                    )
++                    .or_else(|| {
++                        find_good_method_for_match(
++                            cx,
++                            arms,
++                            path_left,
++                            path_right,
++                            &paths::POLL_READY,
++                            &paths::POLL_PENDING,
++                            "is_ready()",
++                            "is_pending()",
++                        )
++                    })
++                } else {
++                    None
++                }
++            },
++            _ => None,
++        };
++
++        if let Some(good_method) = found_good_method {
++            let span = expr.span.to(op.span);
++            let result_expr = match &op.kind {
++                ExprKind::AddrOf(_, _, borrowed) => borrowed,
++                _ => op,
++            };
++            span_lint_and_then(
++                cx,
++                REDUNDANT_PATTERN_MATCHING,
++                expr.span,
++                &format!("redundant pattern matching, consider using `{}`", good_method),
++                |diag| {
++                    diag.span_suggestion(
++                        span,
++                        "try this",
++                        format!("{}.{}", snippet(cx, result_expr.span, "_"), good_method),
++                        Applicability::MaybeIncorrect, // snippet
++                    );
++                },
++            );
++        }
++    }
++}
++
++#[allow(clippy::too_many_arguments)]
++fn find_good_method_for_match<'a>(
++    cx: &LateContext<'_>,
++    arms: &[Arm<'_>],
++    path_left: &QPath<'_>,
++    path_right: &QPath<'_>,
++    expected_left: &[&str],
++    expected_right: &[&str],
++    should_be_left: &'a str,
++    should_be_right: &'a str,
++) -> Option<&'a str> {
++    let left_id = cx
++        .typeck_results()
++        .qpath_res(path_left, arms[0].pat.hir_id)
++        .opt_def_id()?;
++    let right_id = cx
++        .typeck_results()
++        .qpath_res(path_right, arms[1].pat.hir_id)
++        .opt_def_id()?;
++    let body_node_pair = if match_def_path(cx, left_id, expected_left) && match_def_path(cx, right_id, expected_right) {
++        (&(*arms[0].body).kind, &(*arms[1].body).kind)
++    } else if match_def_path(cx, right_id, expected_left) && match_def_path(cx, right_id, expected_right) {
++        (&(*arms[1].body).kind, &(*arms[0].body).kind)
++    } else {
++        return None;
++    };
++
++    match body_node_pair {
++        (ExprKind::Lit(ref lit_left), ExprKind::Lit(ref lit_right)) => match (&lit_left.node, &lit_right.node) {
++            (LitKind::Bool(true), LitKind::Bool(false)) => Some(should_be_left),
++            (LitKind::Bool(false), LitKind::Bool(true)) => Some(should_be_right),
++            _ => None,
++        },
++        _ => None,
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..5076239a57c4d79f707b8aa0655d698ba126faf7

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@@ -1,0 -1,0 +1,29 @@@
++use clippy_utils::diagnostics::span_lint_and_help;
++use rustc_hir::{Pat, PatKind, QPath};
++use rustc_lint::LateContext;
++use rustc_middle::ty;
++
++use super::REST_PAT_IN_FULLY_BOUND_STRUCTS;
++
++pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
++    if_chain! {
++        if !pat.span.from_expansion();
++        if let PatKind::Struct(QPath::Resolved(_, path), fields, true) = pat.kind;
++        if let Some(def_id) = path.res.opt_def_id();
++        let ty = cx.tcx.type_of(def_id);
++        if let ty::Adt(def, _) = ty.kind();
++        if def.is_struct() || def.is_union();
++        if fields.len() == def.non_enum_variant().fields.len();
++
++        then {
++            span_lint_and_help(
++                cx,
++                REST_PAT_IN_FULLY_BOUND_STRUCTS,
++                pat.span,
++                "unnecessary use of `..` pattern in struct binding. All fields were already bound",
++                None,
++                "consider removing `..` from this binding",
++            );
++        }
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/single_match.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..6ba279eaf122433885b17e8dcf592dd88876bf09

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/single_match.rs
@@@ -1,0 -1,0 +1,269 @@@
++use clippy_utils::diagnostics::span_lint_and_sugg;
++use clippy_utils::source::{expr_block, snippet};
++use clippy_utils::ty::{implements_trait, match_type, peel_mid_ty_refs};
++use clippy_utils::{
++    is_lint_allowed, is_unit_expr, is_wild, paths, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs,
++};
++use core::cmp::max;
++use rustc_errors::Applicability;
++use rustc_hir::{Arm, BindingAnnotation, Block, Expr, ExprKind, Pat, PatKind};
++use rustc_lint::LateContext;
++use rustc_middle::ty::{self, Ty, TyS};
++
++use super::{MATCH_BOOL, SINGLE_MATCH, SINGLE_MATCH_ELSE};
++
++#[rustfmt::skip]
++pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
++    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
++        if expr.span.from_expansion() {
++            // Don't lint match expressions present in
++            // macro_rules! block
++            return;
++        }
++        if let PatKind::Or(..) = arms[0].pat.kind {
++            // don't lint for or patterns for now, this makes
++            // the lint noisy in unnecessary situations
++            return;
++        }
++        let els = arms[1].body;
++        let els = if is_unit_expr(peel_blocks(els)) {
++            None
++        } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
++            if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
++                // single statement/expr "else" block, don't lint
++                return;
++            }
++            // block with 2+ statements or 1 expr and 1+ statement
++            Some(els)
++        } else {
++            // not a block, don't lint
++            return;
++        };
++
++        let ty = cx.typeck_results().expr_ty(ex);
++        if *ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
++            check_single_pattern(cx, ex, arms, expr, els);
++            check_opt_like(cx, ex, arms, expr, ty, els);
++        }
++    }
++}
++
++fn check_single_pattern(
++    cx: &LateContext<'_>,
++    ex: &Expr<'_>,
++    arms: &[Arm<'_>],
++    expr: &Expr<'_>,
++    els: Option<&Expr<'_>>,
++) {
++    if is_wild(arms[1].pat) {
++        report_single_pattern(cx, ex, arms, expr, els);
++    }
++}
++
++fn report_single_pattern(
++    cx: &LateContext<'_>,
++    ex: &Expr<'_>,
++    arms: &[Arm<'_>],
++    expr: &Expr<'_>,
++    els: Option<&Expr<'_>>,
++) {
++    let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
++    let els_str = els.map_or(String::new(), |els| {
++        format!(" else {}", expr_block(cx, els, None, "..", Some(expr.span)))
++    });
++
++    let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
++    let (msg, sugg) = if_chain! {
++        if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind;
++        let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex));
++        if let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait();
++        if let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait();
++        if ty.is_integral() || ty.is_char() || ty.is_str()
++            || (implements_trait(cx, ty, spe_trait_id, &[])
++                && implements_trait(cx, ty, pe_trait_id, &[ty.into()]));
++        then {
++            // scrutinee derives PartialEq and the pattern is a constant.
++            let pat_ref_count = match pat.kind {
++                // string literals are already a reference.
++                PatKind::Lit(Expr { kind: ExprKind::Lit(lit), .. }) if lit.node.is_str() => pat_ref_count + 1,
++                _ => pat_ref_count,
++            };
++            // References are only implicitly added to the pattern, so no overflow here.
++            // e.g. will work: match &Some(_) { Some(_) => () }
++            // will not: match Some(_) { &Some(_) => () }
++            let ref_count_diff = ty_ref_count - pat_ref_count;
++
++            // Try to remove address of expressions first.
++            let (ex, removed) = peel_n_hir_expr_refs(ex, ref_count_diff);
++            let ref_count_diff = ref_count_diff - removed;
++
++            let msg = "you seem to be trying to use `match` for an equality check. Consider using `if`";
++            let sugg = format!(
++                "if {} == {}{} {}{}",
++                snippet(cx, ex.span, ".."),
++                // PartialEq for different reference counts may not exist.
++                "&".repeat(ref_count_diff),
++                snippet(cx, arms[0].pat.span, ".."),
++                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
++                els_str,
++            );
++            (msg, sugg)
++        } else {
++            let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
++            let sugg = format!(
++                "if let {} = {} {}{}",
++                snippet(cx, arms[0].pat.span, ".."),
++                snippet(cx, ex.span, ".."),
++                expr_block(cx, arms[0].body, None, "..", Some(expr.span)),
++                els_str,
++            );
++            (msg, sugg)
++        }
++    };
++
++    span_lint_and_sugg(
++        cx,
++        lint,
++        expr.span,
++        msg,
++        "try this",
++        sugg,
++        Applicability::HasPlaceholders,
++    );
++}
++
++fn check_opt_like<'a>(
++    cx: &LateContext<'a>,
++    ex: &Expr<'_>,
++    arms: &[Arm<'_>],
++    expr: &Expr<'_>,
++    ty: Ty<'a>,
++    els: Option<&Expr<'_>>,
++) {
++    // list of candidate `Enum`s we know will never get any more members
++    let candidates = &[
++        (&paths::COW, "Borrowed"),
++        (&paths::COW, "Cow::Borrowed"),
++        (&paths::COW, "Cow::Owned"),
++        (&paths::COW, "Owned"),
++        (&paths::OPTION, "None"),
++        (&paths::RESULT, "Err"),
++        (&paths::RESULT, "Ok"),
++    ];
++
++    // We want to suggest to exclude an arm that contains only wildcards or forms the exhaustive
++    // match with the second branch, without enum variants in matches.
++    if !contains_only_wilds(arms[1].pat) && !form_exhaustive_matches(arms[0].pat, arms[1].pat) {
++        return;
++    }
++
++    let mut paths_and_types = Vec::new();
++    if !collect_pat_paths(&mut paths_and_types, cx, arms[1].pat, ty) {
++        return;
++    }
++
++    let in_candidate_enum = |path_info: &(String, &TyS<'_>)| -> bool {
++        let (path, ty) = path_info;
++        for &(ty_path, pat_path) in candidates {
++            if path == pat_path && match_type(cx, ty, ty_path) {
++                return true;
++            }
++        }
++        false
++    };
++    if paths_and_types.iter().all(in_candidate_enum) {
++        report_single_pattern(cx, ex, arms, expr, els);
++    }
++}
++
++/// Collects paths and their types from the given patterns. Returns true if the given pattern could
++/// be simplified, false otherwise.
++fn collect_pat_paths<'a>(acc: &mut Vec<(String, Ty<'a>)>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) -> bool {
++    match pat.kind {
++        PatKind::Wild => true,
++        PatKind::Tuple(inner, _) => inner.iter().all(|p| {
++            let p_ty = cx.typeck_results().pat_ty(p);
++            collect_pat_paths(acc, cx, p, p_ty)
++        }),
++        PatKind::TupleStruct(ref path, ..) => {
++            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
++                s.print_qpath(path, false);
++            });
++            acc.push((path, ty));
++            true
++        },
++        PatKind::Binding(BindingAnnotation::Unannotated, .., ident, None) => {
++            acc.push((ident.to_string(), ty));
++            true
++        },
++        PatKind::Path(ref path) => {
++            let path = rustc_hir_pretty::to_string(rustc_hir_pretty::NO_ANN, |s| {
++                s.print_qpath(path, false);
++            });
++            acc.push((path, ty));
++            true
++        },
++        _ => false,
++    }
++}
++
++/// Returns true if the given arm of pattern matching contains wildcard patterns.
++fn contains_only_wilds(pat: &Pat<'_>) -> bool {
++    match pat.kind {
++        PatKind::Wild => true,
++        PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
++        _ => false,
++    }
++}
++
++/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
++/// patterns without a wildcard.
++fn form_exhaustive_matches(left: &Pat<'_>, right: &Pat<'_>) -> bool {
++    match (&left.kind, &right.kind) {
++        (PatKind::Wild, _) | (_, PatKind::Wild) => true,
++        (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
++            // We don't actually know the position and the presence of the `..` (dotdot) operator
++            // in the arms, so we need to evaluate the correct offsets here in order to iterate in
++            // both arms at the same time.
++            let len = max(
++                left_in.len() + {
++                    if left_pos.is_some() { 1 } else { 0 }
++                },
++                right_in.len() + {
++                    if right_pos.is_some() { 1 } else { 0 }
++                },
++            );
++            let mut left_pos = left_pos.unwrap_or(usize::MAX);
++            let mut right_pos = right_pos.unwrap_or(usize::MAX);
++            let mut left_dot_space = 0;
++            let mut right_dot_space = 0;
++            for i in 0..len {
++                let mut found_dotdot = false;
++                if i == left_pos {
++                    left_dot_space += 1;
++                    if left_dot_space < len - left_in.len() {
++                        left_pos += 1;
++                    }
++                    found_dotdot = true;
++                }
++                if i == right_pos {
++                    right_dot_space += 1;
++                    if right_dot_space < len - right_in.len() {
++                        right_pos += 1;
++                    }
++                    found_dotdot = true;
++                }
++                if found_dotdot {
++                    continue;
++                }
++                if !contains_only_wilds(&left_in[i - left_dot_space])
++                    && !contains_only_wilds(&right_in[i - right_dot_space])
++                {
++                    return false;
++                }
++            }
++            true
++        },
++        _ => false,
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/matches/wild_in_or_pats.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..459513e65bfad1b1aeb7e503a06e9c6949c6f0c3

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/matches/wild_in_or_pats.rs
@@@ -1,0 -1,0 +1,24 @@@
++use clippy_utils::diagnostics::span_lint_and_help;
++use clippy_utils::is_wild;
++use rustc_hir::{Arm, PatKind};
++use rustc_lint::LateContext;
++
++use super::WILDCARD_IN_OR_PATTERNS;
++
++pub(crate) fn check(cx: &LateContext<'_>, arms: &[Arm<'_>]) {
++    for arm in arms {
++        if let PatKind::Or(fields) = arm.pat.kind {
++            // look for multiple fields in this arm that contains at least one Wild pattern
++            if fields.len() > 1 && fields.iter().any(is_wild) {
++                span_lint_and_help(
++                    cx,
++                    WILDCARD_IN_OR_PATTERNS,
++                    arm.pat.span,
++                    "wildcard pattern covers any other pattern as it will match anyway",
++                    None,
++                    "consider handling `_` separately",
++                );
++            }
++        }
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs

index 514c411876551150478608f8f4756d0ecb5074ef,0000000000000000000000000000000000000000..2cf2c5641bf10654e37c51cfb31171ce62bce223

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs
@@@ -1,54 -1,0 +1,51 @@@
- use clippy_utils::{method_chain_args, single_segment_path};
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::source::snippet_with_applicability;
- use rustc_middle::ty;
- use rustc_span::sym;
++use clippy_utils::{method_chain_args, path_def_id};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir as hir;
+ +use rustc_lint::LateContext;
+ +use rustc_lint::Lint;
-         if let hir::ExprKind::Call(fun, arg_char) = info.other.kind;
-         if arg_char.len() == 1;
-         if let hir::ExprKind::Path(ref qpath) = fun.kind;
-         if let Some(segment) = single_segment_path(qpath);
-         if segment.ident.name == sym::Some;
++use rustc_middle::ty::{self, DefIdTree};
+ +
+ +/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints.
+ +pub(super) fn check(
+ +    cx: &LateContext<'_>,
+ +    info: &crate::methods::BinaryExprInfo<'_>,
+ +    chain_methods: &[&str],
+ +    lint: &'static Lint,
+ +    suggest: &str,
+ +) -> bool {
+ +    if_chain! {
+ +        if let Some(args) = method_chain_args(info.chain, chain_methods);
-                         snippet_with_applicability(cx, arg_char[0].span, "..", &mut applicability)),
++        if let hir::ExprKind::Call(fun, [arg_char]) = info.other.kind;
++        if let Some(id) = path_def_id(cx, fun).and_then(|ctor_id| cx.tcx.parent(ctor_id));
++        if Some(id) == cx.tcx.lang_items().option_some_variant();
+ +        then {
+ +            let mut applicability = Applicability::MachineApplicable;
+ +            let self_ty = cx.typeck_results().expr_ty_adjusted(&args[0][0]).peel_refs();
+ +
+ +            if *self_ty.kind() != ty::Str {
+ +                return false;
+ +            }
+ +
+ +            span_lint_and_sugg(
+ +                cx,
+ +                lint,
+ +                info.expr.span,
+ +                &format!("you should use the `{}` method", suggest),
+ +                "like this",
+ +                format!("{}{}.{}({})",
+ +                        if info.eq { "" } else { "!" },
+ +                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
+ +                        suggest,
++                        snippet_with_applicability(cx, arg_char.span, "..", &mut applicability)),
+ +                applicability,
+ +            );
+ +
+ +            return true;
+ +        }
+ +    }
+ +
+ +    false
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/chars_cmp_with_unwrap.rs

index 4275857757fee4552ee56536a9622261a78a86e5,0000000000000000000000000000000000000000..a7c0e43923e139b3cc378b6f54aa19161d396f6e

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/chars_cmp_with_unwrap.rs
@@@ -1,44 -1,0 +1,44 @@@
-                         c),
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::method_chain_args;
+ +use clippy_utils::source::snippet_with_applicability;
+ +use if_chain::if_chain;
+ +use rustc_ast::ast;
+ +use rustc_errors::Applicability;
+ +use rustc_hir as hir;
+ +use rustc_lint::LateContext;
+ +use rustc_lint::Lint;
+ +
+ +/// Wrapper fn for `CHARS_NEXT_CMP` and `CHARS_LAST_CMP` lints with `unwrap()`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    info: &crate::methods::BinaryExprInfo<'_>,
+ +    chain_methods: &[&str],
+ +    lint: &'static Lint,
+ +    suggest: &str,
+ +) -> bool {
+ +    if_chain! {
+ +        if let Some(args) = method_chain_args(info.chain, chain_methods);
+ +        if let hir::ExprKind::Lit(ref lit) = info.other.kind;
+ +        if let ast::LitKind::Char(c) = lit.node;
+ +        then {
+ +            let mut applicability = Applicability::MachineApplicable;
+ +            span_lint_and_sugg(
+ +                cx,
+ +                lint,
+ +                info.expr.span,
+ +                &format!("you should use the `{}` method", suggest),
+ +                "like this",
+ +                format!("{}{}.{}('{}')",
+ +                        if info.eq { "" } else { "!" },
+ +                        snippet_with_applicability(cx, args[0][0].span, "..", &mut applicability),
+ +                        suggest,
++                        c.escape_default()),
+ +                applicability,
+ +            );
+ +
+ +            true
+ +        } else {
+ +            false
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs

index 4307cbf00507a1fcb130f83793770af35a4c334d,0000000000000000000000000000000000000000..0fe510beaa07ee8640d48599b3025775744c8e84

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs
@@@ -1,164 -1,0 +1,164 @@@
- use clippy_utils::is_qpath_def_path;
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
-     if let hir::ExprKind::Path(path) = &expr.kind {
-         if is_qpath_def_path(cx, path, expr.hir_id, &["core", &ty_str, "MAX"][..]) {
+ +use clippy_utils::source::snippet_with_applicability;
++use clippy_utils::{match_def_path, path_def_id};
+ +use if_chain::if_chain;
+ +use rustc_ast::ast;
+ +use rustc_errors::Applicability;
+ +use rustc_hir as hir;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::layout::LayoutOf;
+ +
+ +pub fn check(
+ +    cx: &LateContext<'_>,
+ +    expr: &hir::Expr<'_>,
+ +    arith_lhs: &hir::Expr<'_>,
+ +    arith_rhs: &hir::Expr<'_>,
+ +    unwrap_arg: &hir::Expr<'_>,
+ +    arith: &str,
+ +) {
+ +    let ty = cx.typeck_results().expr_ty(arith_lhs);
+ +    if !ty.is_integral() {
+ +        return;
+ +    }
+ +
+ +    let mm = if let Some(mm) = is_min_or_max(cx, unwrap_arg) {
+ +        mm
+ +    } else {
+ +        return;
+ +    };
+ +
+ +    if ty.is_signed() {
+ +        use self::{
+ +            MinMax::{Max, Min},
+ +            Sign::{Neg, Pos},
+ +        };
+ +
+ +        let sign = if let Some(sign) = lit_sign(arith_rhs) {
+ +            sign
+ +        } else {
+ +            return;
+ +        };
+ +
+ +        match (arith, sign, mm) {
+ +            ("add", Pos, Max) | ("add", Neg, Min) | ("sub", Neg, Max) | ("sub", Pos, Min) => (),
+ +            // "mul" is omitted because lhs can be negative.
+ +            _ => return,
+ +        }
+ +    } else {
+ +        match (mm, arith) {
+ +            (MinMax::Max, "add" | "mul") | (MinMax::Min, "sub") => (),
+ +            _ => return,
+ +        }
+ +    }
+ +
+ +    let mut applicability = Applicability::MachineApplicable;
+ +    span_lint_and_sugg(
+ +        cx,
+ +        super::MANUAL_SATURATING_ARITHMETIC,
+ +        expr.span,
+ +        "manual saturating arithmetic",
+ +        &format!("try using `saturating_{}`", arith),
+ +        format!(
+ +            "{}.saturating_{}({})",
+ +            snippet_with_applicability(cx, arith_lhs.span, "..", &mut applicability),
+ +            arith,
+ +            snippet_with_applicability(cx, arith_rhs.span, "..", &mut applicability),
+ +        ),
+ +        applicability,
+ +    );
+ +}
+ +
+ +#[derive(PartialEq, Eq)]
+ +enum MinMax {
+ +    Min,
+ +    Max,
+ +}
+ +
+ +fn is_min_or_max<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option<MinMax> {
+ +    // `T::max_value()` `T::min_value()` inherent methods
+ +    if_chain! {
+ +        if let hir::ExprKind::Call(func, args) = &expr.kind;
+ +        if args.is_empty();
+ +        if let hir::ExprKind::Path(hir::QPath::TypeRelative(_, segment)) = &func.kind;
+ +        then {
+ +            match segment.ident.as_str() {
+ +                "max_value" => return Some(MinMax::Max),
+ +                "min_value" => return Some(MinMax::Min),
+ +                _ => {}
+ +            }
+ +        }
+ +    }
+ +
+ +    let ty = cx.typeck_results().expr_ty(expr);
+ +    let ty_str = ty.to_string();
+ +
+ +    // `std::T::MAX` `std::T::MIN` constants
-         if is_qpath_def_path(cx, path, expr.hir_id, &["core", &ty_str, "MIN"][..]) {
++    if let Some(id) = path_def_id(cx, expr) {
++        if match_def_path(cx, id, &["core", &ty_str, "MAX"]) {
+ +            return Some(MinMax::Max);
+ +        }
+ +
++        if match_def_path(cx, id, &["core", &ty_str, "MIN"]) {
+ +            return Some(MinMax::Min);
+ +        }
+ +    }
+ +
+ +    // Literals
+ +    let bits = cx.layout_of(ty).unwrap().size.bits();
+ +    let (minval, maxval): (u128, u128) = if ty.is_signed() {
+ +        let minval = 1 << (bits - 1);
+ +        let mut maxval = !(1 << (bits - 1));
+ +        if bits != 128 {
+ +            maxval &= (1 << bits) - 1;
+ +        }
+ +        (minval, maxval)
+ +    } else {
+ +        (0, if bits == 128 { !0 } else { (1 << bits) - 1 })
+ +    };
+ +
+ +    let check_lit = |expr: &hir::Expr<'_>, check_min: bool| {
+ +        if let hir::ExprKind::Lit(lit) = &expr.kind {
+ +            if let ast::LitKind::Int(value, _) = lit.node {
+ +                if value == maxval {
+ +                    return Some(MinMax::Max);
+ +                }
+ +
+ +                if check_min && value == minval {
+ +                    return Some(MinMax::Min);
+ +                }
+ +            }
+ +        }
+ +
+ +        None
+ +    };
+ +
+ +    if let r @ Some(_) = check_lit(expr, !ty.is_signed()) {
+ +        return r;
+ +    }
+ +
+ +    if ty.is_signed() {
+ +        if let hir::ExprKind::Unary(hir::UnOp::Neg, val) = &expr.kind {
+ +            return check_lit(val, true);
+ +        }
+ +    }
+ +
+ +    None
+ +}
+ +
+ +#[derive(PartialEq, Eq)]
+ +enum Sign {
+ +    Pos,
+ +    Neg,
+ +}
+ +
+ +fn lit_sign(expr: &hir::Expr<'_>) -> Option<Sign> {
+ +    if let hir::ExprKind::Unary(hir::UnOp::Neg, inner) = &expr.kind {
+ +        if let hir::ExprKind::Lit(..) = &inner.kind {
+ +            return Some(Sign::Neg);
+ +        }
+ +    } else if let hir::ExprKind::Lit(..) = &expr.kind {
+ +        return Some(Sign::Pos);
+ +    }
+ +
+ +    None
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/mod.rs

index 80e1eb86e6c6c10aecc7d38f0afbc37b1f405c76,0000000000000000000000000000000000000000..c2202cb1e57709517787801ef261964e9ebd2de9

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,2652 -1,0 +1,2662 @@@
-     /// `_.flat_map(_)`
+ +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};
+ +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
-             ("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),
++    /// `_.flat_map(_)` for `Iterator` or `_.and_then(_)` for `Option`
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let vec = vec![vec![1]];
++    /// let opt = Some(5);
+ +    ///
+ +    /// // Bad
+ +    /// vec.iter().map(|x| x.iter()).flatten();
++    /// opt.map(|x| Some(x * 2)).flatten();
+ +    ///
+ +    /// // Good
+ +    /// vec.iter().flat_map(|x| x.iter());
++    /// opt.and_then(|x| Some(x * 2));
+ +    /// ```
+ +    #[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, args, _) = recv.kind {
+ +        if !args.iter().any(|e| e.span.from_expansion()) {
+ +            let name = path.ident.name.as_str();
+ +            return Some((name, args, path.ident.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, args, _) => {
+ +                let method_span = method_call.ident.span;
+ +                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() {
+ +                        let assoc_ty = match projection_predicate.term {
+ +                            ty::Term::Ty(ty) => ty,
+ +                            ty::Term::Const(_c) => continue,
+ +                        };
+ +                        // walk the associated type and check for Self
+ +                        if let Some(self_adt) = self_ty.ty_adt_def() {
+ +                            if contains_adt_constructor(assoc_ty, self_adt) {
+ +                                return;
+ +                            }
+ +                        } else if contains_ty(assoc_ty, self_ty) {
+ +                            return;
+ +                        }
+ +                    }
+ +                }
+ +            }
+ +
+ +            if name == "new" && 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);
+ +                    }
+ +                },
+ +                _ => {},
+ +            },
+ +            (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);
+ +            },
+ +            (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),
+ +            (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),
+ +                        _ => {},
+ +                    }
+ +                }
+ +            },
+ +            ("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/option_map_or_none.rs

index 5e5c1038e829e76ddfe9a7007f19ca54328f9412,0000000000000000000000000000000000000000..bdf8cea120739f63b1092dc88cafc352cfb0f741

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/option_map_or_none.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/option_map_or_none.rs
@@@ -1,127 -1,0 +1,126 @@@
- use clippy_utils::{is_lang_ctor, single_segment_path};
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::source::snippet;
+ +use clippy_utils::ty::is_type_diagnostic_item;
-                 if let Some((func, arg_char)) = reduce_unit_expression(cx, &body.value);
-                 if arg_char.len() == 1;
-                 if let hir::ExprKind::Path(ref qpath) = func.kind;
-                 if let Some(segment) = single_segment_path(qpath);
-                 if segment.ident.name == sym::Some;
++use clippy_utils::{is_lang_ctor, path_def_id};
+ +use rustc_errors::Applicability;
+ +use rustc_hir as hir;
+ +use rustc_hir::LangItem::{OptionNone, OptionSome};
+ +use rustc_lint::LateContext;
++use rustc_middle::ty::DefIdTree;
+ +use rustc_span::symbol::sym;
+ +
+ +use super::OPTION_MAP_OR_NONE;
+ +use super::RESULT_MAP_OR_INTO_OPTION;
+ +
+ +// The expression inside a closure may or may not have surrounding braces
+ +// which causes problems when generating a suggestion.
+ +fn reduce_unit_expression<'a>(
+ +    cx: &LateContext<'_>,
+ +    expr: &'a hir::Expr<'_>,
+ +) -> Option<(&'a hir::Expr<'a>, &'a [hir::Expr<'a>])> {
+ +    match expr.kind {
+ +        hir::ExprKind::Call(func, arg_char) => Some((func, arg_char)),
+ +        hir::ExprKind::Block(block, _) => {
+ +            match (block.stmts, block.expr) {
+ +                (&[], Some(inner_expr)) => {
+ +                    // If block only contains an expression,
+ +                    // reduce `|x| { x + 1 }` to `|x| x + 1`
+ +                    reduce_unit_expression(cx, inner_expr)
+ +                },
+ +                _ => None,
+ +            }
+ +        },
+ +        _ => None,
+ +    }
+ +}
+ +
+ +/// lint use of `_.map_or(None, _)` for `Option`s and `Result`s
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    expr: &'tcx hir::Expr<'_>,
+ +    recv: &'tcx hir::Expr<'_>,
+ +    def_arg: &'tcx hir::Expr<'_>,
+ +    map_arg: &'tcx hir::Expr<'_>,
+ +) {
+ +    let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
+ +    let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
+ +
+ +    // There are two variants of this `map_or` lint:
+ +    // (1) using `map_or` as an adapter from `Result<T,E>` to `Option<T>`
+ +    // (2) using `map_or` as a combinator instead of `and_then`
+ +    //
+ +    // (For this lint) we don't care if any other type calls `map_or`
+ +    if !is_option && !is_result {
+ +        return;
+ +    }
+ +
+ +    let default_arg_is_none = if let hir::ExprKind::Path(ref qpath) = def_arg.kind {
+ +        is_lang_ctor(cx, qpath, OptionNone)
+ +    } else {
+ +        return;
+ +    };
+ +
+ +    if !default_arg_is_none {
+ +        // nothing to lint!
+ +        return;
+ +    }
+ +
+ +    let f_arg_is_some = if let hir::ExprKind::Path(ref qpath) = map_arg.kind {
+ +        is_lang_ctor(cx, qpath, OptionSome)
+ +    } else {
+ +        false
+ +    };
+ +
+ +    if is_option {
+ +        let self_snippet = snippet(cx, recv.span, "..");
+ +        if_chain! {
+ +        if let hir::ExprKind::Closure(_, _, id, span, _) = map_arg.kind;
+ +            let arg_snippet = snippet(cx, span, "..");
+ +            let body = cx.tcx.hir().body(id);
-                     let func_snippet = snippet(cx, arg_char[0].span, "..");
++                if let Some((func, [arg_char])) = reduce_unit_expression(cx, &body.value);
++                if let Some(id) = path_def_id(cx, func).and_then(|ctor_id| cx.tcx.parent(ctor_id));
++                if Some(id) == cx.tcx.lang_items().option_some_variant();
+ +                then {
++                    let func_snippet = snippet(cx, arg_char.span, "..");
+ +                    let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
+ +                       `map(..)` instead";
+ +                    return span_lint_and_sugg(
+ +                        cx,
+ +                        OPTION_MAP_OR_NONE,
+ +                        expr.span,
+ +                        msg,
+ +                        "try using `map` instead",
+ +                        format!("{0}.map({1} {2})", self_snippet, arg_snippet,func_snippet),
+ +                        Applicability::MachineApplicable,
+ +                    );
+ +                }
+ +
+ +        }
+ +
+ +        let func_snippet = snippet(cx, map_arg.span, "..");
+ +        let msg = "called `map_or(None, ..)` on an `Option` value. This can be done more directly by calling \
+ +                       `and_then(..)` instead";
+ +        return span_lint_and_sugg(
+ +            cx,
+ +            OPTION_MAP_OR_NONE,
+ +            expr.span,
+ +            msg,
+ +            "try using `and_then` instead",
+ +            format!("{0}.and_then({1})", self_snippet, func_snippet),
+ +            Applicability::MachineApplicable,
+ +        );
+ +    } else if f_arg_is_some {
+ +        let msg = "called `map_or(None, Some)` on a `Result` value. This can be done more directly by calling \
+ +                       `ok()` instead";
+ +        let self_snippet = snippet(cx, recv.span, "..");
+ +        return span_lint_and_sugg(
+ +            cx,
+ +            RESULT_MAP_OR_INTO_OPTION,
+ +            expr.span,
+ +            msg,
+ +            "try using `ok` instead",
+ +            format!("{0}.ok()", self_snippet),
+ +            Applicability::MachineApplicable,
+ +        );
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs

index 9c6f421103185c7f02437bc63372256642fa3111,0000000000000000000000000000000000000000..6c641af59f92b9c6a3f1b6941c01305f8b8bd464

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs
@@@ -1,140 -1,0 +1,139 @@@
- use clippy_utils::differing_macro_contexts;
+ +use clippy_utils::diagnostics::span_lint_and_then;
-         if differing_macro_contexts(unwrap_arg.span, map_span) {
+ +use clippy_utils::source::snippet_with_applicability;
+ +use clippy_utils::ty::is_copy;
+ +use clippy_utils::ty::is_type_diagnostic_item;
+ +use rustc_data_structures::fx::FxHashSet;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::intravisit::{walk_path, Visitor};
+ +use rustc_hir::{self, HirId, Path};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::hir::nested_filter;
+ +use rustc_span::source_map::Span;
+ +use rustc_span::{sym, Symbol};
+ +
+ +use super::MAP_UNWRAP_OR;
+ +
+ +/// lint use of `map().unwrap_or()` for `Option`s
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    expr: &rustc_hir::Expr<'_>,
+ +    recv: &rustc_hir::Expr<'_>,
+ +    map_arg: &'tcx rustc_hir::Expr<'_>,
+ +    unwrap_recv: &rustc_hir::Expr<'_>,
+ +    unwrap_arg: &'tcx rustc_hir::Expr<'_>,
+ +    map_span: Span,
+ +) {
+ +    // lint if the caller of `map()` is an `Option`
+ +    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option) {
+ +        if !is_copy(cx, cx.typeck_results().expr_ty(unwrap_arg)) {
+ +            // Do not lint if the `map` argument uses identifiers in the `map`
+ +            // argument that are also used in the `unwrap_or` argument
+ +
+ +            let mut unwrap_visitor = UnwrapVisitor {
+ +                cx,
+ +                identifiers: FxHashSet::default(),
+ +            };
+ +            unwrap_visitor.visit_expr(unwrap_arg);
+ +
+ +            let mut map_expr_visitor = MapExprVisitor {
+ +                cx,
+ +                identifiers: unwrap_visitor.identifiers,
+ +                found_identifier: false,
+ +            };
+ +            map_expr_visitor.visit_expr(map_arg);
+ +
+ +            if map_expr_visitor.found_identifier {
+ +                return;
+ +            }
+ +        }
+ +
++        if unwrap_arg.span.ctxt() != map_span.ctxt() {
+ +            return;
+ +        }
+ +
+ +        let mut applicability = Applicability::MachineApplicable;
+ +        // get snippet for unwrap_or()
+ +        let unwrap_snippet = snippet_with_applicability(cx, unwrap_arg.span, "..", &mut applicability);
+ +        // lint message
+ +        // comparing the snippet from source to raw text ("None") below is safe
+ +        // because we already have checked the type.
+ +        let arg = if unwrap_snippet == "None" { "None" } else { "<a>" };
+ +        let unwrap_snippet_none = unwrap_snippet == "None";
+ +        let suggest = if unwrap_snippet_none {
+ +            "and_then(<f>)"
+ +        } else {
+ +            "map_or(<a>, <f>)"
+ +        };
+ +        let msg = &format!(
+ +            "called `map(<f>).unwrap_or({})` on an `Option` value. \
+ +            This can be done more directly by calling `{}` instead",
+ +            arg, suggest
+ +        );
+ +
+ +        span_lint_and_then(cx, MAP_UNWRAP_OR, expr.span, msg, |diag| {
+ +            let map_arg_span = map_arg.span;
+ +
+ +            let mut suggestion = vec![
+ +                (
+ +                    map_span,
+ +                    String::from(if unwrap_snippet_none { "and_then" } else { "map_or" }),
+ +                ),
+ +                (expr.span.with_lo(unwrap_recv.span.hi()), String::from("")),
+ +            ];
+ +
+ +            if !unwrap_snippet_none {
+ +                suggestion.push((map_arg_span.with_hi(map_arg_span.lo()), format!("{}, ", unwrap_snippet)));
+ +            }
+ +
+ +            diag.multipart_suggestion(&format!("use `{}` instead", suggest), suggestion, applicability);
+ +        });
+ +    }
+ +}
+ +
+ +struct UnwrapVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,
+ +    identifiers: FxHashSet<Symbol>,
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for UnwrapVisitor<'a, 'tcx> {
+ +    type NestedFilter = nested_filter::All;
+ +
+ +    fn visit_path(&mut self, path: &'tcx Path<'_>, _id: HirId) {
+ +        self.identifiers.insert(ident(path));
+ +        walk_path(self, path);
+ +    }
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +}
+ +
+ +struct MapExprVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,
+ +    identifiers: FxHashSet<Symbol>,
+ +    found_identifier: bool,
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for MapExprVisitor<'a, 'tcx> {
+ +    type NestedFilter = nested_filter::All;
+ +
+ +    fn visit_path(&mut self, path: &'tcx Path<'_>, _id: HirId) {
+ +        if self.identifiers.contains(&ident(path)) {
+ +            self.found_identifier = true;
+ +            return;
+ +        }
+ +        walk_path(self, path);
+ +    }
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +}
+ +
+ +fn ident(path: &Path<'_>) -> Symbol {
+ +    path.segments
+ +        .last()
+ +        .expect("segments should be composed of at least 1 element")
+ +        .ident
+ +        .name
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/str_splitn.rs

index b2f624ed480e4cc903fcbebc08722105a9449037,0000000000000000000000000000000000000000..926c25b4b40a5c7aa2bd7c5003384ed5951fa857

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
@@@ -1,323 -1,0 +1,323 @@@
-                 if adjust.is_empty() {
+ +use clippy_utils::consts::{constant, Constant};
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::source::snippet_with_context;
+ +use clippy_utils::{is_diag_item_method, match_def_path, paths};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{Expr, ExprKind, HirId, LangItem, Node, QPath};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, adjustment::Adjust};
+ +use rustc_span::{symbol::sym, Span, SyntaxContext};
+ +
+ +use super::MANUAL_SPLIT_ONCE;
+ +
+ +pub(super) fn check_manual_split_once(
+ +    cx: &LateContext<'_>,
+ +    method_name: &str,
+ +    expr: &Expr<'_>,
+ +    self_arg: &Expr<'_>,
+ +    pat_arg: &Expr<'_>,
+ +) {
+ +    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
+ +        return;
+ +    }
+ +
+ +    let ctxt = expr.span.ctxt();
+ +    let (method_name, msg, reverse) = if method_name == "splitn" {
+ +        ("split_once", "manual implementation of `split_once`", false)
+ +    } else {
+ +        ("rsplit_once", "manual implementation of `rsplit_once`", true)
+ +    };
+ +    let usage = match parse_iter_usage(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), reverse) {
+ +        Some(x) => x,
+ +        None => return,
+ +    };
+ +
+ +    let mut app = Applicability::MachineApplicable;
+ +    let self_snip = snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0;
+ +    let pat_snip = snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0;
+ +
+ +    let sugg = match usage.kind {
+ +        IterUsageKind::NextTuple => {
+ +            format!("{}.{}({})", self_snip, method_name, pat_snip)
+ +        },
+ +        IterUsageKind::RNextTuple => format!("{}.{}({}).map(|(x, y)| (y, x))", self_snip, method_name, pat_snip),
+ +        IterUsageKind::Next | IterUsageKind::Second => {
+ +            let self_deref = {
+ +                let adjust = cx.typeck_results().expr_adjustments(self_arg);
-                     format!("&{}", "*".repeat(adjust.len() - 1))
++                if adjust.len() < 2 {
+ +                    String::new()
+ +                } else if cx.typeck_results().expr_ty(self_arg).is_box()
+ +                    || adjust
+ +                        .iter()
+ +                        .any(|a| matches!(a.kind, Adjust::Deref(Some(_))) || a.target.is_box())
+ +                {
-                     "*".repeat(adjust.len() - 2)
++                    format!("&{}", "*".repeat(adjust.len().saturating_sub(1)))
+ +                } else {
++                    "*".repeat(adjust.len().saturating_sub(2))
+ +                }
+ +            };
+ +            if matches!(usage.kind, IterUsageKind::Next) {
+ +                match usage.unwrap_kind {
+ +                    Some(UnwrapKind::Unwrap) => {
+ +                        if reverse {
+ +                            format!("{}.{}({}).unwrap().0", self_snip, method_name, pat_snip)
+ +                        } else {
+ +                            format!(
+ +                                "{}.{}({}).map_or({}{}, |x| x.0)",
+ +                                self_snip, method_name, pat_snip, self_deref, &self_snip
+ +                            )
+ +                        }
+ +                    },
+ +                    Some(UnwrapKind::QuestionMark) => {
+ +                        format!(
+ +                            "{}.{}({}).map_or({}{}, |x| x.0)",
+ +                            self_snip, method_name, pat_snip, self_deref, &self_snip
+ +                        )
+ +                    },
+ +                    None => {
+ +                        format!(
+ +                            "Some({}.{}({}).map_or({}{}, |x| x.0))",
+ +                            &self_snip, method_name, pat_snip, self_deref, &self_snip
+ +                        )
+ +                    },
+ +                }
+ +            } else {
+ +                match usage.unwrap_kind {
+ +                    Some(UnwrapKind::Unwrap) => {
+ +                        if reverse {
+ +                            // In this case, no better suggestion is offered.
+ +                            return;
+ +                        }
+ +                        format!("{}.{}({}).unwrap().1", self_snip, method_name, pat_snip)
+ +                    },
+ +                    Some(UnwrapKind::QuestionMark) => {
+ +                        format!("{}.{}({})?.1", self_snip, method_name, pat_snip)
+ +                    },
+ +                    None => {
+ +                        format!("{}.{}({}).map(|x| x.1)", self_snip, method_name, pat_snip)
+ +                    },
+ +                }
+ +            }
+ +        },
+ +    };
+ +
+ +    span_lint_and_sugg(cx, MANUAL_SPLIT_ONCE, usage.span, msg, "try this", sugg, app);
+ +}
+ +
+ +enum IterUsageKind {
+ +    Next,
+ +    Second,
+ +    NextTuple,
+ +    RNextTuple,
+ +}
+ +
+ +enum UnwrapKind {
+ +    Unwrap,
+ +    QuestionMark,
+ +}
+ +
+ +struct IterUsage {
+ +    kind: IterUsageKind,
+ +    unwrap_kind: Option<UnwrapKind>,
+ +    span: Span,
+ +}
+ +
+ +#[allow(clippy::too_many_lines)]
+ +fn parse_iter_usage<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    ctxt: SyntaxContext,
+ +    mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
+ +    reverse: bool,
+ +) -> Option<IterUsage> {
+ +    let (kind, span) = match iter.next() {
+ +        Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
+ +            let (name, args) = if let ExprKind::MethodCall(name, [_, args @ ..], _) = e.kind {
+ +                (name, args)
+ +            } else {
+ +                return None;
+ +            };
+ +            let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
+ +            let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?;
+ +
+ +            match (name.ident.as_str(), args) {
+ +                ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+ +                    if reverse {
+ +                        (IterUsageKind::Second, e.span)
+ +                    } else {
+ +                        (IterUsageKind::Next, e.span)
+ +                    }
+ +                },
+ +                ("next_tuple", []) => {
+ +                    return if_chain! {
+ +                        if match_def_path(cx, did, &paths::ITERTOOLS_NEXT_TUPLE);
+ +                        if let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind();
+ +                        if cx.tcx.is_diagnostic_item(sym::Option, adt_def.did);
+ +                        if let ty::Tuple(subs) = subs.type_at(0).kind();
+ +                        if subs.len() == 2;
+ +                        then {
+ +                            Some(IterUsage {
+ +                                kind: if reverse { IterUsageKind::RNextTuple } else { IterUsageKind::NextTuple },
+ +                                span: e.span,
+ +                                unwrap_kind: None
+ +                            })
+ +                        } else {
+ +                            None
+ +                        }
+ +                    };
+ +                },
+ +                ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+ +                    if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
+ +                        let span = if name.ident.as_str() == "nth" {
+ +                            e.span
+ +                        } else {
+ +                            if_chain! {
+ +                                if let Some((_, Node::Expr(next_expr))) = iter.next();
+ +                                if let ExprKind::MethodCall(next_name, [_], _) = next_expr.kind;
+ +                                if next_name.ident.name == sym::next;
+ +                                if next_expr.span.ctxt() == ctxt;
+ +                                if let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id);
+ +                                if cx.tcx.trait_of_item(next_id) == Some(iter_id);
+ +                                then {
+ +                                    next_expr.span
+ +                                } else {
+ +                                    return None;
+ +                                }
+ +                            }
+ +                        };
+ +                        match if reverse { idx ^ 1 } else { idx } {
+ +                            0 => (IterUsageKind::Next, span),
+ +                            1 => (IterUsageKind::Second, span),
+ +                            _ => return None,
+ +                        }
+ +                    } else {
+ +                        return None;
+ +                    }
+ +                },
+ +                _ => return None,
+ +            }
+ +        },
+ +        _ => return None,
+ +    };
+ +
+ +    let (unwrap_kind, span) = if let Some((_, Node::Expr(e))) = iter.next() {
+ +        match e.kind {
+ +            ExprKind::Call(
+ +                Expr {
+ +                    kind: ExprKind::Path(QPath::LangItem(LangItem::TryTraitBranch, ..)),
+ +                    ..
+ +                },
+ +                _,
+ +            ) => {
+ +                let parent_span = e.span.parent_callsite().unwrap();
+ +                if parent_span.ctxt() == ctxt {
+ +                    (Some(UnwrapKind::QuestionMark), parent_span)
+ +                } else {
+ +                    (None, span)
+ +                }
+ +            },
+ +            _ if e.span.ctxt() != ctxt => (None, span),
+ +            ExprKind::MethodCall(name, [_], _)
+ +                if name.ident.name == sym::unwrap
+ +                    && cx
+ +                        .typeck_results()
+ +                        .type_dependent_def_id(e.hir_id)
+ +                        .map_or(false, |id| is_diag_item_method(cx, id, sym::Option)) =>
+ +            {
+ +                (Some(UnwrapKind::Unwrap), e.span)
+ +            },
+ +            _ => (None, span),
+ +        }
+ +    } else {
+ +        (None, span)
+ +    };
+ +
+ +    Some(IterUsage {
+ +        kind,
+ +        unwrap_kind,
+ +        span,
+ +    })
+ +}
+ +
+ +use super::NEEDLESS_SPLITN;
+ +
+ +pub(super) fn check_needless_splitn(
+ +    cx: &LateContext<'_>,
+ +    method_name: &str,
+ +    expr: &Expr<'_>,
+ +    self_arg: &Expr<'_>,
+ +    pat_arg: &Expr<'_>,
+ +    count: u128,
+ +) {
+ +    if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
+ +        return;
+ +    }
+ +    let ctxt = expr.span.ctxt();
+ +    let mut app = Applicability::MachineApplicable;
+ +    let (reverse, message) = if method_name == "splitn" {
+ +        (false, "unnecessary use of `splitn`")
+ +    } else {
+ +        (true, "unnecessary use of `rsplitn`")
+ +    };
+ +    if_chain! {
+ +        if count >= 2;
+ +        if check_iter(cx, ctxt, cx.tcx.hir().parent_iter(expr.hir_id), count);
+ +        then {
+ +            span_lint_and_sugg(
+ +                cx,
+ +                NEEDLESS_SPLITN,
+ +                expr.span,
+ +                message,
+ +                "try this",
+ +                format!(
+ +                    "{}.{}({})",
+ +                    snippet_with_context(cx, self_arg.span, ctxt, "..", &mut app).0,
+ +                    if reverse {"rsplit"} else {"split"},
+ +                    snippet_with_context(cx, pat_arg.span, ctxt, "..", &mut app).0
+ +                ),
+ +                app,
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +fn check_iter<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    ctxt: SyntaxContext,
+ +    mut iter: impl Iterator<Item = (HirId, Node<'tcx>)>,
+ +    count: u128,
+ +) -> bool {
+ +    match iter.next() {
+ +        Some((_, Node::Expr(e))) if e.span.ctxt() == ctxt => {
+ +            let (name, args) = if let ExprKind::MethodCall(name, [_, args @ ..], _) = e.kind {
+ +                (name, args)
+ +            } else {
+ +                return false;
+ +            };
+ +            if_chain! {
+ +                if let Some(did) = cx.typeck_results().type_dependent_def_id(e.hir_id);
+ +                if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator);
+ +                then {
+ +                    match (name.ident.as_str(), args) {
+ +                        ("next", []) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+ +                            return true;
+ +                        },
+ +                        ("next_tuple", []) if count > 2 => {
+ +                            return true;
+ +                        },
+ +                        ("nth", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
+ +                            if let Some((Constant::Int(idx), _)) = constant(cx, cx.typeck_results(), idx_expr) {
+ +                                if count > idx + 1 {
+ +                                    return true;
+ +                                }
+ +                            }
+ +                        },
+ +                        _ =>  return false,
+ +                    }
+ +                }
+ +            }
+ +        },
+ +        _ => return false,
+ +    };
+ +    false
+ +}
diff --cc src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs

index ccfce31713f93469b7e620b8b65770abc1e2ad9f,0000000000000000000000000000000000000000..12ad3d8d69038d3016ebf021f0fa7895603fa749

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs
@@@ -1,124 -1,0 +1,122 @@@
-                 ty::Adt(adt, subst)
-                     if cx.tcx.is_diagnostic_item(sym::Option, adt.did) && in_ty == subst.type_at(0) =>
-                 {
+ +use clippy_utils::diagnostics::span_lint;
+ +use clippy_utils::usage::mutated_variables;
+ +use clippy_utils::{is_lang_ctor, is_trait_method, path_to_local_id};
+ +use rustc_hir as hir;
+ +use rustc_hir::intravisit::{walk_expr, Visitor};
+ +use rustc_hir::LangItem::{OptionNone, OptionSome};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty;
+ +use rustc_span::sym;
+ +
+ +use super::UNNECESSARY_FILTER_MAP;
+ +
+ +pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, arg: &hir::Expr<'_>) {
+ +    if !is_trait_method(cx, expr, sym::Iterator) {
+ +        return;
+ +    }
+ +
+ +    if let hir::ExprKind::Closure(_, _, body_id, ..) = arg.kind {
+ +        let body = cx.tcx.hir().body(body_id);
+ +        let arg_id = body.params[0].pat.hir_id;
+ +        let mutates_arg =
+ +            mutated_variables(&body.value, cx).map_or(true, |used_mutably| used_mutably.contains(&arg_id));
+ +
+ +        let (mut found_mapping, mut found_filtering) = check_expression(cx, arg_id, &body.value);
+ +
+ +        let mut return_visitor = ReturnVisitor::new(cx, arg_id);
+ +        return_visitor.visit_expr(&body.value);
+ +        found_mapping |= return_visitor.found_mapping;
+ +        found_filtering |= return_visitor.found_filtering;
+ +
+ +        let sugg = if !found_filtering {
+ +            "map"
+ +        } else if !found_mapping && !mutates_arg {
+ +            let in_ty = cx.typeck_results().node_type(body.params[0].hir_id);
+ +            match cx.typeck_results().expr_ty(&body.value).kind() {
++                ty::Adt(adt, subst) if cx.tcx.is_diagnostic_item(sym::Option, adt.did) && in_ty == subst.type_at(0) => {
+ +                    "filter"
+ +                },
+ +                _ => return,
+ +            }
+ +        } else {
+ +            return;
+ +        };
+ +        span_lint(
+ +            cx,
+ +            UNNECESSARY_FILTER_MAP,
+ +            expr.span,
+ +            &format!("this `.filter_map` can be written more simply using `.{}`", sugg),
+ +        );
+ +    }
+ +}
+ +
+ +// returns (found_mapping, found_filtering)
+ +fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tcx hir::Expr<'_>) -> (bool, bool) {
+ +    match &expr.kind {
+ +        hir::ExprKind::Call(func, args) => {
+ +            if let hir::ExprKind::Path(ref path) = func.kind {
+ +                if is_lang_ctor(cx, path, OptionSome) {
+ +                    if path_to_local_id(&args[0], arg_id) {
+ +                        return (false, false);
+ +                    }
+ +                    return (true, false);
+ +                }
+ +            }
+ +            (true, true)
+ +        },
+ +        hir::ExprKind::Block(block, _) => block
+ +            .expr
+ +            .as_ref()
+ +            .map_or((false, false), |expr| check_expression(cx, arg_id, expr)),
+ +        hir::ExprKind::Match(_, arms, _) => {
+ +            let mut found_mapping = false;
+ +            let mut found_filtering = false;
+ +            for arm in *arms {
+ +                let (m, f) = check_expression(cx, arg_id, arm.body);
+ +                found_mapping |= m;
+ +                found_filtering |= f;
+ +            }
+ +            (found_mapping, found_filtering)
+ +        },
+ +        // There must be an else_arm or there will be a type error
+ +        hir::ExprKind::If(_, if_arm, Some(else_arm)) => {
+ +            let if_check = check_expression(cx, arg_id, if_arm);
+ +            let else_check = check_expression(cx, arg_id, else_arm);
+ +            (if_check.0 | else_check.0, if_check.1 | else_check.1)
+ +        },
+ +        hir::ExprKind::Path(path) if is_lang_ctor(cx, path, OptionNone) => (false, true),
+ +        _ => (true, true),
+ +    }
+ +}
+ +
+ +struct ReturnVisitor<'a, 'tcx> {
+ +    cx: &'a LateContext<'tcx>,
+ +    arg_id: hir::HirId,
+ +    // Found a non-None return that isn't Some(input)
+ +    found_mapping: bool,
+ +    // Found a return that isn't Some
+ +    found_filtering: bool,
+ +}
+ +
+ +impl<'a, 'tcx> ReturnVisitor<'a, 'tcx> {
+ +    fn new(cx: &'a LateContext<'tcx>, arg_id: hir::HirId) -> ReturnVisitor<'a, 'tcx> {
+ +        ReturnVisitor {
+ +            cx,
+ +            arg_id,
+ +            found_mapping: false,
+ +            found_filtering: false,
+ +        }
+ +    }
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for ReturnVisitor<'a, 'tcx> {
+ +    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'_>) {
+ +        if let hir::ExprKind::Ret(Some(expr)) = &expr.kind {
+ +            let (found_mapping, found_filtering) = check_expression(self.cx, self.arg_id, expr);
+ +            self.found_mapping |= found_mapping;
+ +            self.found_filtering |= found_filtering;
+ +        } else {
+ +            walk_expr(self, expr);
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/misc.rs

index 3918bdbdf4387cc7e5bc926df8d5519bfdd684b8,0000000000000000000000000000000000000000..ac82dd306a52879d1d96976dac46938d06abd974

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,806 -1,0 +1,805 @@@
-     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,
+ +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::{
-             if expr_path_res(cx, path)
-                 .opt_def_id()
++    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, path_def_id, 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 path_def_id(cx, path)
+ +                .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!(
+ +                        "{}{}{}",
+ +                        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/missing_enforced_import_rename.rs

index 566e15ab2a6d640aff7e55090733d58c4313762b,0000000000000000000000000000000000000000..3d0a23822838e871c3c6ef5f891aa4303505b7d3

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/missing_enforced_import_rename.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/missing_enforced_import_rename.rs
@@@ -1,102 -1,0 +1,102 @@@
-             if let Res::Def(_, id) = clippy_utils::path_to_res(cx, &path.split("::").collect::<Vec<_>>()) {
+ +use clippy_utils::{diagnostics::span_lint_and_sugg, source::snippet_opt};
+ +
+ +use rustc_data_structures::fx::FxHashMap;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{def::Res, def_id::DefId, Item, ItemKind, UseKind};
+ +use rustc_lint::{LateContext, LateLintPass, LintContext};
+ +use rustc_session::{declare_tool_lint, impl_lint_pass};
+ +use rustc_span::Symbol;
+ +
+ +use crate::utils::conf::Rename;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for imports that do not rename the item as specified
+ +    /// in the `enforce-import-renames` config option.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Consistency is important, if a project has defined import
+ +    /// renames they should be followed. More practically, some item names are too
+ +    /// vague outside of their defining scope this can enforce a more meaningful naming.
+ +    ///
+ +    /// ### Example
+ +    /// An example clippy.toml configuration:
+ +    /// ```toml
+ +    /// # clippy.toml
+ +    /// enforced-import-renames = [ { path = "serde_json::Value", rename = "JsonValue" }]
+ +    /// ```
+ +    ///
+ +    /// ```rust,ignore
+ +    /// use serde_json::Value;
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust,ignore
+ +    /// use serde_json::Value as JsonValue;
+ +    /// ```
+ +    #[clippy::version = "1.55.0"]
+ +    pub MISSING_ENFORCED_IMPORT_RENAMES,
+ +    restriction,
+ +    "enforce import renames"
+ +}
+ +
+ +pub struct ImportRename {
+ +    conf_renames: Vec<Rename>,
+ +    renames: FxHashMap<DefId, Symbol>,
+ +}
+ +
+ +impl ImportRename {
+ +    pub fn new(conf_renames: Vec<Rename>) -> Self {
+ +        Self {
+ +            conf_renames,
+ +            renames: FxHashMap::default(),
+ +        }
+ +    }
+ +}
+ +
+ +impl_lint_pass!(ImportRename => [MISSING_ENFORCED_IMPORT_RENAMES]);
+ +
+ +impl LateLintPass<'_> for ImportRename {
+ +    fn check_crate(&mut self, cx: &LateContext<'_>) {
+ +        for Rename { path, rename } in &self.conf_renames {
++            if let Res::Def(_, id) = clippy_utils::def_path_res(cx, &path.split("::").collect::<Vec<_>>()) {
+ +                self.renames.insert(id, Symbol::intern(rename));
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
+ +        if_chain! {
+ +            if let ItemKind::Use(path, UseKind::Single) = &item.kind;
+ +            if let Res::Def(_, id) = path.res;
+ +            if let Some(name) = self.renames.get(&id);
+ +            // Remove semicolon since it is not present for nested imports
+ +            let span_without_semi = cx.sess().source_map().span_until_char(item.span, ';');
+ +            if let Some(snip) = snippet_opt(cx, span_without_semi);
+ +            if let Some(import) = match snip.split_once(" as ") {
+ +                None => Some(snip.as_str()),
+ +                Some((import, rename)) => {
+ +                    if rename.trim() == name.as_str() {
+ +                        None
+ +                    } else {
+ +                        Some(import.trim())
+ +                    }
+ +                },
+ +            };
+ +            then {
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    MISSING_ENFORCED_IMPORT_RENAMES,
+ +                    span_without_semi,
+ +                    "this import should be renamed",
+ +                    "try",
+ +                    format!(
+ +                        "{} as {}",
+ +                        import,
+ +                        name,
+ +                    ),
+ +                    Applicability::MachineApplicable,
+ +                );
+ +            }
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/ptr.rs

index b5d65542de0bf1c068279149bb67df8615006a81,0000000000000000000000000000000000000000..e0ce1b7db003afb96091e912a701d1e0ab2f7a84

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/ptr.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/ptr.rs
@@@ -1,674 -1,0 +1,680 @@@
- use clippy_utils::{
-     expr_path_res, get_expr_use_or_unification_node, is_lint_allowed, match_any_diagnostic_items, path_to_local, paths,
- };
+ +//! Checks for usage of  `&Vec[_]` and `&String`.
+ +
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
+ +use clippy_utils::source::snippet_opt;
+ +use clippy_utils::ty::expr_sig;
-             ) {
++use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local, paths};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::def_id::DefId;
+ +use rustc_hir::hir_id::HirIdMap;
+ +use rustc_hir::intravisit::{walk_expr, Visitor};
+ +use rustc_hir::{
+ +    self as hir, AnonConst, BinOpKind, BindingAnnotation, Body, Expr, ExprKind, FnDecl, FnRetTy, GenericArg,
+ +    ImplItemKind, ItemKind, Lifetime, LifetimeName, Mutability, Node, Param, ParamName, PatKind, QPath, TraitFn,
+ +    TraitItem, TraitItemKind, TyKind,
+ +};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_middle::hir::nested_filter;
+ +use rustc_middle::ty::{self, AssocItems, AssocKind, Ty};
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::source_map::Span;
+ +use rustc_span::symbol::Symbol;
+ +use rustc_span::{sym, MultiSpan};
+ +use std::fmt;
+ +use std::iter;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// This lint checks for function arguments of type `&String`, `&Vec`,
+ +    /// `&PathBuf`, and `Cow<_>`. It will also suggest you replace `.clone()` calls
+ +    /// with the appropriate `.to_owned()`/`to_string()` calls.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Requiring the argument to be of the specific size
+ +    /// makes the function less useful for no benefit; slices in the form of `&[T]`
+ +    /// or `&str` usually suffice and can be obtained from other types, too.
+ +    ///
+ +    /// ### Known problems
+ +    /// There may be `fn(&Vec)`-typed references pointing to your function.
+ +    /// If you have them, you will get a compiler error after applying this lint's
+ +    /// suggestions. You then have the choice to undo your changes or change the
+ +    /// type of the reference.
+ +    ///
+ +    /// Note that if the function is part of your public interface, there may be
+ +    /// other crates referencing it, of which you may not be aware. Carefully
+ +    /// deprecate the function before applying the lint suggestions in this case.
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// // Bad
+ +    /// fn foo(&Vec<u32>) { .. }
+ +    ///
+ +    /// // Good
+ +    /// fn foo(&[u32]) { .. }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub PTR_ARG,
+ +    style,
+ +    "fn arguments of the type `&Vec<...>` or `&String`, suggesting to use `&[...]` or `&str` instead, respectively"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// This lint checks for equality comparisons with `ptr::null`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It's easier and more readable to use the inherent
+ +    /// `.is_null()`
+ +    /// method instead
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// // Bad
+ +    /// if x == ptr::null {
+ +    ///     ..
+ +    /// }
+ +    ///
+ +    /// // Good
+ +    /// if x.is_null() {
+ +    ///     ..
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub CMP_NULL,
+ +    style,
+ +    "comparing a pointer to a null pointer, suggesting to use `.is_null()` instead"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// This lint checks for functions that take immutable
+ +    /// references and return mutable ones.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is trivially unsound, as one can create two
+ +    /// mutable references from the same (immutable!) source.
+ +    /// This [error](https://github.com/rust-lang/rust/issues/39465)
+ +    /// actually lead to an interim Rust release 1.15.1.
+ +    ///
+ +    /// ### Known problems
+ +    /// To be on the conservative side, if there's at least one
+ +    /// mutable reference with the output lifetime, this lint will not trigger.
+ +    /// In practice, this case is unlikely anyway.
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// fn foo(&Foo) -> &mut Bar { .. }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub MUT_FROM_REF,
+ +    correctness,
+ +    "fns that create mutable refs from immutable ref args"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// This lint checks for invalid usages of `ptr::null`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This causes undefined behavior.
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// // Bad. Undefined behavior
+ +    /// unsafe { std::slice::from_raw_parts(ptr::null(), 0); }
+ +    /// ```
+ +    ///
+ +    /// ```ignore
+ +    /// // Good
+ +    /// unsafe { std::slice::from_raw_parts(NonNull::dangling().as_ptr(), 0); }
+ +    /// ```
+ +    #[clippy::version = "1.53.0"]
+ +    pub INVALID_NULL_PTR_USAGE,
+ +    correctness,
+ +    "invalid usage of a null pointer, suggesting `NonNull::dangling()` instead"
+ +}
+ +
+ +declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF, INVALID_NULL_PTR_USAGE]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for Ptr {
+ +    fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx TraitItem<'_>) {
+ +        if let TraitItemKind::Fn(sig, trait_method) = &item.kind {
+ +            if matches!(trait_method, TraitFn::Provided(_)) {
+ +                // Handled by check body.
+ +                return;
+ +            }
+ +
+ +            check_mut_from_ref(cx, sig.decl);
+ +            for arg in check_fn_args(
+ +                cx,
+ +                cx.tcx.fn_sig(item.def_id).skip_binder().inputs(),
+ +                sig.decl.inputs,
+ +                &[],
-         let (item_id, decl) = match parents.next() {
++            )
++            .filter(|arg| arg.mutability() == Mutability::Not)
++            {
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    PTR_ARG,
+ +                    arg.span,
+ +                    &arg.build_msg(),
+ +                    "change this to",
+ +                    format!("{}{}", arg.ref_prefix, arg.deref_ty.display(cx)),
+ +                    Applicability::Unspecified,
+ +                );
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
+ +        let hir = cx.tcx.hir();
+ +        let mut parents = hir.parent_iter(body.value.hir_id);
-                     (i.def_id, sig.decl)
++        let (item_id, decl, is_trait_item) = match parents.next() {
+ +            Some((_, Node::Item(i))) => {
+ +                if let ItemKind::Fn(sig, ..) = &i.kind {
-                     (i.def_id, sig.decl)
++                    (i.def_id, sig.decl, false)
+ +                } else {
+ +                    return;
+ +                }
+ +            },
+ +            Some((_, Node::ImplItem(i))) => {
+ +                if !matches!(parents.next(),
+ +                    Some((_, Node::Item(i))) if matches!(&i.kind, ItemKind::Impl(i) if i.of_trait.is_none())
+ +                ) {
+ +                    return;
+ +                }
+ +                if let ImplItemKind::Fn(sig, _) = &i.kind {
-                     (i.def_id, sig.decl)
++                    (i.def_id, sig.decl, false)
+ +                } else {
+ +                    return;
+ +                }
+ +            },
+ +            Some((_, Node::TraitItem(i))) => {
+ +                if let TraitItemKind::Fn(sig, _) = &i.kind {
-         let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, body.params).collect();
++                    (i.def_id, sig.decl, true)
+ +                } else {
+ +                    return;
+ +                }
+ +            },
+ +            _ => return,
+ +        };
+ +
+ +        check_mut_from_ref(cx, decl);
+ +        let sig = cx.tcx.fn_sig(item_id).skip_binder();
-                         results[arg.idx].skip = true;
++        let lint_args: Vec<_> = check_fn_args(cx, sig.inputs(), decl.inputs, body.params)
++            .filter(|arg| !is_trait_item || arg.mutability() == Mutability::Not)
++            .collect();
+ +        let results = check_ptr_arg_usage(cx, body, &lint_args);
+ +
+ +        for (result, args) in results.iter().zip(lint_args.iter()).filter(|(r, _)| !r.skip) {
+ +            span_lint_and_then(cx, PTR_ARG, args.span, &args.build_msg(), |diag| {
+ +                diag.multipart_suggestion(
+ +                    "change this to",
+ +                    iter::once((args.span, format!("{}{}", args.ref_prefix, args.deref_ty.display(cx))))
+ +                        .chain(result.replacements.iter().map(|r| {
+ +                            (
+ +                                r.expr_span,
+ +                                format!("{}{}", snippet_opt(cx, r.self_span).unwrap(), r.replacement),
+ +                            )
+ +                        }))
+ +                        .collect(),
+ +                    Applicability::Unspecified,
+ +                );
+ +            });
+ +        }
+ +    }
+ +
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        if let ExprKind::Binary(ref op, l, r) = expr.kind {
+ +            if (op.node == BinOpKind::Eq || op.node == BinOpKind::Ne) && (is_null_path(cx, l) || is_null_path(cx, r)) {
+ +                span_lint(
+ +                    cx,
+ +                    CMP_NULL,
+ +                    expr.span,
+ +                    "comparing with null is better expressed by the `.is_null()` method",
+ +                );
+ +            }
+ +        } else {
+ +            check_invalid_ptr_usage(cx, expr);
+ +        }
+ +    }
+ +}
+ +
+ +fn check_invalid_ptr_usage<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +    // (fn_path, arg_indices) - `arg_indices` are the `arg` positions where null would cause U.B.
+ +    const INVALID_NULL_PTR_USAGE_TABLE: [(&[&str], &[usize]); 16] = [
+ +        (&paths::SLICE_FROM_RAW_PARTS, &[0]),
+ +        (&paths::SLICE_FROM_RAW_PARTS_MUT, &[0]),
+ +        (&paths::PTR_COPY, &[0, 1]),
+ +        (&paths::PTR_COPY_NONOVERLAPPING, &[0, 1]),
+ +        (&paths::PTR_READ, &[0]),
+ +        (&paths::PTR_READ_UNALIGNED, &[0]),
+ +        (&paths::PTR_READ_VOLATILE, &[0]),
+ +        (&paths::PTR_REPLACE, &[0]),
+ +        (&paths::PTR_SLICE_FROM_RAW_PARTS, &[0]),
+ +        (&paths::PTR_SLICE_FROM_RAW_PARTS_MUT, &[0]),
+ +        (&paths::PTR_SWAP, &[0, 1]),
+ +        (&paths::PTR_SWAP_NONOVERLAPPING, &[0, 1]),
+ +        (&paths::PTR_WRITE, &[0]),
+ +        (&paths::PTR_WRITE_UNALIGNED, &[0]),
+ +        (&paths::PTR_WRITE_VOLATILE, &[0]),
+ +        (&paths::PTR_WRITE_BYTES, &[0]),
+ +    ];
+ +
+ +    if_chain! {
+ +        if let ExprKind::Call(fun, args) = expr.kind;
+ +        if let ExprKind::Path(ref qpath) = fun.kind;
+ +        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+ +        let fun_def_path = cx.get_def_path(fun_def_id).into_iter().map(Symbol::to_ident_string).collect::<Vec<_>>();
+ +        if let Some(&(_, arg_indices)) = INVALID_NULL_PTR_USAGE_TABLE
+ +            .iter()
+ +            .find(|&&(fn_path, _)| fn_path == fun_def_path);
+ +        then {
+ +            for &arg_idx in arg_indices {
+ +                if let Some(arg) = args.get(arg_idx).filter(|arg| is_null_path(cx, arg)) {
+ +                    span_lint_and_sugg(
+ +                        cx,
+ +                        INVALID_NULL_PTR_USAGE,
+ +                        arg.span,
+ +                        "pointer must be non-null",
+ +                        "change this to",
+ +                        "core::ptr::NonNull::dangling().as_ptr()".to_string(),
+ +                        Applicability::MachineApplicable,
+ +                    );
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +#[derive(Default)]
+ +struct PtrArgResult {
+ +    skip: bool,
+ +    replacements: Vec<PtrArgReplacement>,
+ +}
+ +
+ +struct PtrArgReplacement {
+ +    expr_span: Span,
+ +    self_span: Span,
+ +    replacement: &'static str,
+ +}
+ +
+ +struct PtrArg<'tcx> {
+ +    idx: usize,
+ +    span: Span,
+ +    ty_did: DefId,
+ +    ty_name: Symbol,
+ +    method_renames: &'static [(&'static str, &'static str)],
+ +    ref_prefix: RefPrefix,
+ +    deref_ty: DerefTy<'tcx>,
+ +    deref_assoc_items: Option<(DefId, &'tcx AssocItems<'tcx>)>,
+ +}
+ +impl PtrArg<'_> {
+ +    fn build_msg(&self) -> String {
+ +        format!(
+ +            "writing `&{}{}` instead of `&{}{}` involves a new object where a slice will do",
+ +            self.ref_prefix.mutability.prefix_str(),
+ +            self.ty_name,
+ +            self.ref_prefix.mutability.prefix_str(),
+ +            self.deref_ty.argless_str(),
+ +        )
+ +    }
++
++    fn mutability(&self) -> Mutability {
++        self.ref_prefix.mutability
++    }
+ +}
+ +
+ +struct RefPrefix {
+ +    lt: LifetimeName,
+ +    mutability: Mutability,
+ +}
+ +impl fmt::Display for RefPrefix {
+ +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ +        use fmt::Write;
+ +        f.write_char('&')?;
+ +        match self.lt {
+ +            LifetimeName::Param(ParamName::Plain(name)) => {
+ +                name.fmt(f)?;
+ +                f.write_char(' ')?;
+ +            },
+ +            LifetimeName::Underscore => f.write_str("'_ ")?,
+ +            LifetimeName::Static => f.write_str("'static ")?,
+ +            _ => (),
+ +        }
+ +        f.write_str(self.mutability.prefix_str())
+ +    }
+ +}
+ +
+ +struct DerefTyDisplay<'a, 'tcx>(&'a LateContext<'tcx>, &'a DerefTy<'tcx>);
+ +impl fmt::Display for DerefTyDisplay<'_, '_> {
+ +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ +        use std::fmt::Write;
+ +        match self.1 {
+ +            DerefTy::Str => f.write_str("str"),
+ +            DerefTy::Path => f.write_str("Path"),
+ +            DerefTy::Slice(hir_ty, ty) => {
+ +                f.write_char('[')?;
+ +                match hir_ty.and_then(|s| snippet_opt(self.0, s)) {
+ +                    Some(s) => f.write_str(&s)?,
+ +                    None => ty.fmt(f)?,
+ +                }
+ +                f.write_char(']')
+ +            },
+ +        }
+ +    }
+ +}
+ +
+ +enum DerefTy<'tcx> {
+ +    Str,
+ +    Path,
+ +    Slice(Option<Span>, Ty<'tcx>),
+ +}
+ +impl<'tcx> DerefTy<'tcx> {
+ +    fn argless_str(&self) -> &'static str {
+ +        match *self {
+ +            Self::Str => "str",
+ +            Self::Path => "Path",
+ +            Self::Slice(..) => "[_]",
+ +        }
+ +    }
+ +
+ +    fn display<'a>(&'a self, cx: &'a LateContext<'tcx>) -> DerefTyDisplay<'a, 'tcx> {
+ +        DerefTyDisplay(cx, self)
+ +    }
+ +}
+ +
+ +fn check_fn_args<'cx, 'tcx: 'cx>(
+ +    cx: &'cx LateContext<'tcx>,
+ +    tys: &'tcx [Ty<'_>],
+ +    hir_tys: &'tcx [hir::Ty<'_>],
+ +    params: &'tcx [Param<'_>],
+ +) -> impl Iterator<Item = PtrArg<'tcx>> + 'cx {
+ +    tys.iter()
+ +        .zip(hir_tys.iter())
+ +        .enumerate()
+ +        .filter_map(|(i, (ty, hir_ty))| {
+ +            if_chain! {
+ +                if let ty::Ref(_, ty, mutability) = *ty.kind();
+ +                if let ty::Adt(adt, substs) = *ty.kind();
+ +
+ +                if let TyKind::Rptr(lt, ref ty) = hir_ty.kind;
+ +                if let TyKind::Path(QPath::Resolved(None, path)) = ty.ty.kind;
+ +
+ +                // Check that the name as typed matches the actual name of the type.
+ +                // e.g. `fn foo(_: &Foo)` shouldn't trigger the lint when `Foo` is an alias for `Vec`
+ +                if let [.., name] = path.segments;
+ +                if cx.tcx.item_name(adt.did) == name.ident.name;
+ +
+ +                if !is_lint_allowed(cx, PTR_ARG, hir_ty.hir_id);
+ +                if params.get(i).map_or(true, |p| !is_lint_allowed(cx, PTR_ARG, p.hir_id));
+ +
+ +                then {
+ +                    let (method_renames, deref_ty, deref_impl_id) = match cx.tcx.get_diagnostic_name(adt.did) {
+ +                        Some(sym::Vec) => (
+ +                            [("clone", ".to_owned()")].as_slice(),
+ +                            DerefTy::Slice(
+ +                                name.args
+ +                                    .and_then(|args| args.args.first())
+ +                                    .and_then(|arg| if let GenericArg::Type(ty) = arg {
+ +                                        Some(ty.span)
+ +                                    } else {
+ +                                        None
+ +                                    }),
+ +                                substs.type_at(0),
+ +                            ),
+ +                            cx.tcx.lang_items().slice_impl()
+ +                        ),
+ +                        Some(sym::String) => (
+ +                            [("clone", ".to_owned()"), ("as_str", "")].as_slice(),
+ +                            DerefTy::Str,
+ +                            cx.tcx.lang_items().str_impl()
+ +                        ),
+ +                        Some(sym::PathBuf) => (
+ +                            [("clone", ".to_path_buf()"), ("as_path", "")].as_slice(),
+ +                            DerefTy::Path,
+ +                            None,
+ +                        ),
+ +                        Some(sym::Cow) => {
+ +                            let ty_name = name.args
+ +                                .and_then(|args| {
+ +                                    args.args.iter().find_map(|a| match a {
+ +                                        GenericArg::Type(x) => Some(x),
+ +                                        _ => None,
+ +                                    })
+ +                                })
+ +                                .and_then(|arg| snippet_opt(cx, arg.span))
+ +                                .unwrap_or_else(|| substs.type_at(1).to_string());
+ +                            span_lint_and_sugg(
+ +                                cx,
+ +                                PTR_ARG,
+ +                                hir_ty.span,
+ +                                "using a reference to `Cow` is not recommended",
+ +                                "change this to",
+ +                                format!("&{}{}", mutability.prefix_str(), ty_name),
+ +                                Applicability::Unspecified,
+ +                            );
+ +                            return None;
+ +                        },
+ +                        _ => return None,
+ +                    };
+ +                    return Some(PtrArg {
+ +                        idx: i,
+ +                        span: hir_ty.span,
+ +                        ty_did: adt.did,
+ +                        ty_name: name.ident.name,
+ +                        method_renames,
+ +                        ref_prefix: RefPrefix {
+ +                            lt: lt.name,
+ +                            mutability,
+ +                        },
+ +                        deref_ty,
+ +                        deref_assoc_items: deref_impl_id.map(|id| (id, cx.tcx.associated_items(id))),
+ +                    });
+ +                }
+ +            }
+ +            None
+ +        })
+ +}
+ +
+ +fn check_mut_from_ref(cx: &LateContext<'_>, decl: &FnDecl<'_>) {
+ +    if let FnRetTy::Return(ty) = decl.output {
+ +        if let Some((out, Mutability::Mut, _)) = get_rptr_lm(ty) {
+ +            let mut immutables = vec![];
+ +            for (_, mutbl, argspan) in decl
+ +                .inputs
+ +                .iter()
+ +                .filter_map(get_rptr_lm)
+ +                .filter(|&(lt, _, _)| lt.name == out.name)
+ +            {
+ +                if mutbl == Mutability::Mut {
+ +                    return;
+ +                }
+ +                immutables.push(argspan);
+ +            }
+ +            if immutables.is_empty() {
+ +                return;
+ +            }
+ +            span_lint_and_then(
+ +                cx,
+ +                MUT_FROM_REF,
+ +                ty.span,
+ +                "mutable borrow from immutable input(s)",
+ +                |diag| {
+ +                    let ms = MultiSpan::from_spans(immutables);
+ +                    diag.span_note(ms, "immutable borrow here");
+ +                },
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +#[allow(clippy::too_many_lines)]
+ +fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &'tcx Body<'_>, args: &[PtrArg<'tcx>]) -> Vec<PtrArgResult> {
+ +    struct V<'cx, 'tcx> {
+ +        cx: &'cx LateContext<'tcx>,
+ +        /// Map from a local id to which argument it came from (index into `Self::args` and
+ +        /// `Self::results`)
+ +        bindings: HirIdMap<usize>,
+ +        /// The arguments being checked.
+ +        args: &'cx [PtrArg<'tcx>],
+ +        /// The results for each argument (len should match args.len)
+ +        results: Vec<PtrArgResult>,
+ +        /// The number of arguments which can't be linted. Used to return early.
+ +        skip_count: usize,
+ +    }
+ +    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
+ +        type NestedFilter = nested_filter::OnlyBodies;
+ +        fn nested_visit_map(&mut self) -> Self::Map {
+ +            self.cx.tcx.hir()
+ +        }
+ +
+ +        fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
+ +
+ +        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+ +            if self.skip_count == self.args.len() {
+ +                return;
+ +            }
+ +
+ +            // Check if this is local we care about
+ +            let args_idx = match path_to_local(e).and_then(|id| self.bindings.get(&id)) {
+ +                Some(&i) => i,
+ +                None => return walk_expr(self, e),
+ +            };
+ +            let args = &self.args[args_idx];
+ +            let result = &mut self.results[args_idx];
+ +
+ +            // Helper function to handle early returns.
+ +            let mut set_skip_flag = || {
+ +                if result.skip {
+ +                    self.skip_count += 1;
+ +                }
+ +                result.skip = true;
+ +            };
+ +
+ +            match get_expr_use_or_unification_node(self.cx.tcx, e) {
+ +                Some((Node::Stmt(_), _)) => (),
+ +                Some((Node::Local(l), _)) => {
+ +                    // Only trace simple bindings. e.g `let x = y;`
+ +                    if let PatKind::Binding(BindingAnnotation::Unannotated, id, _, None) = l.pat.kind {
+ +                        self.bindings.insert(id, args_idx);
+ +                    } else {
+ +                        set_skip_flag();
+ +                    }
+ +                },
+ +                Some((Node::Expr(e), child_id)) => match e.kind {
+ +                    ExprKind::Call(f, expr_args) => {
+ +                        let i = expr_args.iter().position(|arg| arg.hir_id == child_id).unwrap_or(0);
+ +                        if expr_sig(self.cx, f)
+ +                            .map(|sig| sig.input(i).skip_binder().peel_refs())
+ +                            .map_or(true, |ty| match *ty.kind() {
+ +                                ty::Param(_) => true,
+ +                                ty::Adt(def, _) => def.did == args.ty_did,
+ +                                _ => false,
+ +                            })
+ +                        {
+ +                            // Passed to a function taking the non-dereferenced type.
+ +                            set_skip_flag();
+ +                        }
+ +                    },
+ +                    ExprKind::MethodCall(name, expr_args @ [self_arg, ..], _) => {
+ +                        let i = expr_args.iter().position(|arg| arg.hir_id == child_id).unwrap_or(0);
+ +                        if i == 0 {
+ +                            // Check if the method can be renamed.
+ +                            let name = name.ident.as_str();
+ +                            if let Some((_, replacement)) = args.method_renames.iter().find(|&&(x, _)| x == name) {
+ +                                result.replacements.push(PtrArgReplacement {
+ +                                    expr_span: e.span,
+ +                                    self_span: self_arg.span,
+ +                                    replacement,
+ +                                });
+ +                                return;
+ +                            }
+ +                        }
+ +
+ +                        let id = if let Some(x) = self.cx.typeck_results().type_dependent_def_id(e.hir_id) {
+ +                            x
+ +                        } else {
+ +                            set_skip_flag();
+ +                            return;
+ +                        };
+ +
+ +                        match *self.cx.tcx.fn_sig(id).skip_binder().inputs()[i].peel_refs().kind() {
+ +                            ty::Param(_) => {
+ +                                set_skip_flag();
+ +                            },
+ +                            // If the types match check for methods which exist on both types. e.g. `Vec::len` and
+ +                            // `slice::len`
+ +                            ty::Adt(def, _)
+ +                                if def.did == args.ty_did
+ +                                    && (i != 0
+ +                                        || self.cx.tcx.trait_of_item(id).is_some()
+ +                                        || !args.deref_assoc_items.map_or(false, |(id, items)| {
+ +                                            items
+ +                                                .find_by_name_and_kind(self.cx.tcx, name.ident, AssocKind::Fn, id)
+ +                                                .is_some()
+ +                                        })) =>
+ +                            {
+ +                                set_skip_flag();
+ +                            },
+ +                            _ => (),
+ +                        }
+ +                    },
+ +                    // Indexing is fine for currently supported types.
+ +                    ExprKind::Index(e, _) if e.hir_id == child_id => (),
+ +                    _ => set_skip_flag(),
+ +                },
+ +                _ => set_skip_flag(),
+ +            }
+ +        }
+ +    }
+ +
+ +    let mut skip_count = 0;
+ +    let mut results = args.iter().map(|_| PtrArgResult::default()).collect::<Vec<_>>();
+ +    let mut v = V {
+ +        cx,
+ +        bindings: args
+ +            .iter()
+ +            .enumerate()
+ +            .filter_map(|(i, arg)| {
+ +                let param = &body.params[arg.idx];
+ +                match param.pat.kind {
+ +                    PatKind::Binding(BindingAnnotation::Unannotated, id, _, None)
+ +                        if !is_lint_allowed(cx, PTR_ARG, param.hir_id) =>
+ +                    {
+ +                        Some((id, i))
+ +                    },
+ +                    _ => {
+ +                        skip_count += 1;
-         expr_path_res(cx, pathexp).opt_def_id().map_or(false, |id| {
-             match_any_diagnostic_items(cx, id, &[sym::ptr_null, sym::ptr_null_mut]).is_some()
++                        results[i].skip = true;
+ +                        None
+ +                    },
+ +                }
+ +            })
+ +            .collect(),
+ +        args,
+ +        results,
+ +        skip_count,
+ +    };
+ +    v.visit_expr(&body.value);
+ +    v.results
+ +}
+ +
+ +fn get_rptr_lm<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Option<(&'tcx Lifetime, Mutability, Span)> {
+ +    if let TyKind::Rptr(ref lt, ref m) = ty.kind {
+ +        Some((lt, m.mutbl, ty.span))
+ +    } else {
+ +        None
+ +    }
+ +}
+ +
+ +fn is_null_path(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    if let ExprKind::Call(pathexp, []) = expr.kind {
++        path_def_id(cx, pathexp).map_or(false, |id| {
++            matches!(cx.tcx.get_diagnostic_name(id), Some(sym::ptr_null | sym::ptr_null_mut))
+ +        })
+ +    } else {
+ +        false
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/ranges.rs

index 027ab70014fc0c2ca51ced2aa25f329cfcb87028,0000000000000000000000000000000000000000..be7610f365c5be716dc68aaf25de986b0a99f651

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/ranges.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/ranges.rs
@@@ -1,544 -1,0 +1,532 @@@
- use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, msrvs, single_segment_path};
+ +use clippy_utils::consts::{constant, Constant};
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
+ +use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
+ +use clippy_utils::sugg::Sugg;
- use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, QPath};
++use clippy_utils::{get_parent_expr, in_constant, is_integer_const, meets_msrv, msrvs, path_to_local};
+ +use clippy_utils::{higher, SpanlessEq};
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::RangeLimits;
+ +use rustc_errors::Applicability;
- use rustc_span::symbol::Ident;
++use rustc_hir::{BinOpKind, Expr, ExprKind, HirId, PathSegment, QPath};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_middle::ty;
+ +use rustc_semver::RustcVersion;
+ +use rustc_session::{declare_tool_lint, impl_lint_pass};
+ +use rustc_span::source_map::{Span, Spanned};
+ +use rustc_span::sym;
-     if let (Some((lval, lname, name_span, lval_span, lord, linc)), Some((rval, rname, _, rval_span, rord, rinc))) =
+ +use std::cmp::Ordering;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for zipping a collection with the range of
+ +    /// `0.._.len()`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The code is better expressed with `.enumerate()`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let x = vec![1];
+ +    /// x.iter().zip(0..x.len());
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust
+ +    /// # let x = vec![1];
+ +    /// x.iter().enumerate();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub RANGE_ZIP_WITH_LEN,
+ +    complexity,
+ +    "zipping iterator with a range when `enumerate()` would do"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for exclusive ranges where 1 is added to the
+ +    /// upper bound, e.g., `x..(y+1)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The code is more readable with an inclusive range
+ +    /// like `x..=y`.
+ +    ///
+ +    /// ### Known problems
+ +    /// Will add unnecessary pair of parentheses when the
+ +    /// expression is not wrapped in a pair but starts with an opening parenthesis
+ +    /// and ends with a closing one.
+ +    /// I.e., `let _ = (f()+1)..(f()+1)` results in `let _ = ((f()+1)..=f())`.
+ +    ///
+ +    /// Also in many cases, inclusive ranges are still slower to run than
+ +    /// exclusive ranges, because they essentially add an extra branch that
+ +    /// LLVM may fail to hoist out of the loop.
+ +    ///
+ +    /// This will cause a warning that cannot be fixed if the consumer of the
+ +    /// range only accepts a specific range type, instead of the generic
+ +    /// `RangeBounds` trait
+ +    /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// for x..(y+1) { .. }
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust,ignore
+ +    /// for x..=y { .. }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub RANGE_PLUS_ONE,
+ +    pedantic,
+ +    "`x..(y+1)` reads better as `x..=y`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for inclusive ranges where 1 is subtracted from
+ +    /// the upper bound, e.g., `x..=(y-1)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The code is more readable with an exclusive range
+ +    /// like `x..y`.
+ +    ///
+ +    /// ### Known problems
+ +    /// This will cause a warning that cannot be fixed if
+ +    /// the consumer of the range only accepts a specific range type, instead of
+ +    /// the generic `RangeBounds` trait
+ +    /// ([#3307](https://github.com/rust-lang/rust-clippy/issues/3307)).
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// for x..=(y-1) { .. }
+ +    /// ```
+ +    /// Could be written as
+ +    /// ```rust,ignore
+ +    /// for x..y { .. }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub RANGE_MINUS_ONE,
+ +    pedantic,
+ +    "`x..=(y-1)` reads better as `x..y`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for range expressions `x..y` where both `x` and `y`
+ +    /// are constant and `x` is greater or equal to `y`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Empty ranges yield no values so iterating them is a no-op.
+ +    /// Moreover, trying to use a reversed range to index a slice will panic at run-time.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,no_run
+ +    /// fn main() {
+ +    ///     (10..=0).for_each(|x| println!("{}", x));
+ +    ///
+ +    ///     let arr = [1, 2, 3, 4, 5];
+ +    ///     let sub = &arr[3..1];
+ +    /// }
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// fn main() {
+ +    ///     (0..=10).rev().for_each(|x| println!("{}", x));
+ +    ///
+ +    ///     let arr = [1, 2, 3, 4, 5];
+ +    ///     let sub = &arr[1..3];
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "1.45.0"]
+ +    pub REVERSED_EMPTY_RANGES,
+ +    correctness,
+ +    "reversing the limits of range expressions, resulting in empty ranges"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for expressions like `x >= 3 && x < 8` that could
+ +    /// be more readably expressed as `(3..8).contains(x)`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `contains` expresses the intent better and has less
+ +    /// failure modes (such as fencepost errors or using `||` instead of `&&`).
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // given
+ +    /// let x = 6;
+ +    ///
+ +    /// assert!(x >= 3 && x < 8);
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    ///# let x = 6;
+ +    /// assert!((3..8).contains(&x));
+ +    /// ```
+ +    #[clippy::version = "1.49.0"]
+ +    pub MANUAL_RANGE_CONTAINS,
+ +    style,
+ +    "manually reimplementing {`Range`, `RangeInclusive`}`::contains`"
+ +}
+ +
+ +pub struct Ranges {
+ +    msrv: Option<RustcVersion>,
+ +}
+ +
+ +impl Ranges {
+ +    #[must_use]
+ +    pub fn new(msrv: Option<RustcVersion>) -> Self {
+ +        Self { msrv }
+ +    }
+ +}
+ +
+ +impl_lint_pass!(Ranges => [
+ +    RANGE_ZIP_WITH_LEN,
+ +    RANGE_PLUS_ONE,
+ +    RANGE_MINUS_ONE,
+ +    REVERSED_EMPTY_RANGES,
+ +    MANUAL_RANGE_CONTAINS,
+ +]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for Ranges {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        match expr.kind {
+ +            ExprKind::MethodCall(path, args, _) => {
+ +                check_range_zip_with_len(cx, path, args, expr.span);
+ +            },
+ +            ExprKind::Binary(ref op, l, r) => {
+ +                if meets_msrv(self.msrv.as_ref(), &msrvs::RANGE_CONTAINS) {
+ +                    check_possible_range_contains(cx, op.node, l, r, expr);
+ +                }
+ +            },
+ +            _ => {},
+ +        }
+ +
+ +        check_exclusive_range_plus_one(cx, expr);
+ +        check_inclusive_range_minus_one(cx, expr);
+ +        check_reversed_empty_range(cx, expr);
+ +    }
+ +    extract_msrv_attr!(LateContext);
+ +}
+ +
+ +fn check_possible_range_contains(cx: &LateContext<'_>, op: BinOpKind, l: &Expr<'_>, r: &Expr<'_>, expr: &Expr<'_>) {
+ +    if in_constant(cx, expr.hir_id) {
+ +        return;
+ +    }
+ +
+ +    let span = expr.span;
+ +    let combine_and = match op {
+ +        BinOpKind::And | BinOpKind::BitAnd => true,
+ +        BinOpKind::Or | BinOpKind::BitOr => false,
+ +        _ => return,
+ +    };
+ +    // value, name, order (higher/lower), inclusiveness
-         if lname != rname || lord == rord {
++    if let (Some((lval, lid, name_span, lval_span, lord, linc)), Some((rval, rid, _, rval_span, rord, rinc))) =
+ +        (check_range_bounds(cx, l), check_range_bounds(cx, r))
+ +    {
+ +        // we only lint comparisons on the same name and with different
+ +        // direction
- fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, Ident, Span, Span, Ordering, bool)> {
++        if lid != rid || lord == rord {
+ +            return;
+ +        }
+ +        let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l), &lval, &rval);
+ +        if combine_and && ord == Some(rord) {
+ +            // order lower bound and upper bound
+ +            let (l_span, u_span, l_inc, u_inc) = if rord == Ordering::Less {
+ +                (lval_span, rval_span, linc, rinc)
+ +            } else {
+ +                (rval_span, lval_span, rinc, linc)
+ +            };
+ +            // we only lint inclusive lower bounds
+ +            if !l_inc {
+ +                return;
+ +            }
+ +            let (range_type, range_op) = if u_inc {
+ +                ("RangeInclusive", "..=")
+ +            } else {
+ +                ("Range", "..")
+ +            };
+ +            let mut applicability = Applicability::MachineApplicable;
+ +            let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
+ +            let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
+ +            let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
+ +            let space = if lo.ends_with('.') { " " } else { "" };
+ +            span_lint_and_sugg(
+ +                cx,
+ +                MANUAL_RANGE_CONTAINS,
+ +                span,
+ +                &format!("manual `{}::contains` implementation", range_type),
+ +                "use",
+ +                format!("({}{}{}{}).contains(&{})", lo, space, range_op, hi, name),
+ +                applicability,
+ +            );
+ +        } else if !combine_and && ord == Some(lord) {
+ +            // `!_.contains(_)`
+ +            // order lower bound and upper bound
+ +            let (l_span, u_span, l_inc, u_inc) = if lord == Ordering::Less {
+ +                (lval_span, rval_span, linc, rinc)
+ +            } else {
+ +                (rval_span, lval_span, rinc, linc)
+ +            };
+ +            if l_inc {
+ +                return;
+ +            }
+ +            let (range_type, range_op) = if u_inc {
+ +                ("Range", "..")
+ +            } else {
+ +                ("RangeInclusive", "..=")
+ +            };
+ +            let mut applicability = Applicability::MachineApplicable;
+ +            let name = snippet_with_applicability(cx, name_span, "_", &mut applicability);
+ +            let lo = snippet_with_applicability(cx, l_span, "_", &mut applicability);
+ +            let hi = snippet_with_applicability(cx, u_span, "_", &mut applicability);
+ +            let space = if lo.ends_with('.') { " " } else { "" };
+ +            span_lint_and_sugg(
+ +                cx,
+ +                MANUAL_RANGE_CONTAINS,
+ +                span,
+ +                &format!("manual `!{}::contains` implementation", range_type),
+ +                "use",
+ +                format!("!({}{}{}{}).contains(&{})", lo, space, range_op, hi, name),
+ +                applicability,
+ +            );
+ +        }
+ +    }
+ +}
+ +
-         if let Some(id) = match_ident(l) {
++fn check_range_bounds(cx: &LateContext<'_>, ex: &Expr<'_>) -> Option<(Constant, HirId, Span, Span, Ordering, bool)> {
+ +    if let ExprKind::Binary(ref op, l, r) = ex.kind {
+ +        let (inclusive, ordering) = match op.node {
+ +            BinOpKind::Gt => (false, Ordering::Greater),
+ +            BinOpKind::Ge => (true, Ordering::Greater),
+ +            BinOpKind::Lt => (false, Ordering::Less),
+ +            BinOpKind::Le => (true, Ordering::Less),
+ +            _ => return None,
+ +        };
-         } else if let Some(id) = match_ident(r) {
++        if let Some(id) = path_to_local(l) {
+ +            if let Some((c, _)) = constant(cx, cx.typeck_results(), r) {
+ +                return Some((c, id, l.span, r.span, ordering, inclusive));
+ +            }
- fn match_ident(e: &Expr<'_>) -> Option<Ident> {
-     if let ExprKind::Path(ref qpath) = e.kind {
-         if let Some(seg) = single_segment_path(qpath) {
-             if seg.args.is_none() {
-                 return Some(seg.ident);
-             }
-         }
-     }
-     None
- }
- 
++        } else if let Some(id) = path_to_local(r) {
+ +            if let Some((c, _)) = constant(cx, cx.typeck_results(), l) {
+ +                return Some((c, id, r.span, l.span, ordering.reverse(), inclusive));
+ +            }
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +fn check_range_zip_with_len(cx: &LateContext<'_>, path: &PathSegment<'_>, args: &[Expr<'_>], span: Span) {
+ +    if_chain! {
+ +        if path.ident.as_str() == "zip";
+ +        if let [iter, zip_arg] = args;
+ +        // `.iter()` call
+ +        if let ExprKind::MethodCall(iter_path, iter_args, _) = iter.kind;
+ +        if iter_path.ident.name == sym::iter;
+ +        // range expression in `.zip()` call: `0..x.len()`
+ +        if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::Range::hir(zip_arg);
+ +        if is_integer_const(cx, start, 0);
+ +        // `.len()` call
+ +        if let ExprKind::MethodCall(len_path, len_args, _) = end.kind;
+ +        if len_path.ident.name == sym::len && len_args.len() == 1;
+ +        // `.iter()` and `.len()` called on same `Path`
+ +        if let ExprKind::Path(QPath::Resolved(_, iter_path)) = iter_args[0].kind;
+ +        if let ExprKind::Path(QPath::Resolved(_, len_path)) = len_args[0].kind;
+ +        if SpanlessEq::new(cx).eq_path_segments(&iter_path.segments, &len_path.segments);
+ +        then {
+ +            span_lint(cx,
+ +                RANGE_ZIP_WITH_LEN,
+ +                span,
+ +                &format!("it is more idiomatic to use `{}.iter().enumerate()`",
+ +                    snippet(cx, iter_args[0].span, "_"))
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +// exclusive range plus one: `x..(y+1)`
+ +fn check_exclusive_range_plus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
+ +    if_chain! {
+ +        if let Some(higher::Range {
+ +            start,
+ +            end: Some(end),
+ +            limits: RangeLimits::HalfOpen
+ +        }) = higher::Range::hir(expr);
+ +        if let Some(y) = y_plus_one(cx, end);
+ +        then {
+ +            let span = if expr.span.from_expansion() {
+ +                expr.span
+ +                    .ctxt()
+ +                    .outer_expn_data()
+ +                    .call_site
+ +            } else {
+ +                expr.span
+ +            };
+ +            span_lint_and_then(
+ +                cx,
+ +                RANGE_PLUS_ONE,
+ +                span,
+ +                "an inclusive range would be more readable",
+ +                |diag| {
+ +                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
+ +                    let end = Sugg::hir(cx, y, "y").maybe_par();
+ +                    if let Some(is_wrapped) = &snippet_opt(cx, span) {
+ +                        if is_wrapped.starts_with('(') && is_wrapped.ends_with(')') {
+ +                            diag.span_suggestion(
+ +                                span,
+ +                                "use",
+ +                                format!("({}..={})", start, end),
+ +                                Applicability::MaybeIncorrect,
+ +                            );
+ +                        } else {
+ +                            diag.span_suggestion(
+ +                                span,
+ +                                "use",
+ +                                format!("{}..={}", start, end),
+ +                                Applicability::MachineApplicable, // snippet
+ +                            );
+ +                        }
+ +                    }
+ +                },
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +// inclusive range minus one: `x..=(y-1)`
+ +fn check_inclusive_range_minus_one(cx: &LateContext<'_>, expr: &Expr<'_>) {
+ +    if_chain! {
+ +        if let Some(higher::Range { start, end: Some(end), limits: RangeLimits::Closed }) = higher::Range::hir(expr);
+ +        if let Some(y) = y_minus_one(cx, end);
+ +        then {
+ +            span_lint_and_then(
+ +                cx,
+ +                RANGE_MINUS_ONE,
+ +                expr.span,
+ +                "an exclusive range would be more readable",
+ +                |diag| {
+ +                    let start = start.map_or(String::new(), |x| Sugg::hir(cx, x, "x").maybe_par().to_string());
+ +                    let end = Sugg::hir(cx, y, "y").maybe_par();
+ +                    diag.span_suggestion(
+ +                        expr.span,
+ +                        "use",
+ +                        format!("{}..{}", start, end),
+ +                        Applicability::MachineApplicable, // snippet
+ +                    );
+ +                },
+ +            );
+ +        }
+ +    }
+ +}
+ +
+ +fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
+ +    fn inside_indexing_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +        matches!(
+ +            get_parent_expr(cx, expr),
+ +            Some(Expr {
+ +                kind: ExprKind::Index(..),
+ +                ..
+ +            })
+ +        )
+ +    }
+ +
+ +    fn is_for_loop_arg(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +        let mut cur_expr = expr;
+ +        while let Some(parent_expr) = get_parent_expr(cx, cur_expr) {
+ +            match higher::ForLoop::hir(parent_expr) {
+ +                Some(higher::ForLoop { arg, .. }) if arg.hir_id == expr.hir_id => return true,
+ +                _ => cur_expr = parent_expr,
+ +            }
+ +        }
+ +
+ +        false
+ +    }
+ +
+ +    fn is_empty_range(limits: RangeLimits, ordering: Ordering) -> bool {
+ +        match limits {
+ +            RangeLimits::HalfOpen => ordering != Ordering::Less,
+ +            RangeLimits::Closed => ordering == Ordering::Greater,
+ +        }
+ +    }
+ +
+ +    if_chain! {
+ +        if let Some(higher::Range { start: Some(start), end: Some(end), limits }) = higher::Range::hir(expr);
+ +        let ty = cx.typeck_results().expr_ty(start);
+ +        if let ty::Int(_) | ty::Uint(_) = ty.kind();
+ +        if let Some((start_idx, _)) = constant(cx, cx.typeck_results(), start);
+ +        if let Some((end_idx, _)) = constant(cx, cx.typeck_results(), end);
+ +        if let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx);
+ +        if is_empty_range(limits, ordering);
+ +        then {
+ +            if inside_indexing_expr(cx, expr) {
+ +                // Avoid linting `N..N` as it has proven to be useful, see #5689 and #5628 ...
+ +                if ordering != Ordering::Equal {
+ +                    span_lint(
+ +                        cx,
+ +                        REVERSED_EMPTY_RANGES,
+ +                        expr.span,
+ +                        "this range is reversed and using it to index a slice will panic at run-time",
+ +                    );
+ +                }
+ +            // ... except in for loop arguments for backwards compatibility with `reverse_range_loop`
+ +            } else if ordering != Ordering::Equal || is_for_loop_arg(cx, expr) {
+ +                span_lint_and_then(
+ +                    cx,
+ +                    REVERSED_EMPTY_RANGES,
+ +                    expr.span,
+ +                    "this range is empty so it will yield no values",
+ +                    |diag| {
+ +                        if ordering != Ordering::Equal {
+ +                            let start_snippet = snippet(cx, start.span, "_");
+ +                            let end_snippet = snippet(cx, end.span, "_");
+ +                            let dots = match limits {
+ +                                RangeLimits::HalfOpen => "..",
+ +                                RangeLimits::Closed => "..="
+ +                            };
+ +
+ +                            diag.span_suggestion(
+ +                                expr.span,
+ +                                "consider using the following if you are attempting to iterate over this \
+ +                                 range in reverse",
+ +                                format!("({}{}{}).rev()", end_snippet, dots, start_snippet),
+ +                                Applicability::MaybeIncorrect,
+ +                            );
+ +                        }
+ +                    },
+ +                );
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +fn y_plus_one<'t>(cx: &LateContext<'_>, expr: &'t Expr<'_>) -> Option<&'t Expr<'t>> {
+ +    match expr.kind {
+ +        ExprKind::Binary(
+ +            Spanned {
+ +                node: BinOpKind::Add, ..
+ +            },
+ +            lhs,
+ +            rhs,
+ +        ) => {
+ +            if is_integer_const(cx, lhs, 1) {
+ +                Some(rhs)
+ +            } else if is_integer_const(cx, rhs, 1) {
+ +                Some(lhs)
+ +            } else {
+ +                None
+ +            }
+ +        },
+ +        _ => None,
+ +    }
+ +}
+ +
+ +fn y_minus_one<'t>(cx: &LateContext<'_>, expr: &'t Expr<'_>) -> Option<&'t Expr<'t>> {
+ +    match expr.kind {
+ +        ExprKind::Binary(
+ +            Spanned {
+ +                node: BinOpKind::Sub, ..
+ +            },
+ +            lhs,
+ +            rhs,
+ +        ) if is_integer_const(cx, rhs, 1) => Some(lhs),
+ +        _ => None,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/swap.rs

index 4c10b12437d7b5e3465c5e520529b626f5fc8a3a,0000000000000000000000000000000000000000..1885f3ca414dfe9dbef2a600fc961cf4f6b9ebb5

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/swap.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/swap.rs
@@@ -1,258 -1,0 +1,258 @@@
- use clippy_utils::{can_mut_borrow_both, differing_macro_contexts, eq_expr_value, std_or_core};
+ +use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+ +use clippy_utils::source::snippet_with_applicability;
+ +use clippy_utils::sugg::Sugg;
+ +use clippy_utils::ty::is_type_diagnostic_item;
-             if !differing_macro_contexts(first.span, second.span);
++use clippy_utils::{can_mut_borrow_both, eq_expr_value, std_or_core};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{BinOpKind, Block, Expr, ExprKind, PatKind, QPath, Stmt, StmtKind};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_middle::ty;
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::source_map::Spanned;
+ +use rustc_span::{sym, Span};
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for manual swapping.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The `std::mem::swap` function exposes the intent better
+ +    /// without deinitializing or copying either variable.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let mut a = 42;
+ +    /// let mut b = 1337;
+ +    ///
+ +    /// let t = b;
+ +    /// b = a;
+ +    /// a = t;
+ +    /// ```
+ +    /// Use std::mem::swap():
+ +    /// ```rust
+ +    /// let mut a = 1;
+ +    /// let mut b = 2;
+ +    /// std::mem::swap(&mut a, &mut b);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub MANUAL_SWAP,
+ +    complexity,
+ +    "manual swap of two variables"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for `foo = bar; bar = foo` sequences.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This looks like a failed attempt to swap.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let mut a = 1;
+ +    /// # let mut b = 2;
+ +    /// a = b;
+ +    /// b = a;
+ +    /// ```
+ +    /// If swapping is intended, use `swap()` instead:
+ +    /// ```rust
+ +    /// # let mut a = 1;
+ +    /// # let mut b = 2;
+ +    /// std::mem::swap(&mut a, &mut b);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub ALMOST_SWAPPED,
+ +    correctness,
+ +    "`foo = bar; bar = foo` sequence"
+ +}
+ +
+ +declare_lint_pass!(Swap => [MANUAL_SWAP, ALMOST_SWAPPED]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for Swap {
+ +    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'_>) {
+ +        check_manual_swap(cx, block);
+ +        check_suspicious_swap(cx, block);
+ +        check_xor_swap(cx, block);
+ +    }
+ +}
+ +
+ +fn generate_swap_warning(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>, span: Span, is_xor_based: bool) {
+ +    let mut applicability = Applicability::MachineApplicable;
+ +
+ +    if !can_mut_borrow_both(cx, e1, e2) {
+ +        if let ExprKind::Index(lhs1, idx1) = e1.kind {
+ +            if let ExprKind::Index(lhs2, idx2) = e2.kind {
+ +                if eq_expr_value(cx, lhs1, lhs2) {
+ +                    let ty = cx.typeck_results().expr_ty(lhs1).peel_refs();
+ +
+ +                    if matches!(ty.kind(), ty::Slice(_))
+ +                        || matches!(ty.kind(), ty::Array(_, _))
+ +                        || is_type_diagnostic_item(cx, ty, sym::Vec)
+ +                        || is_type_diagnostic_item(cx, ty, sym::VecDeque)
+ +                    {
+ +                        let slice = Sugg::hir_with_applicability(cx, lhs1, "<slice>", &mut applicability);
+ +                        span_lint_and_sugg(
+ +                            cx,
+ +                            MANUAL_SWAP,
+ +                            span,
+ +                            &format!("this looks like you are swapping elements of `{}` manually", slice),
+ +                            "try",
+ +                            format!(
+ +                                "{}.swap({}, {})",
+ +                                slice.maybe_par(),
+ +                                snippet_with_applicability(cx, idx1.span, "..", &mut applicability),
+ +                                snippet_with_applicability(cx, idx2.span, "..", &mut applicability),
+ +                            ),
+ +                            applicability,
+ +                        );
+ +                    }
+ +                }
+ +            }
+ +        }
+ +        return;
+ +    }
+ +
+ +    let first = Sugg::hir_with_applicability(cx, e1, "..", &mut applicability);
+ +    let second = Sugg::hir_with_applicability(cx, e2, "..", &mut applicability);
+ +    let Some(sugg) = std_or_core(cx) else { return };
+ +
+ +    span_lint_and_then(
+ +        cx,
+ +        MANUAL_SWAP,
+ +        span,
+ +        &format!("this looks like you are swapping `{}` and `{}` manually", first, second),
+ +        |diag| {
+ +            diag.span_suggestion(
+ +                span,
+ +                "try",
+ +                format!("{}::mem::swap({}, {})", sugg, first.mut_addr(), second.mut_addr()),
+ +                applicability,
+ +            );
+ +            if !is_xor_based {
+ +                diag.note(&format!("or maybe you should use `{}::mem::replace`?", sugg));
+ +            }
+ +        },
+ +    );
+ +}
+ +
+ +/// Implementation of the `MANUAL_SWAP` lint.
+ +fn check_manual_swap(cx: &LateContext<'_>, block: &Block<'_>) {
+ +    for w in block.stmts.windows(3) {
+ +        if_chain! {
+ +            // let t = foo();
+ +            if let StmtKind::Local(tmp) = w[0].kind;
+ +            if let Some(tmp_init) = tmp.init;
+ +            if let PatKind::Binding(.., ident, None) = tmp.pat.kind;
+ +
+ +            // foo() = bar();
+ +            if let StmtKind::Semi(first) = w[1].kind;
+ +            if let ExprKind::Assign(lhs1, rhs1, _) = first.kind;
+ +
+ +            // bar() = t;
+ +            if let StmtKind::Semi(second) = w[2].kind;
+ +            if let ExprKind::Assign(lhs2, rhs2, _) = second.kind;
+ +            if let ExprKind::Path(QPath::Resolved(None, rhs2)) = rhs2.kind;
+ +            if rhs2.segments.len() == 1;
+ +
+ +            if ident.name == rhs2.segments[0].ident.name;
+ +            if eq_expr_value(cx, tmp_init, lhs1);
+ +            if eq_expr_value(cx, rhs1, lhs2);
+ +            then {
+ +                let span = w[0].span.to(second.span);
+ +                generate_swap_warning(cx, lhs1, lhs2, span, false);
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +/// Implementation of the `ALMOST_SWAPPED` lint.
+ +fn check_suspicious_swap(cx: &LateContext<'_>, block: &Block<'_>) {
+ +    for w in block.stmts.windows(2) {
+ +        if_chain! {
+ +            if let StmtKind::Semi(first) = w[0].kind;
+ +            if let StmtKind::Semi(second) = w[1].kind;
++            if first.span.ctxt() == second.span.ctxt();
+ +            if let ExprKind::Assign(lhs0, rhs0, _) = first.kind;
+ +            if let ExprKind::Assign(lhs1, rhs1, _) = second.kind;
+ +            if eq_expr_value(cx, lhs0, rhs1);
+ +            if eq_expr_value(cx, lhs1, rhs0);
+ +            then {
+ +                let lhs0 = Sugg::hir_opt(cx, lhs0);
+ +                let rhs0 = Sugg::hir_opt(cx, rhs0);
+ +                let (what, lhs, rhs) = if let (Some(first), Some(second)) = (lhs0, rhs0) {
+ +                    (
+ +                        format!(" `{}` and `{}`", first, second),
+ +                        first.mut_addr().to_string(),
+ +                        second.mut_addr().to_string(),
+ +                    )
+ +                } else {
+ +                    (String::new(), String::new(), String::new())
+ +                };
+ +
+ +                let span = first.span.to(second.span);
+ +                let Some(sugg) = std_or_core(cx) else { return };
+ +
+ +                span_lint_and_then(cx,
+ +                    ALMOST_SWAPPED,
+ +                    span,
+ +                    &format!("this looks like you are trying to swap{}", what),
+ +                    |diag| {
+ +                        if !what.is_empty() {
+ +                            diag.span_suggestion(
+ +                                span,
+ +                                "try",
+ +                                format!(
+ +                                    "{}::mem::swap({}, {})",
+ +                                    sugg,
+ +                                    lhs,
+ +                                    rhs,
+ +                                ),
+ +                                Applicability::MaybeIncorrect,
+ +                            );
+ +                            diag.note(
+ +                                &format!("or maybe you should use `{}::mem::replace`?", sugg)
+ +                            );
+ +                        }
+ +                    });
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +/// Implementation of the xor case for `MANUAL_SWAP` lint.
+ +fn check_xor_swap(cx: &LateContext<'_>, block: &Block<'_>) {
+ +    for window in block.stmts.windows(3) {
+ +        if_chain! {
+ +            if let Some((lhs0, rhs0)) = extract_sides_of_xor_assign(&window[0]);
+ +            if let Some((lhs1, rhs1)) = extract_sides_of_xor_assign(&window[1]);
+ +            if let Some((lhs2, rhs2)) = extract_sides_of_xor_assign(&window[2]);
+ +            if eq_expr_value(cx, lhs0, rhs1);
+ +            if eq_expr_value(cx, lhs2, rhs1);
+ +            if eq_expr_value(cx, lhs1, rhs0);
+ +            if eq_expr_value(cx, lhs1, rhs2);
+ +            then {
+ +                let span = window[0].span.to(window[2].span);
+ +                generate_swap_warning(cx, lhs0, rhs0, span, true);
+ +            }
+ +        };
+ +    }
+ +}
+ +
+ +/// Returns the lhs and rhs of an xor assignment statement.
+ +fn extract_sides_of_xor_assign<'a, 'hir>(stmt: &'a Stmt<'hir>) -> Option<(&'a Expr<'hir>, &'a Expr<'hir>)> {
+ +    if let StmtKind::Semi(expr) = stmt.kind {
+ +        if let ExprKind::AssignOp(
+ +            Spanned {
+ +                node: BinOpKind::BitXor,
+ +                ..
+ +            },
+ +            lhs,
+ +            rhs,
+ +        ) = expr.kind
+ +        {
+ +            return Some((lhs, rhs));
+ +        }
+ +    }
+ +    None
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/mod.rs

index 3ad4ec74bf51c1bdde228e00f451c3685fa92e31,0000000000000000000000000000000000000000..4c320deecc28b02b79a19f119be4e49cddb7a5f4

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/mod.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/mod.rs
@@@ -1,414 -1,0 +1,442 @@@
-     #[allow(clippy::similar_names, clippy::too_many_lines)]
+ +mod crosspointer_transmute;
+ +mod transmute_float_to_int;
+ +mod transmute_int_to_bool;
+ +mod transmute_int_to_char;
+ +mod transmute_int_to_float;
+ +mod transmute_num_to_bytes;
+ +mod transmute_ptr_to_ptr;
+ +mod transmute_ptr_to_ref;
+ +mod transmute_ref_to_ref;
++mod transmute_undefined_repr;
+ +mod transmutes_expressible_as_ptr_casts;
+ +mod unsound_collection_transmute;
+ +mod useless_transmute;
+ +mod utils;
+ +mod wrong_transmute;
+ +
+ +use clippy_utils::in_constant;
+ +use if_chain::if_chain;
+ +use rustc_hir::{Expr, ExprKind};
+ +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
+ +    /// Checks for transmutes that can't ever be correct on any
+ +    /// architecture.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It's basically guaranteed to be undefined behaviour.
+ +    ///
+ +    /// ### Known problems
+ +    /// When accessing C, users might want to store pointer
+ +    /// sized objects in `extradata` arguments to save an allocation.
+ +    ///
+ +    /// ### Example
+ +    /// ```ignore
+ +    /// let ptr: *const T = core::intrinsics::transmute('x')
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub WRONG_TRANSMUTE,
+ +    correctness,
+ +    "transmutes that are confusing at best, undefined behaviour at worst and always useless"
+ +}
+ +
+ +// FIXME: Move this to `complexity` again, after #5343 is fixed
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes to the original type of the object
+ +    /// and transmutes that could be a cast.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability. The code tricks people into thinking that
+ +    /// something complex is going on.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// core::intrinsics::transmute(t); // where the result type is the same as `t`'s
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub USELESS_TRANSMUTE,
+ +    nursery,
+ +    "transmutes that have the same to and from types or could be a cast/coercion"
+ +}
+ +
+ +// FIXME: Merge this lint with USELESS_TRANSMUTE once that is out of the nursery.
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    ///Checks for transmutes that could be a pointer cast.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Readability. The code tricks people into thinking that
+ +    /// something complex is going on.
+ +    ///
+ +    /// ### Example
+ +    ///
+ +    /// ```rust
+ +    /// # let p: *const [i32] = &[];
+ +    /// unsafe { std::mem::transmute::<*const [i32], *const [u16]>(p) };
+ +    /// ```
+ +    /// Use instead:
+ +    /// ```rust
+ +    /// # let p: *const [i32] = &[];
+ +    /// p as *const [u16];
+ +    /// ```
+ +    #[clippy::version = "1.47.0"]
+ +    pub TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+ +    complexity,
+ +    "transmutes that could be a pointer cast"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes between a type `T` and `*T`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It's easy to mistakenly transmute between a type and a
+ +    /// pointer to that type.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// core::intrinsics::transmute(t) // where the result type is the same as
+ +    ///                                // `*t` or `&t`'s
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub CROSSPOINTER_TRANSMUTE,
+ +    complexity,
+ +    "transmutes that have to or from types that are a pointer to the other"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from a pointer to a reference.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This can always be rewritten with `&` and `*`.
+ +    ///
+ +    /// ### Known problems
+ +    /// - `mem::transmute` in statics and constants is stable from Rust 1.46.0,
+ +    /// while dereferencing raw pointer is not stable yet.
+ +    /// If you need to do this in those places,
+ +    /// you would have to use `transmute` instead.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// unsafe {
+ +    ///     let _: &T = std::mem::transmute(p); // where p: *const T
+ +    /// }
+ +    ///
+ +    /// // can be written:
+ +    /// let _: &T = &*p;
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub TRANSMUTE_PTR_TO_REF,
+ +    complexity,
+ +    "transmutes from a pointer to a reference type"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from an integer to a `char`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Not every integer is a Unicode scalar value.
+ +    ///
+ +    /// ### Known problems
+ +    /// - [`from_u32`] which this lint suggests using is slower than `transmute`
+ +    /// as it needs to validate the input.
+ +    /// If you are certain that the input is always a valid Unicode scalar value,
+ +    /// use [`from_u32_unchecked`] which is as fast as `transmute`
+ +    /// but has a semantically meaningful name.
+ +    /// - You might want to handle `None` returned from [`from_u32`] instead of calling `unwrap`.
+ +    ///
+ +    /// [`from_u32`]: https://doc.rust-lang.org/std/char/fn.from_u32.html
+ +    /// [`from_u32_unchecked`]: https://doc.rust-lang.org/std/char/fn.from_u32_unchecked.html
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let x = 1_u32;
+ +    /// unsafe {
+ +    ///     let _: char = std::mem::transmute(x); // where x: u32
+ +    /// }
+ +    ///
+ +    /// // should be:
+ +    /// let _ = std::char::from_u32(x).unwrap();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub TRANSMUTE_INT_TO_CHAR,
+ +    complexity,
+ +    "transmutes from an integer to a `char`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from a `&[u8]` to a `&str`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Not every byte slice is a valid UTF-8 string.
+ +    ///
+ +    /// ### Known problems
+ +    /// - [`from_utf8`] which this lint suggests using is slower than `transmute`
+ +    /// as it needs to validate the input.
+ +    /// If you are certain that the input is always a valid UTF-8,
+ +    /// use [`from_utf8_unchecked`] which is as fast as `transmute`
+ +    /// but has a semantically meaningful name.
+ +    /// - You might want to handle errors returned from [`from_utf8`] instead of calling `unwrap`.
+ +    ///
+ +    /// [`from_utf8`]: https://doc.rust-lang.org/std/str/fn.from_utf8.html
+ +    /// [`from_utf8_unchecked`]: https://doc.rust-lang.org/std/str/fn.from_utf8_unchecked.html
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let b: &[u8] = &[1_u8, 2_u8];
+ +    /// unsafe {
+ +    ///     let _: &str = std::mem::transmute(b); // where b: &[u8]
+ +    /// }
+ +    ///
+ +    /// // should be:
+ +    /// let _ = std::str::from_utf8(b).unwrap();
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub TRANSMUTE_BYTES_TO_STR,
+ +    complexity,
+ +    "transmutes from a `&[u8]` to a `&str`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from an integer to a `bool`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This might result in an invalid in-memory representation of a `bool`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let x = 1_u8;
+ +    /// unsafe {
+ +    ///     let _: bool = std::mem::transmute(x); // where x: u8
+ +    /// }
+ +    ///
+ +    /// // should be:
+ +    /// let _: bool = x != 0;
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub TRANSMUTE_INT_TO_BOOL,
+ +    complexity,
+ +    "transmutes from an integer to a `bool`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from an integer to a float.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Transmutes are dangerous and error-prone, whereas `from_bits` is intuitive
+ +    /// and safe.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// unsafe {
+ +    ///     let _: f32 = std::mem::transmute(1_u32); // where x: u32
+ +    /// }
+ +    ///
+ +    /// // should be:
+ +    /// let _: f32 = f32::from_bits(1_u32);
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub TRANSMUTE_INT_TO_FLOAT,
+ +    complexity,
+ +    "transmutes from an integer to a float"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from a float to an integer.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Transmutes are dangerous and error-prone, whereas `to_bits` is intuitive
+ +    /// and safe.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// unsafe {
+ +    ///     let _: u32 = std::mem::transmute(1f32);
+ +    /// }
+ +    ///
+ +    /// // should be:
+ +    /// let _: u32 = 1f32.to_bits();
+ +    /// ```
+ +    #[clippy::version = "1.41.0"]
+ +    pub TRANSMUTE_FLOAT_TO_INT,
+ +    complexity,
+ +    "transmutes from a float to an integer"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from a number to an array of `u8`
+ +    ///
+ +    /// ### Why this is bad?
+ +    /// Transmutes are dangerous and error-prone, whereas `to_ne_bytes`
+ +    /// is intuitive and safe.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// unsafe {
+ +    ///     let x: [u8; 8] = std::mem::transmute(1i64);
+ +    /// }
+ +    ///
+ +    /// // should be
+ +    /// let x: [u8; 8] = 0i64.to_ne_bytes();
+ +    /// ```
+ +    #[clippy::version = "1.58.0"]
+ +    pub TRANSMUTE_NUM_TO_BYTES,
+ +    complexity,
+ +    "transmutes from a number to an array of `u8`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes from a pointer to a pointer, or
+ +    /// from a reference to a reference.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Transmutes are dangerous, and these can instead be
+ +    /// written as casts.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// let ptr = &1u32 as *const u32;
+ +    /// unsafe {
+ +    ///     // pointer-to-pointer transmute
+ +    ///     let _: *const f32 = std::mem::transmute(ptr);
+ +    ///     // ref-ref transmute
+ +    ///     let _: &f32 = std::mem::transmute(&1u32);
+ +    /// }
+ +    /// // These can be respectively written:
+ +    /// let _ = ptr as *const f32;
+ +    /// let _ = unsafe{ &*(&1u32 as *const u32 as *const f32) };
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub TRANSMUTE_PTR_TO_PTR,
+ +    pedantic,
+ +    "transmutes from a pointer to a pointer / a reference to a reference"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for transmutes between collections whose
+ +    /// types have different ABI, size or alignment.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is undefined behavior.
+ +    ///
+ +    /// ### Known problems
+ +    /// Currently, we cannot know whether a type is a
+ +    /// collection, so we just lint the ones that come with `std`.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// // different size, therefore likely out-of-bounds memory access
+ +    /// // You absolutely do not want this in your code!
+ +    /// unsafe {
+ +    ///     std::mem::transmute::<_, Vec<u32>>(vec![2_u16])
+ +    /// };
+ +    /// ```
+ +    ///
+ +    /// You must always iterate, map and collect the values:
+ +    ///
+ +    /// ```rust
+ +    /// vec![2_u16].into_iter().map(u32::from).collect::<Vec<_>>();
+ +    /// ```
+ +    #[clippy::version = "1.40.0"]
+ +    pub UNSOUND_COLLECTION_TRANSMUTE,
+ +    correctness,
+ +    "transmute between collections of layout-incompatible types"
+ +}
+ +
++declare_clippy_lint! {
++    /// ### What it does
++    /// Checks for transmutes either to or from a type which does not have a defined representation.
++    ///
++    /// ### Why is this bad?
++    /// The results of such a transmute are not defined.
++    ///
++    /// ### Example
++    /// ```rust
++    /// struct Foo<T>(u32, T);
++    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
++    /// ```
++    /// Use instead:
++    /// ```rust
++    /// #[repr(C)]
++    /// struct Foo<T>(u32, T);
++    /// let _ = unsafe { core::mem::transmute::<Foo<u32>, Foo<i32>>(Foo(0u32, 0u32)) };
++    /// ```
++    #[clippy::version = "1.60.0"]
++    pub TRANSMUTE_UNDEFINED_REPR,
++    correctness,
++    "transmute to or from a type with an undefined representation"
++}
++
+ +declare_lint_pass!(Transmute => [
+ +    CROSSPOINTER_TRANSMUTE,
+ +    TRANSMUTE_PTR_TO_REF,
+ +    TRANSMUTE_PTR_TO_PTR,
+ +    USELESS_TRANSMUTE,
+ +    WRONG_TRANSMUTE,
+ +    TRANSMUTE_INT_TO_CHAR,
+ +    TRANSMUTE_BYTES_TO_STR,
+ +    TRANSMUTE_INT_TO_BOOL,
+ +    TRANSMUTE_INT_TO_FLOAT,
+ +    TRANSMUTE_FLOAT_TO_INT,
+ +    TRANSMUTE_NUM_TO_BYTES,
+ +    UNSOUND_COLLECTION_TRANSMUTE,
+ +    TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
++    TRANSMUTE_UNDEFINED_REPR,
+ +]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for Transmute {
-             if let ExprKind::Call(path_expr, args) = e.kind;
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+ +        if_chain! {
-                 let from_ty = cx.typeck_results().expr_ty(&args[0]);
++            if let ExprKind::Call(path_expr, [arg]) = e.kind;
+ +            if let ExprKind::Path(ref qpath) = path_expr.kind;
+ +            if let Some(def_id) = cx.qpath_res(qpath, path_expr.hir_id).opt_def_id();
+ +            if cx.tcx.is_diagnostic_item(sym::transmute, def_id);
+ +            then {
+ +                // Avoid suggesting from/to bits and dereferencing raw pointers in const contexts.
+ +                // See https://github.com/rust-lang/rust/issues/73736 for progress on making them `const fn`.
+ +                // And see https://github.com/rust-lang/rust/issues/51911 for dereferencing raw pointers.
+ +                let const_context = in_constant(cx, e.hir_id);
+ +
-                 if useless_transmute::check(cx, e, from_ty, to_ty, args) {
++                let from_ty = cx.typeck_results().expr_ty(arg);
+ +                let to_ty = cx.typeck_results().expr_ty(e);
+ +
+ +                // If useless_transmute is triggered, the other lints can be skipped.
-                 let mut linted = wrong_transmute::check(cx, e, from_ty, to_ty);
-                 linted |= crosspointer_transmute::check(cx, e, from_ty, to_ty);
-                 linted |= transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, args, qpath);
-                 linted |= transmute_int_to_char::check(cx, e, from_ty, to_ty, args);
-                 linted |= transmute_ref_to_ref::check(cx, e, from_ty, to_ty, args, const_context);
-                 linted |= transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, args);
-                 linted |= transmute_int_to_bool::check(cx, e, from_ty, to_ty, args);
-                 linted |= transmute_int_to_float::check(cx, e, from_ty, to_ty, args, const_context);
-                 linted |= transmute_float_to_int::check(cx, e, from_ty, to_ty, args, const_context);
-                 linted |= transmute_num_to_bytes::check(cx, e, from_ty, to_ty, args, const_context);
-                 linted |= unsound_collection_transmute::check(cx, e, from_ty, to_ty);
++                if useless_transmute::check(cx, e, from_ty, to_ty, arg) {
+ +                    return;
+ +                }
+ +
-                     transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, args);
++                let linted = wrong_transmute::check(cx, e, from_ty, to_ty)
++                    | crosspointer_transmute::check(cx, e, from_ty, to_ty)
++                    | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, qpath)
++                    | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg)
++                    | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
++                    | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg)
++                    | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
++                    | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context)
++                    | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context)
++                    | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context)
++                    | (
++                        unsound_collection_transmute::check(cx, e, from_ty, to_ty)
++                        || transmute_undefined_repr::check(cx, e, from_ty, to_ty)
++                    );
+ +
+ +                if !linted {
++                    transmutes_expressible_as_ptr_casts::check(cx, e, from_ty, to_ty, arg);
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs

index 3aa3c393ba57cce3a8d26a402683405ba607f099,0000000000000000000000000000000000000000..d5ef86dc4e572703af49941486832c5c9bea462e

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs
@@@ -1,66 -1,0 +1,65 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::TRANSMUTE_FLOAT_TO_INT;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use if_chain::if_chain;
+ +use rustc_ast as ast;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{Expr, ExprKind, UnOp};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +
+ +/// Checks for `transmute_float_to_int` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     let mut expr = &args[0];
-                     let mut arg = sugg::Sugg::hir(cx, expr, "..");
++    mut arg: &'tcx Expr<'_>,
+ +    const_context: bool,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::Float(float_ty), ty::Int(_) | ty::Uint(_)) if !const_context => {
+ +            span_lint_and_then(
+ +                cx,
+ +                TRANSMUTE_FLOAT_TO_INT,
+ +                e.span,
+ +                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+ +                |diag| {
-                     if let ExprKind::Unary(UnOp::Neg, inner_expr) = &expr.kind {
-                         expr = inner_expr;
++                    let mut sugg = sugg::Sugg::hir(cx, arg, "..");
+ +
-                         if let ExprKind::Lit(lit) = &expr.kind;
++                    if let ExprKind::Unary(UnOp::Neg, inner_expr) = &arg.kind {
++                        arg = inner_expr;
+ +                    }
+ +
+ +                    if_chain! {
+ +                        // if the expression is a float literal and it is unsuffixed then
+ +                        // add a suffix so the suggestion is valid and unambiguous
-                             let op = format!("{}{}", arg, float_ty.name_str()).into();
-                             match arg {
-                                 sugg::Sugg::MaybeParen(_) => arg = sugg::Sugg::MaybeParen(op),
-                                 _ => arg = sugg::Sugg::NonParen(op)
++                        if let ExprKind::Lit(lit) = &arg.kind;
+ +                        if let ast::LitKind::Float(_, ast::LitFloatType::Unsuffixed) = lit.node;
+ +                        then {
-                     arg = sugg::Sugg::NonParen(format!("{}.to_bits()", arg.maybe_par()).into());
++                            let op = format!("{}{}", sugg, float_ty.name_str()).into();
++                            match sugg {
++                                sugg::Sugg::MaybeParen(_) => sugg = sugg::Sugg::MaybeParen(op),
++                                _ => sugg = sugg::Sugg::NonParen(op)
+ +                            }
+ +                        }
+ +                    }
+ +
-                     arg = if let ty::Int(int_ty) = to_ty.kind() {
-                         arg.as_ty(int_ty.name_str().to_string())
++                    sugg = sugg::Sugg::NonParen(format!("{}.to_bits()", sugg.maybe_par()).into());
+ +
+ +                    // cast the result of `to_bits` if `to_ty` is signed
-                         arg
++                    sugg = if let ty::Int(int_ty) = to_ty.kind() {
++                        sugg.as_ty(int_ty.name_str().to_string())
+ +                    } else {
-                     diag.span_suggestion(e.span, "consider using", arg.to_string(), Applicability::Unspecified);
++                        sugg
+ +                    };
+ +
++                    diag.span_suggestion(e.span, "consider using", sugg.to_string(), Applicability::Unspecified);
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_bool.rs

index cc0a5643e2a7d35295de3f9eff785371fdbc1ad7,0000000000000000000000000000000000000000..8c50b58ca4b862af20360774f2a4654df4fa1085

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_bool.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_bool.rs
@@@ -1,42 -1,0 +1,42 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::TRANSMUTE_INT_TO_BOOL;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use rustc_ast as ast;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +use std::borrow::Cow;
+ +
+ +/// Checks for `transmute_int_to_bool` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     let arg = sugg::Sugg::hir(cx, &args[0], "..");
++    arg: &'tcx Expr<'_>,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::Int(ty::IntTy::I8) | ty::Uint(ty::UintTy::U8), ty::Bool) => {
+ +            span_lint_and_then(
+ +                cx,
+ +                TRANSMUTE_INT_TO_BOOL,
+ +                e.span,
+ +                &format!("transmute from a `{}` to a `bool`", from_ty),
+ +                |diag| {
++                    let arg = sugg::Sugg::hir(cx, arg, "..");
+ +                    let zero = sugg::Sugg::NonParen(Cow::from("0"));
+ +                    diag.span_suggestion(
+ +                        e.span,
+ +                        "consider using",
+ +                        sugg::make_binop(ast::BinOpKind::Ne, &arg, &zero).to_string(),
+ +                        Applicability::Unspecified,
+ +                    );
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_char.rs

index e83d2e06b9a8d26800e7b0a65b6f02e2b42221c8,0000000000000000000000000000000000000000..3eb07b68992a89b96ff10c4a40277023c8878536

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_char.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_char.rs
@@@ -1,45 -1,0 +1,45 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::TRANSMUTE_INT_TO_CHAR;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use rustc_ast as ast;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +
+ +/// Checks for `transmute_int_to_char` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     let arg = sugg::Sugg::hir(cx, &args[0], "..");
++    arg: &'tcx Expr<'_>,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::Int(ty::IntTy::I32) | ty::Uint(ty::UintTy::U32), &ty::Char) => {
+ +            span_lint_and_then(
+ +                cx,
+ +                TRANSMUTE_INT_TO_CHAR,
+ +                e.span,
+ +                &format!("transmute from a `{}` to a `char`", from_ty),
+ +                |diag| {
++                    let arg = sugg::Sugg::hir(cx, arg, "..");
+ +                    let arg = if let ty::Int(_) = from_ty.kind() {
+ +                        arg.as_ty(ast::UintTy::U32.name_str())
+ +                    } else {
+ +                        arg
+ +                    };
+ +                    diag.span_suggestion(
+ +                        e.span,
+ +                        "consider using",
+ +                        format!("std::char::from_u32({}).unwrap()", arg),
+ +                        Applicability::Unspecified,
+ +                    );
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs

index 05eee380d6f409bdf275384d089a16b4334abf80,0000000000000000000000000000000000000000..b8703052e6c869750a09751579885123c0e1143a

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs
@@@ -1,48 -1,0 +1,48 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::TRANSMUTE_INT_TO_FLOAT;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +
+ +/// Checks for `transmute_int_to_float` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     let arg = sugg::Sugg::hir(cx, &args[0], "..");
++    arg: &'tcx Expr<'_>,
+ +    const_context: bool,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context => {
+ +            span_lint_and_then(
+ +                cx,
+ +                TRANSMUTE_INT_TO_FLOAT,
+ +                e.span,
+ +                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+ +                |diag| {
++                    let arg = sugg::Sugg::hir(cx, arg, "..");
+ +                    let arg = if let ty::Int(int_ty) = from_ty.kind() {
+ +                        arg.as_ty(format!(
+ +                            "u{}",
+ +                            int_ty.bit_width().map_or_else(|| "size".to_string(), |v| v.to_string())
+ +                        ))
+ +                    } else {
+ +                        arg
+ +                    };
+ +                    diag.span_suggestion(
+ +                        e.span,
+ +                        "consider using",
+ +                        format!("{}::from_bits({})", to_ty, arg),
+ +                        Applicability::Unspecified,
+ +                    );
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs

index 5ba58a764940191728d0266f5c77b2e2cc113ef2,0000000000000000000000000000000000000000..52d193d11e1a08dab87adca2de3548d904b3d16f

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs
@@@ -1,49 -1,0 +1,49 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::TRANSMUTE_NUM_TO_BYTES;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty, UintTy};
+ +
+ +/// Checks for `transmute_int_to_float` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     let arg = sugg::Sugg::hir(cx, &args[0], "..");
++    arg: &'tcx Expr<'_>,
+ +    const_context: bool,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::Int(_) | ty::Uint(_) | ty::Float(_), ty::Array(arr_ty, _)) => {
+ +            if !matches!(arr_ty.kind(), ty::Uint(UintTy::U8)) {
+ +                return false;
+ +            }
+ +            if matches!(from_ty.kind(), ty::Float(_)) && const_context {
+ +                // TODO: Remove when const_float_bits_conv is stabilized
+ +                // rust#72447
+ +                return false;
+ +            }
+ +
+ +            span_lint_and_then(
+ +                cx,
+ +                TRANSMUTE_NUM_TO_BYTES,
+ +                e.span,
+ +                &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+ +                |diag| {
++                    let arg = sugg::Sugg::hir(cx, arg, "..");
+ +                    diag.span_suggestion(
+ +                        e.span,
+ +                        "consider using `to_ne_bytes()`",
+ +                        format!("{}.to_ne_bytes()", arg),
+ +                        Applicability::Unspecified,
+ +                    );
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs

index 7b646bfc0c6d13e0bb544d4aef8fede6beb8f0cb,0000000000000000000000000000000000000000..d712b33de9e1a49ead17804603354e5d09055bcd

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@@ -1,36 -1,0 +1,36 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::TRANSMUTE_PTR_TO_PTR;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +
+ +/// Checks for `transmute_ptr_to_ptr` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
++    arg: &'tcx Expr<'_>,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::RawPtr(_), ty::RawPtr(to_ty)) => {
+ +            span_lint_and_then(
+ +                cx,
+ +                TRANSMUTE_PTR_TO_PTR,
+ +                e.span,
+ +                "transmute from a pointer to a pointer",
+ +                |diag| {
++                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+ +                        let sugg = arg.as_ty(cx.tcx.mk_ptr(*to_ty));
+ +                        diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
+ +                    }
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs

index f14eef936453114abb3b4814fafe2cfe09c95826,0000000000000000000000000000000000000000..5699f8e92cfca82428614d957a7075a249f6e071

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@@ -1,56 -1,0 +1,56 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::utils::get_type_snippet;
+ +use super::TRANSMUTE_PTR_TO_REF;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{Expr, Mutability, QPath};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +
+ +/// Checks for `transmute_ptr_to_ref` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     let arg = sugg::Sugg::hir(cx, &args[0], "..");
++    arg: &'tcx Expr<'_>,
+ +    qpath: &'tcx QPath<'_>,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::RawPtr(from_ptr_ty), ty::Ref(_, to_ref_ty, mutbl)) => {
+ +            span_lint_and_then(
+ +                cx,
+ +                TRANSMUTE_PTR_TO_REF,
+ +                e.span,
+ +                &format!(
+ +                    "transmute from a pointer type (`{}`) to a reference type (`{}`)",
+ +                    from_ty, to_ty
+ +                ),
+ +                |diag| {
++                    let arg = sugg::Sugg::hir(cx, arg, "..");
+ +                    let (deref, cast) = if *mutbl == Mutability::Mut {
+ +                        ("&mut *", "*mut")
+ +                    } else {
+ +                        ("&*", "*const")
+ +                    };
+ +
+ +                    let arg = if from_ptr_ty.ty == *to_ref_ty {
+ +                        arg
+ +                    } else {
+ +                        arg.as_ty(&format!("{} {}", cast, get_type_snippet(cx, qpath, to_ref_ty)))
+ +                    };
+ +
+ +                    diag.span_suggestion(
+ +                        e.span,
+ +                        "try",
+ +                        sugg::make_unop(deref, arg).to_string(),
+ +                        Applicability::Unspecified,
+ +                    );
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs

index d105e37abf9c08281553f4298958db2e2f1bc9c6,0000000000000000000000000000000000000000..fdef8bac7f9b093faf73679e13d3c319596b69c9

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs
@@@ -1,87 -1,0 +1,87 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::{TRANSMUTE_BYTES_TO_STR, TRANSMUTE_PTR_TO_PTR};
+ +use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+ +use clippy_utils::source::snippet;
+ +use clippy_utils::sugg;
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{Expr, Mutability};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +
+ +/// Checks for `transmute_bytes_to_str` and `transmute_ptr_to_ptr` lints.
+ +/// Returns `true` if either one triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                         snippet(cx, args[0].span, ".."),
++    arg: &'tcx Expr<'_>,
+ +    const_context: bool,
+ +) -> bool {
+ +    let mut triggered = false;
+ +
+ +    if let (ty::Ref(_, ty_from, from_mutbl), ty::Ref(_, ty_to, to_mutbl)) = (&from_ty.kind(), &to_ty.kind()) {
+ +        if_chain! {
+ +            if let (&ty::Slice(slice_ty), &ty::Str) = (&ty_from.kind(), &ty_to.kind());
+ +            if let ty::Uint(ty::UintTy::U8) = slice_ty.kind();
+ +            if from_mutbl == to_mutbl;
+ +            then {
+ +                let postfix = if *from_mutbl == Mutability::Mut {
+ +                    "_mut"
+ +                } else {
+ +                    ""
+ +                };
+ +
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    TRANSMUTE_BYTES_TO_STR,
+ +                    e.span,
+ +                    &format!("transmute from a `{}` to a `{}`", from_ty, to_ty),
+ +                    "consider using",
+ +                    format!(
+ +                        "std::str::from_utf8{}({}).unwrap()",
+ +                        postfix,
-                         |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
++                        snippet(cx, arg.span, ".."),
+ +                    ),
+ +                    Applicability::Unspecified,
+ +                );
+ +                triggered = true;
+ +            } else {
+ +                if (cx.tcx.erase_regions(from_ty) != cx.tcx.erase_regions(to_ty))
+ +                    && !const_context {
+ +                    span_lint_and_then(
+ +                        cx,
+ +                        TRANSMUTE_PTR_TO_PTR,
+ +                        e.span,
+ +                        "transmute from a reference to a reference",
++                        |diag| if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+ +                            let ty_from_and_mut = ty::TypeAndMut {
+ +                                ty: ty_from,
+ +                                mutbl: *from_mutbl
+ +                            };
+ +                            let ty_to_and_mut = ty::TypeAndMut { ty: ty_to, mutbl: *to_mutbl };
+ +                            let sugg_paren = arg
+ +                                .as_ty(cx.tcx.mk_ptr(ty_from_and_mut))
+ +                                .as_ty(cx.tcx.mk_ptr(ty_to_and_mut));
+ +                            let sugg = if *to_mutbl == Mutability::Mut {
+ +                                sugg_paren.mut_addr_deref()
+ +                            } else {
+ +                                sugg_paren.addr_deref()
+ +                            };
+ +                            diag.span_suggestion(
+ +                                e.span,
+ +                                "try",
+ +                                sugg.to_string(),
+ +                                Applicability::Unspecified,
+ +                            );
+ +                        },
+ +                    );
+ +
+ +                    triggered = true;
+ +                }
+ +            }
+ +        }
+ +    }
+ +
+ +    triggered
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..c91bc3245e41784e24bd7a18dd10d95b1235efc7

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@@ -1,0 -1,0 +1,289 @@@
++use super::TRANSMUTE_UNDEFINED_REPR;
++use clippy_utils::diagnostics::span_lint_and_then;
++use rustc_hir::Expr;
++use rustc_lint::LateContext;
++use rustc_middle::ty::subst::{GenericArg, Subst};
++use rustc_middle::ty::{self, Ty, TypeAndMut};
++use rustc_span::Span;
++
++#[allow(clippy::too_many_lines)]
++pub(super) fn check<'tcx>(
++    cx: &LateContext<'tcx>,
++    e: &'tcx Expr<'_>,
++    from_ty_orig: Ty<'tcx>,
++    to_ty_orig: Ty<'tcx>,
++) -> bool {
++    let mut from_ty = cx.tcx.erase_regions(from_ty_orig);
++    let mut to_ty = cx.tcx.erase_regions(to_ty_orig);
++
++    while from_ty != to_ty {
++        match reduce_refs(cx, e.span, from_ty, to_ty) {
++            ReducedTys::FromFatPtr { unsized_ty, .. } => {
++                span_lint_and_then(
++                    cx,
++                    TRANSMUTE_UNDEFINED_REPR,
++                    e.span,
++                    &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
++                    |diag| {
++                        if from_ty_orig.peel_refs() != unsized_ty {
++                            diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
++                        }
++                    },
++                );
++                return true;
++            },
++            ReducedTys::ToFatPtr { unsized_ty, .. } => {
++                span_lint_and_then(
++                    cx,
++                    TRANSMUTE_UNDEFINED_REPR,
++                    e.span,
++                    &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
++                    |diag| {
++                        if to_ty_orig.peel_refs() != unsized_ty {
++                            diag.note(&format!("the contained type `&{}` has an undefined layout", unsized_ty));
++                        }
++                    },
++                );
++                return true;
++            },
++            ReducedTys::ToPtr {
++                from_ty: from_sub_ty,
++                to_ty: to_sub_ty,
++            } => match reduce_ty(cx, from_sub_ty) {
++                ReducedTy::UnorderedFields(from_ty) => {
++                    span_lint_and_then(
++                        cx,
++                        TRANSMUTE_UNDEFINED_REPR,
++                        e.span,
++                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
++                        |diag| {
++                            if from_ty_orig.peel_refs() != from_ty {
++                                diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
++                            }
++                        },
++                    );
++                    return true;
++                },
++                ReducedTy::Ref(from_sub_ty) => {
++                    from_ty = from_sub_ty;
++                    to_ty = to_sub_ty;
++                    continue;
++                },
++                _ => break,
++            },
++            ReducedTys::FromPtr {
++                from_ty: from_sub_ty,
++                to_ty: to_sub_ty,
++            } => match reduce_ty(cx, to_sub_ty) {
++                ReducedTy::UnorderedFields(to_ty) => {
++                    span_lint_and_then(
++                        cx,
++                        TRANSMUTE_UNDEFINED_REPR,
++                        e.span,
++                        &format!("transmute to `{}` which has an undefined layout", to_ty_orig),
++                        |diag| {
++                            if to_ty_orig.peel_refs() != to_ty {
++                                diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
++                            }
++                        },
++                    );
++                    return true;
++                },
++                ReducedTy::Ref(to_sub_ty) => {
++                    from_ty = from_sub_ty;
++                    to_ty = to_sub_ty;
++                    continue;
++                },
++                _ => break,
++            },
++            ReducedTys::Other {
++                from_ty: from_sub_ty,
++                to_ty: to_sub_ty,
++            } => match (reduce_ty(cx, from_sub_ty), reduce_ty(cx, to_sub_ty)) {
++                (ReducedTy::IntArray, _) | (_, ReducedTy::IntArray) => return false,
++                (ReducedTy::UnorderedFields(from_ty), ReducedTy::UnorderedFields(to_ty)) if from_ty != to_ty => {
++                    span_lint_and_then(
++                        cx,
++                        TRANSMUTE_UNDEFINED_REPR,
++                        e.span,
++                        &format!(
++                            "transmute from `{}` to `{}`, both of which have an undefined layout",
++                            from_ty_orig, to_ty_orig
++                        ),
++                        |diag| {
++                            if let (Some(from_def), Some(to_def)) = (from_ty.ty_adt_def(), to_ty.ty_adt_def())
++                                && from_def == to_def
++                            {
++                                diag.note(&format!(
++                                    "two instances of the same generic type (`{}`) may have different layouts",
++                                    cx.tcx.item_name(from_def.did)
++                                ));
++                            } else {
++                                if from_ty_orig.peel_refs() != from_ty {
++                                    diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
++                                }
++                                if to_ty_orig.peel_refs() != to_ty {
++                                    diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
++                                }
++                            }
++                        },
++                    );
++                    return true;
++                },
++                (
++                    ReducedTy::UnorderedFields(from_ty),
++                    ReducedTy::Other(_) | ReducedTy::OrderedFields(_) | ReducedTy::Ref(_),
++                ) => {
++                    span_lint_and_then(
++                        cx,
++                        TRANSMUTE_UNDEFINED_REPR,
++                        e.span,
++                        &format!("transmute from `{}` which has an undefined layout", from_ty_orig),
++                        |diag| {
++                            if from_ty_orig.peel_refs() != from_ty {
++                                diag.note(&format!("the contained type `{}` has an undefined layout", from_ty));
++                            }
++                        },
++                    );
++                    return true;
++                },
++                (
++                    ReducedTy::Other(_) | ReducedTy::OrderedFields(_) | ReducedTy::Ref(_),
++                    ReducedTy::UnorderedFields(to_ty),
++                ) => {
++                    span_lint_and_then(
++                        cx,
++                        TRANSMUTE_UNDEFINED_REPR,
++                        e.span,
++                        &format!("transmute into `{}` which has an undefined layout", to_ty_orig),
++                        |diag| {
++                            if to_ty_orig.peel_refs() != to_ty {
++                                diag.note(&format!("the contained type `{}` has an undefined layout", to_ty));
++                            }
++                        },
++                    );
++                    return true;
++                },
++                (ReducedTy::Ref(from_sub_ty), ReducedTy::Ref(to_sub_ty)) => {
++                    from_ty = from_sub_ty;
++                    to_ty = to_sub_ty;
++                    continue;
++                },
++                (
++                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_),
++                    ReducedTy::OrderedFields(_) | ReducedTy::Ref(_) | ReducedTy::Other(_),
++                )
++                | (ReducedTy::UnorderedFields(_), ReducedTy::UnorderedFields(_)) => break,
++            },
++        }
++    }
++
++    false
++}
++
++enum ReducedTys<'tcx> {
++    FromFatPtr { unsized_ty: Ty<'tcx> },
++    ToFatPtr { unsized_ty: Ty<'tcx> },
++    ToPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
++    FromPtr { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
++    Other { from_ty: Ty<'tcx>, to_ty: Ty<'tcx> },
++}
++
++fn reduce_refs<'tcx>(
++    cx: &LateContext<'tcx>,
++    span: Span,
++    mut from_ty: Ty<'tcx>,
++    mut to_ty: Ty<'tcx>,
++) -> ReducedTys<'tcx> {
++    loop {
++        return match (from_ty.kind(), to_ty.kind()) {
++            (
++                ty::Ref(_, from_sub_ty, _) | ty::RawPtr(TypeAndMut { ty: from_sub_ty, .. }),
++                ty::Ref(_, to_sub_ty, _) | ty::RawPtr(TypeAndMut { ty: to_sub_ty, .. }),
++            ) => {
++                from_ty = from_sub_ty;
++                to_ty = to_sub_ty;
++                continue;
++            },
++            (ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. }), _)
++                if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
++            {
++                ReducedTys::FromFatPtr { unsized_ty }
++            },
++            (_, ty::Ref(_, unsized_ty, _) | ty::RawPtr(TypeAndMut { ty: unsized_ty, .. }))
++                if !unsized_ty.is_sized(cx.tcx.at(span), cx.param_env) =>
++            {
++                ReducedTys::ToFatPtr { unsized_ty }
++            },
++            (ty::Ref(_, from_ty, _) | ty::RawPtr(TypeAndMut { ty: from_ty, .. }), _) => {
++                ReducedTys::FromPtr { from_ty, to_ty }
++            },
++            (_, ty::Ref(_, to_ty, _) | ty::RawPtr(TypeAndMut { ty: to_ty, .. })) => {
++                ReducedTys::ToPtr { from_ty, to_ty }
++            },
++            _ => ReducedTys::Other { from_ty, to_ty },
++        };
++    }
++}
++
++enum ReducedTy<'tcx> {
++    OrderedFields(Ty<'tcx>),
++    UnorderedFields(Ty<'tcx>),
++    Ref(Ty<'tcx>),
++    Other(Ty<'tcx>),
++    IntArray,
++}
++
++fn reduce_ty<'tcx>(cx: &LateContext<'tcx>, mut ty: Ty<'tcx>) -> ReducedTy<'tcx> {
++    loop {
++        ty = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty).unwrap_or(ty);
++        return match *ty.kind() {
++            ty::Array(sub_ty, _) if matches!(sub_ty.kind(), ty::Int(_) | ty::Uint(_)) => ReducedTy::IntArray,
++            ty::Array(sub_ty, _) | ty::Slice(sub_ty) => {
++                ty = sub_ty;
++                continue;
++            },
++            ty::Tuple(args) => {
++                let mut iter = args.iter().map(GenericArg::expect_ty);
++                let Some(sized_ty) = iter.find(|ty| !is_zero_sized_ty(cx, ty)) else {
++                    return ReducedTy::OrderedFields(ty);
++                };
++                if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
++                    ty = sized_ty;
++                    continue;
++                }
++                ReducedTy::UnorderedFields(ty)
++            },
++            ty::Adt(def, substs) if def.is_struct() => {
++                if def.repr.inhibit_struct_field_reordering_opt() {
++                    return ReducedTy::OrderedFields(ty);
++                }
++                let mut iter = def
++                    .non_enum_variant()
++                    .fields
++                    .iter()
++                    .map(|f| cx.tcx.type_of(f.did).subst(cx.tcx, substs));
++                let Some(sized_ty) = iter.find(|ty| !is_zero_sized_ty(cx, ty)) else {
++                    return ReducedTy::OrderedFields(ty);
++                };
++                if iter.all(|ty| is_zero_sized_ty(cx, ty)) {
++                    ty = sized_ty;
++                    continue;
++                }
++                ReducedTy::UnorderedFields(ty)
++            },
++            ty::Ref(..) | ty::RawPtr(_) => ReducedTy::Ref(ty),
++            _ => ReducedTy::Other(ty),
++        };
++    }
++}
++
++fn is_zero_sized_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
++    if let Ok(ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, ty)
++        && let Ok(layout) = cx.tcx.layout_of(cx.param_env.and(ty))
++    {
++        layout.layout.size.bytes() == 0
++    } else {
++        false
++    }
++}
diff --cc src/tools/clippy/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs

index e2c6d130f3c9cd40c537732af1e4b02e8305e0a7,0000000000000000000000000000000000000000..626d7cd46fc43c1383717d3b670780df06bc6201

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs
@@@ -1,39 -1,0 +1,39 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::utils::can_be_expressed_as_pointer_cast;
+ +use super::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS;
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::sugg;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::Ty;
+ +
+ +/// Checks for `transmutes_expressible_as_ptr_casts` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                 if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
++    arg: &'tcx Expr<'_>,
+ +) -> bool {
+ +    if can_be_expressed_as_pointer_cast(cx, e, from_ty, to_ty) {
+ +        span_lint_and_then(
+ +            cx,
+ +            TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS,
+ +            e.span,
+ +            &format!(
+ +                "transmute from `{}` to `{}` which could be expressed as a pointer cast instead",
+ +                from_ty, to_ty
+ +            ),
+ +            |diag| {
++                if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+ +                    let sugg = arg.as_ty(&to_ty.to_string()).to_string();
+ +                    diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
+ +                }
+ +            },
+ +        );
+ +        true
+ +    } else {
+ +        false
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/unsound_collection_transmute.rs

index 2ce8d4031d77cb7c721bf207404c8e5bc6d68875,0000000000000000000000000000000000000000..2d67401a15f2d65b96cacdbaa0f92e69c6ae7fce

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/unsound_collection_transmute.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/unsound_collection_transmute.rs
@@@ -1,50 -1,0 +1,52 @@@
- use clippy_utils::match_any_diagnostic_items;
+ +use super::utils::is_layout_incompatible;
+ +use super::UNSOUND_COLLECTION_TRANSMUTE;
+ +use clippy_utils::diagnostics::span_lint;
- use rustc_span::symbol::{sym, Symbol};
- 
- // used to check for UNSOUND_COLLECTION_TRANSMUTE
- static COLLECTIONS: &[Symbol] = &[
-     sym::Vec,
-     sym::VecDeque,
-     sym::BinaryHeap,
-     sym::BTreeSet,
-     sym::BTreeMap,
-     sym::HashSet,
-     sym::HashMap,
- ];
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
-             if from_adt.did != to_adt.did || match_any_diagnostic_items(cx, to_adt.did, COLLECTIONS).is_none() {
++use rustc_span::symbol::sym;
+ +
+ +/// Checks for `unsound_collection_transmute` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, from_ty: Ty<'tcx>, to_ty: Ty<'tcx>) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        (ty::Adt(from_adt, from_substs), ty::Adt(to_adt, to_substs)) => {
++            if from_adt.did != to_adt.did {
++                return false;
++            }
++            if !matches!(
++                cx.tcx.get_diagnostic_name(to_adt.did),
++                Some(
++                    sym::BTreeMap
++                        | sym::BTreeSet
++                        | sym::BinaryHeap
++                        | sym::HashMap
++                        | sym::HashSet
++                        | sym::Vec
++                        | sym::VecDeque
++                )
++            ) {
+ +                return false;
+ +            }
+ +            if from_substs
+ +                .types()
+ +                .zip(to_substs.types())
+ +                .any(|(from_ty, to_ty)| is_layout_incompatible(cx, from_ty, to_ty))
+ +            {
+ +                span_lint(
+ +                    cx,
+ +                    UNSOUND_COLLECTION_TRANSMUTE,
+ +                    e.span,
+ +                    &format!(
+ +                        "transmute from `{}` to `{}` with mismatched layout is unsound",
+ +                        from_ty, to_ty
+ +                    ),
+ +                );
+ +                true
+ +            } else {
+ +                false
+ +            }
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/transmute/useless_transmute.rs

index 445bcf60fa71a68e4481a945f4abda3a012d2cb3,0000000000000000000000000000000000000000..998f97eb5d8c65990e2f7348a256a16c6b8072ec

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/transmute/useless_transmute.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/transmute/useless_transmute.rs
@@@ -1,74 -1,0 +1,74 @@@
-     args: &'tcx [Expr<'_>],
+ +use super::USELESS_TRANSMUTE;
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+ +use clippy_utils::sugg;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::Expr;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::{self, Ty};
+ +
+ +/// Checks for `useless_transmute` lint.
+ +/// Returns `true` if it's triggered, otherwise returns `false`.
+ +pub(super) fn check<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    e: &'tcx Expr<'_>,
+ +    from_ty: Ty<'tcx>,
+ +    to_ty: Ty<'tcx>,
-                     if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
++    arg: &'tcx Expr<'_>,
+ +) -> bool {
+ +    match (&from_ty.kind(), &to_ty.kind()) {
+ +        _ if from_ty == to_ty => {
+ +            span_lint(
+ +                cx,
+ +                USELESS_TRANSMUTE,
+ +                e.span,
+ +                &format!("transmute from a type (`{}`) to itself", from_ty),
+ +            );
+ +            true
+ +        },
+ +        (ty::Ref(_, rty, rty_mutbl), ty::RawPtr(ptr_ty)) => {
+ +            span_lint_and_then(
+ +                cx,
+ +                USELESS_TRANSMUTE,
+ +                e.span,
+ +                "transmute from a reference to a pointer",
+ +                |diag| {
-                     if let Some(arg) = sugg::Sugg::hir_opt(cx, &args[0]) {
++                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+ +                        let rty_and_mut = ty::TypeAndMut {
+ +                            ty: rty,
+ +                            mutbl: *rty_mutbl,
+ +                        };
+ +
+ +                        let sugg = if *ptr_ty == rty_and_mut {
+ +                            arg.as_ty(to_ty)
+ +                        } else {
+ +                            arg.as_ty(cx.tcx.mk_ptr(rty_and_mut)).as_ty(to_ty)
+ +                        };
+ +
+ +                        diag.span_suggestion(e.span, "try", sugg.to_string(), Applicability::Unspecified);
+ +                    }
+ +                },
+ +            );
+ +            true
+ +        },
+ +        (ty::Int(_) | ty::Uint(_), ty::RawPtr(_)) => {
+ +            span_lint_and_then(
+ +                cx,
+ +                USELESS_TRANSMUTE,
+ +                e.span,
+ +                "transmute from an integer to a pointer",
+ +                |diag| {
++                    if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
+ +                        diag.span_suggestion(
+ +                            e.span,
+ +                            "try",
+ +                            arg.as_ty(&to_ty.to_string()).to_string(),
+ +                            Applicability::Unspecified,
+ +                        );
+ +                    }
+ +                },
+ +            );
+ +            true
+ +        },
+ +        _ => false,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/types/box_collection.rs

index 538c10a5b2045403640a0cae49cb1ce8ba9db760,0000000000000000000000000000000000000000..21a9558ec076a54e938fadc06f56fb6f9fa5ee34

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/types/box_collection.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/types/box_collection.rs
@@@ -1,50 -1,0 +1,45 @@@
- use clippy_utils::is_ty_param_diagnostic_item;
+ +use clippy_utils::diagnostics::span_lint_and_help;
- use rustc_span::symbol::sym;
++use clippy_utils::{path_def_id, qpath_generic_tys};
+ +use rustc_hir::{self as hir, def_id::DefId, QPath};
+ +use rustc_lint::LateContext;
-             let generic = if item_type == "String" {
-                 ""
-             } else {
-                 "<..>"
++use rustc_span::{sym, Symbol};
+ +
+ +use super::BOX_COLLECTION;
+ +
+ +pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+ +    if_chain! {
+ +        if Some(def_id) == cx.tcx.lang_items().owned_box();
+ +        if let Some(item_type) = get_std_collection(cx, qpath);
+ +        then {
- fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
-     if is_ty_param_diagnostic_item(cx, qpath, sym::Vec).is_some() {
-         Some("Vec")
-     } else if is_ty_param_diagnostic_item(cx, qpath, sym::String).is_some() {
-         Some("String")
-     } else if is_ty_param_diagnostic_item(cx, qpath, sym::HashMap).is_some() {
-         Some("HashMap")
-     } else {
-         None
-     }
++            let generic = match item_type {
++                sym::String => "",
++                _ => "<..>",
+ +            };
+ +            span_lint_and_help(
+ +                cx,
+ +                BOX_COLLECTION,
+ +                hir_ty.span,
+ +                &format!(
+ +                    "you seem to be trying to use `Box<{outer}{generic}>`. Consider using just `{outer}{generic}`",
+ +                    outer=item_type,
+ +                    generic = generic),
+ +                None,
+ +                &format!(
+ +                    "`{outer}{generic}` is already on the heap, `Box<{outer}{generic}>` makes an extra allocation",
+ +                    outer=item_type,
+ +                    generic = generic)
+ +            );
+ +            true
+ +        } else {
+ +            false
+ +        }
+ +    }
+ +}
+ +
++fn get_std_collection(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<Symbol> {
++    let param = qpath_generic_tys(qpath).next()?;
++    let id = path_def_id(cx, param)?;
++    cx.tcx
++        .get_diagnostic_name(id)
++        .filter(|&name| matches!(name, sym::HashMap | sym::String | sym::Vec))
+ +}
diff --cc src/tools/clippy/clippy_lints/src/types/option_option.rs

index 903e62995c61702be4775eb152c9674a5e25486b,0000000000000000000000000000000000000000..8767e3c30a68ac4564ba72814b48f53719090be3

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/types/option_option.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/types/option_option.rs
@@@ -1,22 -1,0 +1,28 @@@
- use clippy_utils::is_ty_param_diagnostic_item;
+ +use clippy_utils::diagnostics::span_lint;
-     if cx.tcx.is_diagnostic_item(sym::Option, def_id) && is_ty_param_diagnostic_item(cx, qpath, sym::Option).is_some() {
-         span_lint(
-             cx,
-             OPTION_OPTION,
-             hir_ty.span,
-             "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
-                                  enum if you need to distinguish all 3 cases",
-         );
-         true
-     } else {
-         false
++use clippy_utils::{path_def_id, qpath_generic_tys};
++use if_chain::if_chain;
+ +use rustc_hir::{self as hir, def_id::DefId, QPath};
+ +use rustc_lint::LateContext;
+ +use rustc_span::symbol::sym;
+ +
+ +use super::OPTION_OPTION;
+ +
+ +pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
++    if_chain! {
++        if cx.tcx.is_diagnostic_item(sym::Option, def_id);
++        if let Some(arg) = qpath_generic_tys(qpath).next();
++        if path_def_id(cx, arg) == Some(def_id);
++        then {
++            span_lint(
++                cx,
++                OPTION_OPTION,
++                hir_ty.span,
++                "consider using `Option<T>` instead of `Option<Option<T>>` or a custom \
++                                     enum if you need to distinguish all 3 cases",
++            );
++            true
++        } else {
++            false
++        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/types/rc_buffer.rs

index 31c4abdfc95ea59d4f953926d80af3e14f9c9f1a,0000000000000000000000000000000000000000..4d72a29e8c74722711aeb3b6a754e3d0c2bd4765

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/types/rc_buffer.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/types/rc_buffer.rs
@@@ -1,97 -1,0 +1,106 @@@
- use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item};
+ +use clippy_utils::diagnostics::span_lint_and_sugg;
+ +use clippy_utils::source::snippet_with_applicability;
-         } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Vec) {
++use clippy_utils::{path_def_id, qpath_generic_tys};
+ +use rustc_errors::Applicability;
+ +use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
+ +use rustc_lint::LateContext;
+ +use rustc_span::symbol::sym;
+ +
+ +use super::RC_BUFFER;
+ +
+ +pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+ +    if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+ +        if let Some(alternate) = match_buffer_type(cx, qpath) {
+ +            span_lint_and_sugg(
+ +                cx,
+ +                RC_BUFFER,
+ +                hir_ty.span,
+ +                "usage of `Rc<T>` when T is a buffer type",
+ +                "try",
+ +                format!("Rc<{}>", alternate),
+ +                Applicability::MachineApplicable,
+ +            );
-             let inner_span = match get_qpath_generic_tys(qpath).next() {
++        } else {
++            let Some(ty) = qpath_generic_tys(qpath).next() else { return false };
++            let Some(id) = path_def_id(cx, ty) else { return false };
++            if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
++                return false;
++            }
+ +            let qpath = match &ty.kind {
+ +                TyKind::Path(qpath) => qpath,
+ +                _ => return false,
+ +            };
-         } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Vec) {
++            let inner_span = match qpath_generic_tys(qpath).next() {
+ +                Some(ty) => ty.span,
+ +                None => return false,
+ +            };
+ +            let mut applicability = Applicability::MachineApplicable;
+ +            span_lint_and_sugg(
+ +                cx,
+ +                RC_BUFFER,
+ +                hir_ty.span,
+ +                "usage of `Rc<T>` when T is a buffer type",
+ +                "try",
+ +                format!(
+ +                    "Rc<[{}]>",
+ +                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+ +                ),
+ +                Applicability::MachineApplicable,
+ +            );
+ +            return true;
+ +        }
+ +    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+ +        if let Some(alternate) = match_buffer_type(cx, qpath) {
+ +            span_lint_and_sugg(
+ +                cx,
+ +                RC_BUFFER,
+ +                hir_ty.span,
+ +                "usage of `Arc<T>` when T is a buffer type",
+ +                "try",
+ +                format!("Arc<{}>", alternate),
+ +                Applicability::MachineApplicable,
+ +            );
-             let inner_span = match get_qpath_generic_tys(qpath).next() {
++        } else if let Some(ty) = qpath_generic_tys(qpath).next() {
++            let Some(id) = path_def_id(cx, ty) else { return false };
++            if !cx.tcx.is_diagnostic_item(sym::Vec, id) {
++                return false;
++            }
+ +            let qpath = match &ty.kind {
+ +                TyKind::Path(qpath) => qpath,
+ +                _ => return false,
+ +            };
-     if is_ty_param_diagnostic_item(cx, qpath, sym::String).is_some() {
-         Some("str")
-     } else if is_ty_param_diagnostic_item(cx, qpath, sym::OsString).is_some() {
-         Some("std::ffi::OsStr")
-     } else if is_ty_param_diagnostic_item(cx, qpath, sym::PathBuf).is_some() {
-         Some("std::path::Path")
-     } else {
-         None
-     }
++            let inner_span = match qpath_generic_tys(qpath).next() {
+ +                Some(ty) => ty.span,
+ +                None => return false,
+ +            };
+ +            let mut applicability = Applicability::MachineApplicable;
+ +            span_lint_and_sugg(
+ +                cx,
+ +                RC_BUFFER,
+ +                hir_ty.span,
+ +                "usage of `Arc<T>` when T is a buffer type",
+ +                "try",
+ +                format!(
+ +                    "Arc<[{}]>",
+ +                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+ +                ),
+ +                Applicability::MachineApplicable,
+ +            );
+ +            return true;
+ +        }
+ +    }
+ +
+ +    false
+ +}
+ +
+ +fn match_buffer_type(cx: &LateContext<'_>, qpath: &QPath<'_>) -> Option<&'static str> {
++    let ty = qpath_generic_tys(qpath).next()?;
++    let id = path_def_id(cx, ty)?;
++    let path = match cx.tcx.get_diagnostic_name(id)? {
++        sym::String => "str",
++        sym::OsString => "std::ffi::OsStr",
++        sym::PathBuf => "std::path::Path",
++        _ => return None,
++    };
++    Some(path)
+ +}
diff --cc src/tools/clippy/clippy_lints/src/types/rc_mutex.rs

index d54608a07bb27e70a5432be150f6fcd137b9653e,0000000000000000000000000000000000000000..a75972cf3ddbe1e2d91acbf11fc541577c7ed7e5

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/types/rc_mutex.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/types/rc_mutex.rs
@@@ -1,28 -1,0 +1,30 @@@
- use clippy_utils::is_ty_param_diagnostic_item;
+ +use clippy_utils::diagnostics::span_lint_and_help;
-         if let Some(_) = is_ty_param_diagnostic_item(cx, qpath, sym::Mutex) ;
++use clippy_utils::{path_def_id, qpath_generic_tys};
+ +use if_chain::if_chain;
+ +use rustc_hir::{self as hir, def_id::DefId, QPath};
+ +use rustc_lint::LateContext;
+ +use rustc_span::symbol::sym;
+ +
+ +use super::RC_MUTEX;
+ +
+ +pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+ +    if_chain! {
+ +        if cx.tcx.is_diagnostic_item(sym::Rc, def_id) ;
++        if let Some(arg) = qpath_generic_tys(qpath).next();
++        if let Some(id) = path_def_id(cx, arg);
++        if cx.tcx.is_diagnostic_item(sym::Mutex, id);
+ +        then {
+ +            span_lint_and_help(
+ +                cx,
+ +                RC_MUTEX,
+ +                hir_ty.span,
+ +                "usage of `Rc<Mutex<_>>`",
+ +                None,
+ +                "consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
+ +            );
+ +            return true;
+ +        }
+ +    }
+ +
+ +    false
+ +}
diff --cc src/tools/clippy/clippy_lints/src/types/redundant_allocation.rs

index ac7bdd6a1ebebf318c6e8eab2a46bbcb999b2328,0000000000000000000000000000000000000000..10d2ae2eb1dbb8808eb0fa601d0fc1ffad349dfb

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/types/redundant_allocation.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/types/redundant_allocation.rs
@@@ -1,113 -1,0 +1,112 @@@
- use clippy_utils::{get_qpath_generic_tys, is_ty_param_diagnostic_item, is_ty_param_lang_item};
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::source::{snippet, snippet_with_applicability};
- use rustc_hir::{self as hir, def_id::DefId, LangItem, QPath, TyKind};
++use clippy_utils::{path_def_id, qpath_generic_tys};
+ +use rustc_errors::Applicability;
-     let (inner_sym, ty) = if let Some(ty) = is_ty_param_lang_item(cx, qpath, LangItem::OwnedBox) {
-         ("Box", ty)
-     } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Rc) {
-         ("Rc", ty)
-     } else if let Some(ty) = is_ty_param_diagnostic_item(cx, qpath, sym::Arc) {
-         ("Arc", ty)
-     } else {
-         return false;
++use rustc_hir::{self as hir, def_id::DefId, QPath, TyKind};
+ +use rustc_lint::LateContext;
+ +use rustc_span::symbol::sym;
+ +
+ +use super::{utils, REDUNDANT_ALLOCATION};
+ +
+ +pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_>, def_id: DefId) -> bool {
+ +    let outer_sym = if Some(def_id) == cx.tcx.lang_items().owned_box() {
+ +        "Box"
+ +    } else if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
+ +        "Rc"
+ +    } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
+ +        "Arc"
+ +    } else {
+ +        return false;
+ +    };
+ +
+ +    if let Some(span) = utils::match_borrows_parameter(cx, qpath) {
+ +        let mut applicability = Applicability::MaybeIncorrect;
+ +        let generic_snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
+ +        span_lint_and_then(
+ +            cx,
+ +            REDUNDANT_ALLOCATION,
+ +            hir_ty.span,
+ +            &format!("usage of `{}<{}>`", outer_sym, generic_snippet),
+ +            |diag| {
+ +                diag.span_suggestion(hir_ty.span, "try", format!("{}", generic_snippet), applicability);
+ +                diag.note(&format!(
+ +                    "`{generic}` is already a pointer, `{outer}<{generic}>` allocates a pointer on the heap",
+ +                    outer = outer_sym,
+ +                    generic = generic_snippet
+ +                ));
+ +            },
+ +        );
+ +        return true;
+ +    }
+ +
-     let inner_span = match get_qpath_generic_tys(inner_qpath).next() {
++    let Some(ty) = qpath_generic_tys(qpath).next() else { return false };
++    let Some(id) = path_def_id(cx, ty) else { return false };
++    let (inner_sym, ty) = match cx.tcx.get_diagnostic_name(id) {
++        Some(sym::Arc) => ("Arc", ty),
++        Some(sym::Rc) => ("Rc", ty),
++        _ if Some(id) == cx.tcx.lang_items().owned_box() => ("Box", ty),
++        _ => return false,
+ +    };
+ +
+ +    let inner_qpath = match &ty.kind {
+ +        TyKind::Path(inner_qpath) => inner_qpath,
+ +        _ => return false,
+ +    };
++    let inner_span = match qpath_generic_tys(inner_qpath).next() {
+ +        Some(ty) => {
+ +            // Box<Box<dyn T>> is smaller than Box<dyn T> because of wide pointers
+ +            if matches!(ty.kind, TyKind::TraitObject(..)) {
+ +                return false;
+ +            }
+ +            ty.span
+ +        },
+ +        None => return false,
+ +    };
+ +    if inner_sym == outer_sym {
+ +        let mut applicability = Applicability::MaybeIncorrect;
+ +        let generic_snippet = snippet_with_applicability(cx, inner_span, "..", &mut applicability);
+ +        span_lint_and_then(
+ +            cx,
+ +            REDUNDANT_ALLOCATION,
+ +            hir_ty.span,
+ +            &format!("usage of `{}<{}<{}>>`", outer_sym, inner_sym, generic_snippet),
+ +            |diag| {
+ +                diag.span_suggestion(
+ +                    hir_ty.span,
+ +                    "try",
+ +                    format!("{}<{}>", outer_sym, generic_snippet),
+ +                    applicability,
+ +                );
+ +                diag.note(&format!(
+ +                    "`{inner}<{generic}>` is already on the heap, `{outer}<{inner}<{generic}>>` makes an extra allocation",
+ +                    outer = outer_sym,
+ +                    inner = inner_sym,
+ +                    generic = generic_snippet
+ +                ));
+ +            },
+ +        );
+ +    } else {
+ +        let generic_snippet = snippet(cx, inner_span, "..");
+ +        span_lint_and_then(
+ +            cx,
+ +            REDUNDANT_ALLOCATION,
+ +            hir_ty.span,
+ +            &format!("usage of `{}<{}<{}>>`", outer_sym, inner_sym, generic_snippet),
+ +            |diag| {
+ +                diag.note(&format!(
+ +                    "`{inner}<{generic}>` is already on the heap, `{outer}<{inner}<{generic}>>` makes an extra allocation",
+ +                    outer = outer_sym,
+ +                    inner = inner_sym,
+ +                    generic = generic_snippet
+ +                ));
+ +                diag.help(&format!(
+ +                    "consider using just `{outer}<{generic}>` or `{inner}<{generic}>`",
+ +                    outer = outer_sym,
+ +                    inner = inner_sym,
+ +                    generic = generic_snippet
+ +                ));
+ +            },
+ +        );
+ +    }
+ +    true
+ +}
diff --cc src/tools/clippy/clippy_lints/src/unwrap.rs

index e984048701341099acc25ba8b70b5981f2bb14ae,0000000000000000000000000000000000000000..9b9e25326f9663b11e84984b0acb71e59ffc1cfa

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/unwrap.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/unwrap.rs
@@@ -1,328 -1,0 +1,329 @@@
- use clippy_utils::{differing_macro_contexts, path_to_local, usage::is_potentially_mutated};
+ +use clippy_utils::diagnostics::span_lint_and_then;
+ +use clippy_utils::higher;
+ +use clippy_utils::ty::is_type_diagnostic_item;
-                 if !differing_macro_contexts(unwrappable.branch.span, expr.span);
-                 if !differing_macro_contexts(unwrappable.branch.span, unwrappable.check.span);
++use clippy_utils::{path_to_local, usage::is_potentially_mutated};
+ +use if_chain::if_chain;
+ +use rustc_errors::Applicability;
+ +use rustc_hir::intravisit::{walk_expr, walk_fn, FnKind, Visitor};
+ +use rustc_hir::{BinOpKind, Body, Expr, ExprKind, FnDecl, HirId, PathSegment, UnOp};
+ +use rustc_lint::{LateContext, LateLintPass};
+ +use rustc_middle::hir::nested_filter;
+ +use rustc_middle::lint::in_external_macro;
+ +use rustc_middle::ty::Ty;
+ +use rustc_session::{declare_lint_pass, declare_tool_lint};
+ +use rustc_span::source_map::Span;
+ +use rustc_span::sym;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calls of `unwrap[_err]()` that cannot fail.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Using `if let` or `match` is more idiomatic.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let option = Some(0);
+ +    /// # fn do_something_with(_x: usize) {}
+ +    /// if option.is_some() {
+ +    ///     do_something_with(option.unwrap())
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// Could be written:
+ +    ///
+ +    /// ```rust
+ +    /// # let option = Some(0);
+ +    /// # fn do_something_with(_x: usize) {}
+ +    /// if let Some(value) = option {
+ +    ///     do_something_with(value)
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub UNNECESSARY_UNWRAP,
+ +    complexity,
+ +    "checks for calls of `unwrap[_err]()` that cannot fail"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calls of `unwrap[_err]()` that will always fail.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// If panicking is desired, an explicit `panic!()` should be used.
+ +    ///
+ +    /// ### Known problems
+ +    /// This lint only checks `if` conditions not assignments.
+ +    /// So something like `let x: Option<()> = None; x.unwrap();` will not be recognized.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust
+ +    /// # let option = Some(0);
+ +    /// # fn do_something_with(_x: usize) {}
+ +    /// if option.is_none() {
+ +    ///     do_something_with(option.unwrap())
+ +    /// }
+ +    /// ```
+ +    ///
+ +    /// This code will always panic. The if condition should probably be inverted.
+ +    #[clippy::version = "pre 1.29.0"]
+ +    pub PANICKING_UNWRAP,
+ +    correctness,
+ +    "checks for calls of `unwrap[_err]()` that will always fail"
+ +}
+ +
+ +/// Visitor that keeps track of which variables are unwrappable.
+ +struct UnwrappableVariablesVisitor<'a, 'tcx> {
+ +    unwrappables: Vec<UnwrapInfo<'tcx>>,
+ +    cx: &'a LateContext<'tcx>,
+ +}
+ +
+ +/// What kind of unwrappable this is.
+ +#[derive(Copy, Clone, Debug)]
+ +enum UnwrappableKind {
+ +    Option,
+ +    Result,
+ +}
+ +
+ +impl UnwrappableKind {
+ +    fn success_variant_pattern(self) -> &'static str {
+ +        match self {
+ +            UnwrappableKind::Option => "Some(..)",
+ +            UnwrappableKind::Result => "Ok(..)",
+ +        }
+ +    }
+ +
+ +    fn error_variant_pattern(self) -> &'static str {
+ +        match self {
+ +            UnwrappableKind::Option => "None",
+ +            UnwrappableKind::Result => "Err(..)",
+ +        }
+ +    }
+ +}
+ +
+ +/// Contains information about whether a variable can be unwrapped.
+ +#[derive(Copy, Clone, Debug)]
+ +struct UnwrapInfo<'tcx> {
+ +    /// The variable that is checked
+ +    local_id: HirId,
+ +    /// The if itself
+ +    if_expr: &'tcx Expr<'tcx>,
+ +    /// The check, like `x.is_ok()`
+ +    check: &'tcx Expr<'tcx>,
+ +    /// The check's name, like `is_ok`
+ +    check_name: &'tcx PathSegment<'tcx>,
+ +    /// The branch where the check takes place, like `if x.is_ok() { .. }`
+ +    branch: &'tcx Expr<'tcx>,
+ +    /// Whether `is_some()` or `is_ok()` was called (as opposed to `is_err()` or `is_none()`).
+ +    safe_to_unwrap: bool,
+ +    /// What kind of unwrappable this is.
+ +    kind: UnwrappableKind,
+ +    /// If the check is the entire condition (`if x.is_ok()`) or only a part of it (`foo() &&
+ +    /// x.is_ok()`)
+ +    is_entire_condition: bool,
+ +}
+ +
+ +/// Collects the information about unwrappable variables from an if condition
+ +/// The `invert` argument tells us whether the condition is negated.
+ +fn collect_unwrap_info<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    if_expr: &'tcx Expr<'_>,
+ +    expr: &'tcx Expr<'_>,
+ +    branch: &'tcx Expr<'_>,
+ +    invert: bool,
+ +    is_entire_condition: bool,
+ +) -> Vec<UnwrapInfo<'tcx>> {
+ +    fn is_relevant_option_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: &str) -> bool {
+ +        is_type_diagnostic_item(cx, ty, sym::Option) && ["is_some", "is_none"].contains(&method_name)
+ +    }
+ +
+ +    fn is_relevant_result_call(cx: &LateContext<'_>, ty: Ty<'_>, method_name: &str) -> bool {
+ +        is_type_diagnostic_item(cx, ty, sym::Result) && ["is_ok", "is_err"].contains(&method_name)
+ +    }
+ +
+ +    if let ExprKind::Binary(op, left, right) = &expr.kind {
+ +        match (invert, op.node) {
+ +            (false, BinOpKind::And | BinOpKind::BitAnd) | (true, BinOpKind::Or | BinOpKind::BitOr) => {
+ +                let mut unwrap_info = collect_unwrap_info(cx, if_expr, left, branch, invert, false);
+ +                unwrap_info.append(&mut collect_unwrap_info(cx, if_expr, right, branch, invert, false));
+ +                return unwrap_info;
+ +            },
+ +            _ => (),
+ +        }
+ +    } else if let ExprKind::Unary(UnOp::Not, expr) = &expr.kind {
+ +        return collect_unwrap_info(cx, if_expr, expr, branch, !invert, false);
+ +    } else {
+ +        if_chain! {
+ +            if let ExprKind::MethodCall(method_name, args, _) = &expr.kind;
+ +            if let Some(local_id) = path_to_local(&args[0]);
+ +            let ty = cx.typeck_results().expr_ty(&args[0]);
+ +            let name = method_name.ident.as_str();
+ +            if is_relevant_option_call(cx, ty, name) || is_relevant_result_call(cx, ty, name);
+ +            then {
+ +                assert!(args.len() == 1);
+ +                let unwrappable = match name {
+ +                    "is_some" | "is_ok" => true,
+ +                    "is_err" | "is_none" => false,
+ +                    _ => unreachable!(),
+ +                };
+ +                let safe_to_unwrap = unwrappable != invert;
+ +                let kind = if is_type_diagnostic_item(cx, ty, sym::Option) {
+ +                    UnwrappableKind::Option
+ +                } else {
+ +                    UnwrappableKind::Result
+ +                };
+ +
+ +                return vec![
+ +                    UnwrapInfo {
+ +                        local_id,
+ +                        if_expr,
+ +                        check: expr,
+ +                        check_name: method_name,
+ +                        branch,
+ +                        safe_to_unwrap,
+ +                        kind,
+ +                        is_entire_condition,
+ +                    }
+ +                ]
+ +            }
+ +        }
+ +    }
+ +    Vec::new()
+ +}
+ +
+ +impl<'a, 'tcx> UnwrappableVariablesVisitor<'a, 'tcx> {
+ +    fn visit_branch(
+ +        &mut self,
+ +        if_expr: &'tcx Expr<'_>,
+ +        cond: &'tcx Expr<'_>,
+ +        branch: &'tcx Expr<'_>,
+ +        else_branch: bool,
+ +    ) {
+ +        let prev_len = self.unwrappables.len();
+ +        for unwrap_info in collect_unwrap_info(self.cx, if_expr, cond, branch, else_branch, true) {
+ +            if is_potentially_mutated(unwrap_info.local_id, cond, self.cx)
+ +                || is_potentially_mutated(unwrap_info.local_id, branch, self.cx)
+ +            {
+ +                // if the variable is mutated, we don't know whether it can be unwrapped:
+ +                continue;
+ +            }
+ +            self.unwrappables.push(unwrap_info);
+ +        }
+ +        walk_expr(self, branch);
+ +        self.unwrappables.truncate(prev_len);
+ +    }
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for UnwrappableVariablesVisitor<'a, 'tcx> {
+ +    type NestedFilter = nested_filter::OnlyBodies;
+ +
+ +    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+ +        // Shouldn't lint when `expr` is in macro.
+ +        if in_external_macro(self.cx.tcx.sess, expr.span) {
+ +            return;
+ +        }
+ +        if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr) {
+ +            walk_expr(self, cond);
+ +            self.visit_branch(expr, cond, then, false);
+ +            if let Some(else_inner) = r#else {
+ +                self.visit_branch(expr, cond, else_inner, true);
+ +            }
+ +        } else {
+ +            // find `unwrap[_err]()` calls:
+ +            if_chain! {
+ +                if let ExprKind::MethodCall(method_name, [self_arg, ..], _) = expr.kind;
+ +                if let Some(id) = path_to_local(self_arg);
+ +                if [sym::unwrap, sym::expect, sym!(unwrap_err)].contains(&method_name.ident.name);
+ +                let call_to_unwrap = [sym::unwrap, sym::expect].contains(&method_name.ident.name);
+ +                if let Some(unwrappable) = self.unwrappables.iter()
+ +                    .find(|u| u.local_id == id);
+ +                // Span contexts should not differ with the conditional branch
++                let span_ctxt = expr.span.ctxt();
++                if unwrappable.branch.span.ctxt() == span_ctxt;
++                if unwrappable.check.span.ctxt() == span_ctxt;
+ +                then {
+ +                    if call_to_unwrap == unwrappable.safe_to_unwrap {
+ +                        let is_entire_condition = unwrappable.is_entire_condition;
+ +                        let unwrappable_variable_name = self.cx.tcx.hir().name(unwrappable.local_id);
+ +                        let suggested_pattern = if call_to_unwrap {
+ +                            unwrappable.kind.success_variant_pattern()
+ +                        } else {
+ +                            unwrappable.kind.error_variant_pattern()
+ +                        };
+ +
+ +                        span_lint_and_then(
+ +                            self.cx,
+ +                            UNNECESSARY_UNWRAP,
+ +                            expr.span,
+ +                            &format!(
+ +                                "called `{}` on `{}` after checking its variant with `{}`",
+ +                                method_name.ident.name,
+ +                                unwrappable_variable_name,
+ +                                unwrappable.check_name.ident.as_str(),
+ +                            ),
+ +                            |diag| {
+ +                                if is_entire_condition {
+ +                                    diag.span_suggestion(
+ +                                        unwrappable.check.span.with_lo(unwrappable.if_expr.span.lo()),
+ +                                        "try",
+ +                                        format!(
+ +                                            "if let {} = {}",
+ +                                            suggested_pattern,
+ +                                            unwrappable_variable_name,
+ +                                        ),
+ +                                        // We don't track how the unwrapped value is used inside the
+ +                                        // block or suggest deleting the unwrap, so we can't offer a
+ +                                        // fixable solution.
+ +                                        Applicability::Unspecified,
+ +                                    );
+ +                                } else {
+ +                                    diag.span_label(unwrappable.check.span, "the check is happening here");
+ +                                    diag.help("try using `if let` or `match`");
+ +                                }
+ +                            },
+ +                        );
+ +                    } else {
+ +                        span_lint_and_then(
+ +                            self.cx,
+ +                            PANICKING_UNWRAP,
+ +                            expr.span,
+ +                            &format!("this call to `{}()` will always panic",
+ +                            method_name.ident.name),
+ +                            |diag| { diag.span_label(unwrappable.check.span, "because of this check"); },
+ +                        );
+ +                    }
+ +                }
+ +            }
+ +            walk_expr(self, expr);
+ +        }
+ +    }
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +}
+ +
+ +declare_lint_pass!(Unwrap => [PANICKING_UNWRAP, UNNECESSARY_UNWRAP]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for Unwrap {
+ +    fn check_fn(
+ +        &mut self,
+ +        cx: &LateContext<'tcx>,
+ +        kind: FnKind<'tcx>,
+ +        decl: &'tcx FnDecl<'_>,
+ +        body: &'tcx Body<'_>,
+ +        span: Span,
+ +        fn_id: HirId,
+ +    ) {
+ +        if span.from_expansion() {
+ +            return;
+ +        }
+ +
+ +        let mut v = UnwrappableVariablesVisitor {
+ +            cx,
+ +            unwrappables: Vec::new(),
+ +        };
+ +
+ +        walk_fn(&mut v, kind, decl, body.id(), span, fn_id);
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_lints/src/utils/conf.rs

index c9d99617c1e281f8315bfc2669fd71243155a3ad,0000000000000000000000000000000000000000..680b2eb1da723d7696878d7d9f1ed2d27f69ebc7

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/utils/conf.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/utils/conf.rs
@@@ -1,353 -1,0 +1,371 @@@
-                     Ok(_) => return Ok(Some(config_file)),
+ +//! Read configurations files.
+ +
+ +#![allow(clippy::module_name_repetitions)]
+ +
+ +use serde::de::{Deserializer, IgnoredAny, IntoDeserializer, MapAccess, Visitor};
+ +use serde::Deserialize;
+ +use std::error::Error;
+ +use std::path::{Path, PathBuf};
+ +use std::{env, fmt, fs, io};
+ +
+ +/// Holds information used by `MISSING_ENFORCED_IMPORT_RENAMES` lint.
+ +#[derive(Clone, Debug, Deserialize)]
+ +pub struct Rename {
+ +    pub path: String,
+ +    pub rename: String,
+ +}
+ +
+ +/// A single disallowed method, used by the `DISALLOWED_METHODS` lint.
+ +#[derive(Clone, Debug, Deserialize)]
+ +#[serde(untagged)]
+ +pub enum DisallowedMethod {
+ +    Simple(String),
+ +    WithReason { path: String, reason: Option<String> },
+ +}
+ +
+ +impl DisallowedMethod {
+ +    pub fn path(&self) -> &str {
+ +        let (Self::Simple(path) | Self::WithReason { path, .. }) = self;
+ +
+ +        path
+ +    }
+ +}
+ +
+ +/// A single disallowed type, used by the `DISALLOWED_TYPES` lint.
+ +#[derive(Clone, Debug, Deserialize)]
+ +#[serde(untagged)]
+ +pub enum DisallowedType {
+ +    Simple(String),
+ +    WithReason { path: String, reason: Option<String> },
+ +}
+ +
+ +/// Conf with parse errors
+ +#[derive(Default)]
+ +pub struct TryConf {
+ +    pub conf: Conf,
+ +    pub errors: Vec<String>,
+ +}
+ +
+ +impl TryConf {
+ +    fn from_error(error: impl Error) -> Self {
+ +        Self {
+ +            conf: Conf::default(),
+ +            errors: vec![error.to_string()],
+ +        }
+ +    }
+ +}
+ +
+ +macro_rules! define_Conf {
+ +    ($(
+ +        $(#[doc = $doc:literal])+
+ +        $(#[conf_deprecated($dep:literal)])?
+ +        ($name:ident: $ty:ty = $default:expr),
+ +    )*) => {
+ +        /// Clippy lint configuration
+ +        pub struct Conf {
+ +            $($(#[doc = $doc])+ pub $name: $ty,)*
+ +        }
+ +
+ +        mod defaults {
+ +            $(pub fn $name() -> $ty { $default })*
+ +        }
+ +
+ +        impl Default for Conf {
+ +            fn default() -> Self {
+ +                Self { $($name: defaults::$name(),)* }
+ +            }
+ +        }
+ +
+ +        impl<'de> Deserialize<'de> for TryConf {
+ +            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
+ +                deserializer.deserialize_map(ConfVisitor)
+ +            }
+ +        }
+ +
+ +        #[derive(Deserialize)]
+ +        #[serde(field_identifier, rename_all = "kebab-case")]
+ +        #[allow(non_camel_case_types)]
+ +        enum Field { $($name,)* third_party, }
+ +
+ +        struct ConfVisitor;
+ +
+ +        impl<'de> Visitor<'de> for ConfVisitor {
+ +            type Value = TryConf;
+ +
+ +            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+ +                formatter.write_str("Conf")
+ +            }
+ +
+ +            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error> where V: MapAccess<'de> {
+ +                let mut errors = Vec::new();
+ +                $(let mut $name = None;)*
+ +                // could get `Field` here directly, but get `str` first for diagnostics
+ +                while let Some(name) = map.next_key::<&str>()? {
+ +                    match Field::deserialize(name.into_deserializer())? {
+ +                        $(Field::$name => {
+ +                            $(errors.push(format!("deprecated field `{}`. {}", name, $dep));)?
+ +                            match map.next_value() {
+ +                                Err(e) => errors.push(e.to_string()),
+ +                                Ok(value) => match $name {
+ +                                    Some(_) => errors.push(format!("duplicate field `{}`", name)),
+ +                                    None => $name = Some(value),
+ +                                }
+ +                            }
+ +                        })*
+ +                        // white-listed; ignore
+ +                        Field::third_party => drop(map.next_value::<IgnoredAny>())
+ +                    }
+ +                }
+ +                let conf = Conf { $($name: $name.unwrap_or_else(defaults::$name),)* };
+ +                Ok(TryConf { conf, errors })
+ +            }
+ +        }
+ +
+ +        #[cfg(feature = "internal")]
+ +        pub mod metadata {
+ +            use crate::utils::internal_lints::metadata_collector::ClippyConfiguration;
+ +
+ +            macro_rules! wrap_option {
+ +                () => (None);
+ +                ($x:literal) => (Some($x));
+ +            }
+ +
+ +            pub(crate) fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
+ +                vec![
+ +                    $(
+ +                        {
+ +                            let deprecation_reason = wrap_option!($($dep)?);
+ +
+ +                            ClippyConfiguration::new(
+ +                                stringify!($name),
+ +                                stringify!($ty),
+ +                                format!("{:?}", super::defaults::$name()),
+ +                                concat!($($doc, '\n',)*),
+ +                                deprecation_reason,
+ +                            )
+ +                        },
+ +                    )+
+ +                ]
+ +            }
+ +        }
+ +    };
+ +}
+ +
+ +define_Conf! {
+ +    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX.
+ +    ///
+ +    /// Suppress lints whenever the suggested change would cause breakage for other crates.
+ +    (avoid_breaking_exported_api: bool = true),
+ +    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS.
+ +    ///
+ +    /// The minimum rust version that the project supports
+ +    (msrv: Option<String> = None),
+ +    /// Lint: BLACKLISTED_NAME.
+ +    ///
+ +    /// The list of blacklisted names to lint about. NB: `bar` is not here since it has legitimate uses
+ +    (blacklisted_names: Vec<String> = ["foo", "baz", "quux"].iter().map(ToString::to_string).collect()),
+ +    /// Lint: COGNITIVE_COMPLEXITY.
+ +    ///
+ +    /// The maximum cognitive complexity a function can have
+ +    (cognitive_complexity_threshold: u64 = 25),
+ +    /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
+ +    ///
+ +    /// Use the Cognitive Complexity lint instead.
+ +    #[conf_deprecated("Please use `cognitive-complexity-threshold` instead")]
+ +    (cyclomatic_complexity_threshold: Option<u64> = None),
+ +    /// Lint: DOC_MARKDOWN.
+ +    ///
+ +    /// The list of words this lint should not consider as identifiers needing ticks
+ +    (doc_valid_idents: Vec<String> = [
+ +        "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",
+ +        "DirectX",
+ +        "ECMAScript",
+ +        "GPLv2", "GPLv3",
+ +        "GitHub", "GitLab",
+ +        "IPv4", "IPv6",
+ +        "ClojureScript", "CoffeeScript", "JavaScript", "PureScript", "TypeScript",
+ +        "NaN", "NaNs",
+ +        "OAuth", "GraphQL",
+ +        "OCaml",
+ +        "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenDNS",
+ +        "WebGL",
+ +        "TensorFlow",
+ +        "TrueType",
+ +        "iOS", "macOS", "FreeBSD",
+ +        "TeX", "LaTeX", "BibTeX", "BibLaTeX",
+ +        "MinGW",
+ +        "CamelCase",
+ +    ].iter().map(ToString::to_string).collect()),
+ +    /// Lint: TOO_MANY_ARGUMENTS.
+ +    ///
+ +    /// The maximum number of argument a function or method can have
+ +    (too_many_arguments_threshold: u64 = 7),
+ +    /// Lint: TYPE_COMPLEXITY.
+ +    ///
+ +    /// The maximum complexity a type can have
+ +    (type_complexity_threshold: u64 = 250),
+ +    /// Lint: MANY_SINGLE_CHAR_NAMES.
+ +    ///
+ +    /// The maximum number of single char bindings a scope may have
+ +    (single_char_binding_names_threshold: u64 = 4),
+ +    /// Lint: BOXED_LOCAL, USELESS_VEC.
+ +    ///
+ +    /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+ +    (too_large_for_stack: u64 = 200),
+ +    /// Lint: ENUM_VARIANT_NAMES.
+ +    ///
+ +    /// The minimum number of enum variants for the lints about variant names to trigger
+ +    (enum_variant_name_threshold: u64 = 3),
+ +    /// Lint: LARGE_ENUM_VARIANT.
+ +    ///
+ +    /// The maximum size of an enum's variant to avoid box suggestion
+ +    (enum_variant_size_threshold: u64 = 200),
+ +    /// Lint: VERBOSE_BIT_MASK.
+ +    ///
+ +    /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+ +    (verbose_bit_mask_threshold: u64 = 1),
+ +    /// Lint: DECIMAL_LITERAL_REPRESENTATION.
+ +    ///
+ +    /// The lower bound for linting decimal literals
+ +    (literal_representation_threshold: u64 = 16384),
+ +    /// Lint: TRIVIALLY_COPY_PASS_BY_REF.
+ +    ///
+ +    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by reference.
+ +    (trivial_copy_size_limit: Option<u64> = None),
+ +    /// Lint: LARGE_TYPE_PASS_BY_MOVE.
+ +    ///
+ +    /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+ +    (pass_by_value_size_limit: u64 = 256),
+ +    /// Lint: TOO_MANY_LINES.
+ +    ///
+ +    /// The maximum number of lines a function or method can have
+ +    (too_many_lines_threshold: u64 = 100),
+ +    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
+ +    ///
+ +    /// The maximum allowed size for arrays on the stack
+ +    (array_size_threshold: u64 = 512_000),
+ +    /// Lint: VEC_BOX.
+ +    ///
+ +    /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+ +    (vec_box_size_threshold: u64 = 4096),
+ +    /// Lint: TYPE_REPETITION_IN_BOUNDS.
+ +    ///
+ +    /// The maximum number of bounds a trait can have to be linted
+ +    (max_trait_bounds: u64 = 3),
+ +    /// Lint: STRUCT_EXCESSIVE_BOOLS.
+ +    ///
+ +    /// The maximum number of bool fields a struct can have
+ +    (max_struct_bools: u64 = 3),
+ +    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS.
+ +    ///
+ +    /// The maximum number of bool parameters a function can have
+ +    (max_fn_params_bools: u64 = 3),
+ +    /// Lint: WILDCARD_IMPORTS.
+ +    ///
+ +    /// Whether to allow certain wildcard imports (prelude, super in tests).
+ +    (warn_on_all_wildcard_imports: bool = false),
+ +    /// Lint: DISALLOWED_METHODS.
+ +    ///
+ +    /// The list of disallowed methods, written as fully qualified paths.
+ +    (disallowed_methods: Vec<crate::utils::conf::DisallowedMethod> = Vec::new()),
+ +    /// Lint: DISALLOWED_TYPES.
+ +    ///
+ +    /// The list of disallowed types, written as fully qualified paths.
+ +    (disallowed_types: Vec<crate::utils::conf::DisallowedType> = Vec::new()),
+ +    /// Lint: UNREADABLE_LITERAL.
+ +    ///
+ +    /// Should the fraction of a decimal be linted to include separators.
+ +    (unreadable_literal_lint_fractions: bool = true),
+ +    /// Lint: UPPER_CASE_ACRONYMS.
+ +    ///
+ +    /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
+ +    (upper_case_acronyms_aggressive: bool = false),
+ +    /// Lint: _CARGO_COMMON_METADATA.
+ +    ///
+ +    /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+ +    (cargo_ignore_publish: bool = false),
+ +    /// Lint: NONSTANDARD_MACRO_BRACES.
+ +    ///
+ +    /// Enforce the named macros always use the braces specified.
+ +    ///
+ +    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
+ +    /// is could be used with a full path two `MacroMatcher`s have to be added one with the full path
+ +    /// `crate_name::macro_name` and one with just the macro name.
+ +    (standard_macro_braces: Vec<crate::nonstandard_macro_braces::MacroMatcher> = Vec::new()),
+ +    /// Lint: MISSING_ENFORCED_IMPORT_RENAMES.
+ +    ///
+ +    /// The list of imports to always rename, a fully qualified path followed by the rename.
+ +    (enforced_import_renames: Vec<crate::utils::conf::Rename> = Vec::new()),
+ +    /// Lint: DISALLOWED_SCRIPT_IDENTS.
+ +    ///
+ +    /// The list of unicode scripts allowed to be used in the scope.
+ +    (allowed_scripts: Vec<String> = ["Latin"].iter().map(ToString::to_string).collect()),
+ +    /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
+ +    ///
+ +    /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
+ +    (enable_raw_pointer_heuristic_for_send: bool = true),
+ +    /// Lint: INDEX_REFUTABLE_SLICE.
+ +    ///
+ +    /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
+ +    /// the slice pattern that is suggested. If more elements would be necessary, the lint is suppressed.
+ +    /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
+ +    (max_suggested_slice_pattern_length: u64 = 3),
+ +}
+ +
+ +/// Search for the configuration file.
+ +pub fn lookup_conf_file() -> io::Result<Option<PathBuf>> {
+ +    /// Possible filename to search for.
+ +    const CONFIG_FILE_NAMES: [&str; 2] = [".clippy.toml", "clippy.toml"];
+ +
+ +    // Start looking for a config file in CLIPPY_CONF_DIR, or failing that, CARGO_MANIFEST_DIR.
+ +    // If neither of those exist, use ".".
+ +    let mut current = env::var_os("CLIPPY_CONF_DIR")
+ +        .or_else(|| env::var_os("CARGO_MANIFEST_DIR"))
+ +        .map_or_else(|| PathBuf::from("."), PathBuf::from);
++
++    let mut found_config: Option<PathBuf> = None;
++
+ +    loop {
+ +        for config_file_name in &CONFIG_FILE_NAMES {
+ +            if let Ok(config_file) = current.join(config_file_name).canonicalize() {
+ +                match fs::metadata(&config_file) {
+ +                    Err(e) if e.kind() == io::ErrorKind::NotFound => {},
+ +                    Err(e) => return Err(e),
+ +                    Ok(md) if md.is_dir() => {},
++                    Ok(_) => {
++                        // warn if we happen to find two config files #8323
++                        if let Some(ref found_config_) = found_config {
++                            eprintln!(
++                                "Using config file `{}`\nWarning: `{}` will be ignored.",
++                                found_config_.display(),
++                                config_file.display(),
++                            );
++                        } else {
++                            found_config = Some(config_file);
++                        }
++                    },
+ +                }
+ +            }
+ +        }
+ +
++        if found_config.is_some() {
++            return Ok(found_config);
++        }
++
+ +        // If the current directory has no parent, we're done searching.
+ +        if !current.pop() {
+ +            return Ok(None);
+ +        }
+ +    }
+ +}
+ +
+ +/// Read the `toml` configuration file.
+ +///
+ +/// In case of error, the function tries to continue as much as possible.
+ +pub fn read(path: &Path) -> TryConf {
+ +    let content = match fs::read_to_string(path) {
+ +        Err(e) => return TryConf::from_error(e),
+ +        Ok(content) => content,
+ +    };
+ +    toml::from_str(&content).unwrap_or_else(TryConf::from_error)
+ +}
diff --cc src/tools/clippy/clippy_lints/src/utils/internal_lints.rs

index f170ff69154b6532934489e96d089d670beb32dd,0000000000000000000000000000000000000000..dc0f515bfe5cb1d97e075396e242722eeab43502

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/utils/internal_lints.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints.rs
@@@ -1,1316 -1,0 +1,1316 @@@
-     higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path, method_calls,
-     path_to_res, paths, peel_blocks_with_stmt, SpanlessEq,
+ +use clippy_utils::consts::{constant_simple, Constant};
+ +use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg, span_lint_and_then};
+ +use clippy_utils::macros::root_macro_call_first_node;
+ +use clippy_utils::source::snippet;
+ +use clippy_utils::ty::match_type;
+ +use clippy_utils::{
-             if let Some(ty_did) = path_to_res(cx, &segments[..]).opt_def_id();
++    def_path_res, higher, is_else_clause, is_expn_of, is_expr_path_def_path, is_lint_allowed, match_def_path,
++    method_calls, paths, peel_blocks_with_stmt, SpanlessEq,
+ +};
+ +use if_chain::if_chain;
+ +use rustc_ast as ast;
+ +use rustc_ast::ast::{Crate, ItemKind, LitKind, ModKind, NodeId};
+ +use rustc_ast::visit::FnKind;
+ +use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+ +use rustc_errors::Applicability;
+ +use rustc_hir as hir;
+ +use rustc_hir::def::{DefKind, Res};
+ +use rustc_hir::def_id::DefId;
+ +use rustc_hir::hir_id::CRATE_HIR_ID;
+ +use rustc_hir::intravisit::Visitor;
+ +use rustc_hir::{
+ +    BinOpKind, Block, Expr, ExprKind, HirId, Item, Local, MutTy, Mutability, Node, Path, Stmt, StmtKind, Ty, TyKind,
+ +    UnOp,
+ +};
+ +use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
+ +use rustc_middle::hir::nested_filter;
+ +use rustc_middle::mir::interpret::ConstValue;
+ +use rustc_middle::ty;
+ +use rustc_semver::RustcVersion;
+ +use rustc_session::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
+ +use rustc_span::source_map::Spanned;
+ +use rustc_span::symbol::Symbol;
+ +use rustc_span::{sym, BytePos, Span};
+ +use rustc_typeck::hir_ty_to_ty;
+ +
+ +use std::borrow::{Borrow, Cow};
+ +
+ +#[cfg(feature = "internal")]
+ +pub mod metadata_collector;
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for various things we like to keep tidy in clippy.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// We like to pretend we're an example of tidy code.
+ +    ///
+ +    /// ### Example
+ +    /// Wrong ordering of the util::paths constants.
+ +    pub CLIPPY_LINTS_INTERNAL,
+ +    internal,
+ +    "various things that will negatively affect your clippy experience"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Ensures every lint is associated to a `LintPass`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The compiler only knows lints via a `LintPass`. Without
+ +    /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
+ +    /// know the name of the lint.
+ +    ///
+ +    /// ### Known problems
+ +    /// Only checks for lints associated using the
+ +    /// `declare_lint_pass!`, `impl_lint_pass!`, and `lint_array!` macros.
+ +    ///
+ +    /// ### Example
+ +    /// ```rust,ignore
+ +    /// declare_lint! { pub LINT_1, ... }
+ +    /// declare_lint! { pub LINT_2, ... }
+ +    /// declare_lint! { pub FORGOTTEN_LINT, ... }
+ +    /// // ...
+ +    /// declare_lint_pass!(Pass => [LINT_1, LINT_2]);
+ +    /// // missing FORGOTTEN_LINT
+ +    /// ```
+ +    pub LINT_WITHOUT_LINT_PASS,
+ +    internal,
+ +    "declaring a lint without associating it in a LintPass"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calls to `cx.span_lint*` and suggests to use the `utils::*`
+ +    /// variant of the function.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// The `utils::*` variants also add a link to the Clippy documentation to the
+ +    /// warning/error messages.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// cx.span_lint(LINT_NAME, "message");
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust,ignore
+ +    /// utils::span_lint(cx, LINT_NAME, "message");
+ +    /// ```
+ +    pub COMPILER_LINT_FUNCTIONS,
+ +    internal,
+ +    "usage of the lint functions of the compiler instead of the utils::* variant"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calls to `cx.outer().expn_data()` and suggests to use
+ +    /// the `cx.outer_expn_data()`
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `cx.outer_expn_data()` is faster and more concise.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// expr.span.ctxt().outer().expn_data()
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust,ignore
+ +    /// expr.span.ctxt().outer_expn_data()
+ +    /// ```
+ +    pub OUTER_EXPN_EXPN_DATA,
+ +    internal,
+ +    "using `cx.outer_expn().expn_data()` instead of `cx.outer_expn_data()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Not an actual lint. This lint is only meant for testing our customized internal compiler
+ +    /// error message by calling `panic`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// ICE in large quantities can damage your teeth
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// 🍦🍦🍦🍦🍦
+ +    /// ```
+ +    pub PRODUCE_ICE,
+ +    internal,
+ +    "this message should not appear anywhere as we ICE before and don't emit the lint"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for cases of an auto-generated lint without an updated description,
+ +    /// i.e. `default lint description`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Indicates that the lint is not finished.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust,ignore
+ +    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
+ +    /// ```
+ +    pub DEFAULT_LINT,
+ +    internal,
+ +    "found 'default lint description' in a lint declaration"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Lints `span_lint_and_then` function calls, where the
+ +    /// closure argument has only one statement and that statement is a method
+ +    /// call to `span_suggestion`, `span_help`, `span_note` (using the same
+ +    /// span), `help` or `note`.
+ +    ///
+ +    /// These usages of `span_lint_and_then` should be replaced with one of the
+ +    /// wrapper functions `span_lint_and_sugg`, span_lint_and_help`, or
+ +    /// `span_lint_and_note`.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// Using the wrapper `span_lint_and_*` functions, is more
+ +    /// convenient, readable and less error prone.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+ +    ///     diag.span_suggestion(
+ +    ///         expr.span,
+ +    ///         help_msg,
+ +    ///         sugg.to_string(),
+ +    ///         Applicability::MachineApplicable,
+ +    ///     );
+ +    /// });
+ +    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+ +    ///     diag.span_help(expr.span, help_msg);
+ +    /// });
+ +    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+ +    ///     diag.help(help_msg);
+ +    /// });
+ +    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+ +    ///     diag.span_note(expr.span, note_msg);
+ +    /// });
+ +    /// span_lint_and_then(cx, TEST_LINT, expr.span, lint_msg, |diag| {
+ +    ///     diag.note(note_msg);
+ +    /// });
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust,ignore
+ +    /// span_lint_and_sugg(
+ +    ///     cx,
+ +    ///     TEST_LINT,
+ +    ///     expr.span,
+ +    ///     lint_msg,
+ +    ///     help_msg,
+ +    ///     sugg.to_string(),
+ +    ///     Applicability::MachineApplicable,
+ +    /// );
+ +    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), help_msg);
+ +    /// span_lint_and_help(cx, TEST_LINT, expr.span, lint_msg, None, help_msg);
+ +    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, Some(expr.span), note_msg);
+ +    /// span_lint_and_note(cx, TEST_LINT, expr.span, lint_msg, None, note_msg);
+ +    /// ```
+ +    pub COLLAPSIBLE_SPAN_LINT_CALLS,
+ +    internal,
+ +    "found collapsible `span_lint_and_then` calls"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for calls to `utils::match_type()` on a type diagnostic item
+ +    /// and suggests to use `utils::is_type_diagnostic_item()` instead.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// `utils::is_type_diagnostic_item()` does not require hardcoded paths.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// utils::match_type(cx, ty, &paths::VEC)
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust,ignore
+ +    /// utils::is_type_diagnostic_item(cx, ty, sym::Vec)
+ +    /// ```
+ +    pub MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+ +    internal,
+ +    "using `utils::match_type()` instead of `utils::is_type_diagnostic_item()`"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks the paths module for invalid paths.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It indicates a bug in the code.
+ +    ///
+ +    /// ### Example
+ +    /// None.
+ +    pub INVALID_PATHS,
+ +    internal,
+ +    "invalid path"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for interning symbols that have already been pre-interned and defined as constants.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It's faster and easier to use the symbol constant.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// let _ = sym!(f32);
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust,ignore
+ +    /// let _ = sym::f32;
+ +    /// ```
+ +    pub INTERNING_DEFINED_SYMBOL,
+ +    internal,
+ +    "interning a symbol that is pre-interned and defined as a constant"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for unnecessary conversion from Symbol to a string.
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// It's faster use symbols directly intead of strings.
+ +    ///
+ +    /// ### Example
+ +    /// Bad:
+ +    /// ```rust,ignore
+ +    /// symbol.as_str() == "clippy";
+ +    /// ```
+ +    ///
+ +    /// Good:
+ +    /// ```rust,ignore
+ +    /// symbol == sym::clippy;
+ +    /// ```
+ +    pub UNNECESSARY_SYMBOL_STR,
+ +    internal,
+ +    "unnecessary conversion between Symbol and string"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// Finds unidiomatic usage of `if_chain!`
+ +    pub IF_CHAIN_STYLE,
+ +    internal,
+ +    "non-idiomatic `if_chain!` usage"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for invalid `clippy::version` attributes.
+ +    ///
+ +    /// Valid values are:
+ +    /// * "pre 1.29.0"
+ +    /// * any valid semantic version
+ +    pub INVALID_CLIPPY_VERSION_ATTRIBUTE,
+ +    internal,
+ +    "found an invalid `clippy::version` attribute"
+ +}
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Checks for declared clippy lints without the `clippy::version` attribute.
+ +    ///
+ +    pub MISSING_CLIPPY_VERSION_ATTRIBUTE,
+ +    internal,
+ +    "found clippy lint without `clippy::version` attribute"
+ +}
+ +
+ +declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
+ +
+ +impl EarlyLintPass for ClippyLintsInternal {
+ +    fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
+ +        if let Some(utils) = krate.items.iter().find(|item| item.ident.name.as_str() == "utils") {
+ +            if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = utils.kind {
+ +                if let Some(paths) = items.iter().find(|item| item.ident.name.as_str() == "paths") {
+ +                    if let ItemKind::Mod(_, ModKind::Loaded(ref items, ..)) = paths.kind {
+ +                        let mut last_name: Option<&str> = None;
+ +                        for item in items {
+ +                            let name = item.ident.as_str();
+ +                            if let Some(last_name) = last_name {
+ +                                if *last_name > *name {
+ +                                    span_lint(
+ +                                        cx,
+ +                                        CLIPPY_LINTS_INTERNAL,
+ +                                        item.span,
+ +                                        "this constant should be before the previous constant due to lexical \
+ +                                         ordering",
+ +                                    );
+ +                                }
+ +                            }
+ +                            last_name = Some(name);
+ +                        }
+ +                    }
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +#[derive(Clone, Debug, Default)]
+ +pub struct LintWithoutLintPass {
+ +    declared_lints: FxHashMap<Symbol, Span>,
+ +    registered_lints: FxHashSet<Symbol>,
+ +}
+ +
+ +impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
+ +    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+ +        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id()) {
+ +            return;
+ +        }
+ +
+ +        if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
+ +            if is_lint_ref_type(cx, ty) {
+ +                check_invalid_clippy_version_attribute(cx, item);
+ +
+ +                let expr = &cx.tcx.hir().body(body_id).value;
+ +                if_chain! {
+ +                    if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind;
+ +                    if let ExprKind::Struct(_, fields, _) = inner_exp.kind;
+ +                    let field = fields
+ +                        .iter()
+ +                        .find(|f| f.ident.as_str() == "desc")
+ +                        .expect("lints must have a description field");
+ +                    if let ExprKind::Lit(Spanned {
+ +                        node: LitKind::Str(ref sym, _),
+ +                        ..
+ +                    }) = field.expr.kind;
+ +                    if sym.as_str() == "default lint description";
+ +
+ +                    then {
+ +                        span_lint(
+ +                            cx,
+ +                            DEFAULT_LINT,
+ +                            item.span,
+ +                            &format!("the lint `{}` has the default lint description", item.ident.name),
+ +                        );
+ +                    }
+ +                }
+ +                self.declared_lints.insert(item.ident.name, item.span);
+ +            }
+ +        } else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
+ +            if !matches!(
+ +                &*cx.tcx.item_name(macro_call.def_id).as_str(),
+ +                "impl_lint_pass" | "declare_lint_pass"
+ +            ) {
+ +                return;
+ +            }
+ +            if let hir::ItemKind::Impl(hir::Impl {
+ +                of_trait: None,
+ +                items: impl_item_refs,
+ +                ..
+ +            }) = item.kind
+ +            {
+ +                let mut collector = LintCollector {
+ +                    output: &mut self.registered_lints,
+ +                    cx,
+ +                };
+ +                let body_id = cx.tcx.hir().body_owned_by(
+ +                    impl_item_refs
+ +                        .iter()
+ +                        .find(|iiref| iiref.ident.as_str() == "get_lints")
+ +                        .expect("LintPass needs to implement get_lints")
+ +                        .id
+ +                        .hir_id(),
+ +                );
+ +                collector.visit_expr(&cx.tcx.hir().body(body_id).value);
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+ +        if is_lint_allowed(cx, LINT_WITHOUT_LINT_PASS, CRATE_HIR_ID) {
+ +            return;
+ +        }
+ +
+ +        for (lint_name, &lint_span) in &self.declared_lints {
+ +            // When using the `declare_tool_lint!` macro, the original `lint_span`'s
+ +            // file points to "<rustc macros>".
+ +            // `compiletest-rs` thinks that's an error in a different file and
+ +            // just ignores it. This causes the test in compile-fail/lint_pass
+ +            // not able to capture the error.
+ +            // Therefore, we need to climb the macro expansion tree and find the
+ +            // actual span that invoked `declare_tool_lint!`:
+ +            let lint_span = lint_span.ctxt().outer_expn_data().call_site;
+ +
+ +            if !self.registered_lints.contains(lint_name) {
+ +                span_lint(
+ +                    cx,
+ +                    LINT_WITHOUT_LINT_PASS,
+ +                    lint_span,
+ +                    &format!("the lint `{}` is not added to any `LintPass`", lint_name),
+ +                );
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +fn is_lint_ref_type<'tcx>(cx: &LateContext<'tcx>, ty: &Ty<'_>) -> bool {
+ +    if let TyKind::Rptr(
+ +        _,
+ +        MutTy {
+ +            ty: inner,
+ +            mutbl: Mutability::Not,
+ +        },
+ +    ) = ty.kind
+ +    {
+ +        if let TyKind::Path(ref path) = inner.kind {
+ +            if let Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, inner.hir_id) {
+ +                return match_def_path(cx, def_id, &paths::LINT);
+ +            }
+ +        }
+ +    }
+ +
+ +    false
+ +}
+ +
+ +fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'_>) {
+ +    if let Some(value) = extract_clippy_version_value(cx, item) {
+ +        // The `sym!` macro doesn't work as it only expects a single token.
+ +        // It's better to keep it this way and have a direct `Symbol::intern` call here.
+ +        if value == Symbol::intern("pre 1.29.0") {
+ +            return;
+ +        }
+ +
+ +        if RustcVersion::parse(&*value.as_str()).is_err() {
+ +            span_lint_and_help(
+ +                cx,
+ +                INVALID_CLIPPY_VERSION_ATTRIBUTE,
+ +                item.span,
+ +                "this item has an invalid `clippy::version` attribute",
+ +                None,
+ +                "please use a valid sematic version, see `doc/adding_lints.md`",
+ +            );
+ +        }
+ +    } else {
+ +        span_lint_and_help(
+ +            cx,
+ +            MISSING_CLIPPY_VERSION_ATTRIBUTE,
+ +            item.span,
+ +            "this lint is missing the `clippy::version` attribute or version value",
+ +            None,
+ +            "please use a `clippy::version` attribute, see `doc/adding_lints.md`",
+ +        );
+ +    }
+ +}
+ +
+ +/// This function extracts the version value of a `clippy::version` attribute if the given value has
+ +/// one
+ +fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Option<Symbol> {
+ +    let attrs = cx.tcx.hir().attrs(item.hir_id());
+ +    attrs.iter().find_map(|attr| {
+ +        if_chain! {
+ +            // Identify attribute
+ +            if let ast::AttrKind::Normal(ref attr_kind, _) = &attr.kind;
+ +            if let [tool_name, attr_name] = &attr_kind.path.segments[..];
+ +            if tool_name.ident.name == sym::clippy;
+ +            if attr_name.ident.name == sym::version;
+ +            if let Some(version) = attr.value_str();
+ +            then {
+ +                Some(version)
+ +            } else {
+ +                None
+ +            }
+ +        }
+ +    })
+ +}
+ +
+ +struct LintCollector<'a, 'tcx> {
+ +    output: &'a mut FxHashSet<Symbol>,
+ +    cx: &'a LateContext<'tcx>,
+ +}
+ +
+ +impl<'a, 'tcx> Visitor<'tcx> for LintCollector<'a, 'tcx> {
+ +    type NestedFilter = nested_filter::All;
+ +
+ +    fn visit_path(&mut self, path: &'tcx Path<'_>, _: HirId) {
+ +        if path.segments.len() == 1 {
+ +            self.output.insert(path.segments[0].ident.name);
+ +        }
+ +    }
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +}
+ +
+ +#[derive(Clone, Default)]
+ +pub struct CompilerLintFunctions {
+ +    map: FxHashMap<&'static str, &'static str>,
+ +}
+ +
+ +impl CompilerLintFunctions {
+ +    #[must_use]
+ +    pub fn new() -> Self {
+ +        let mut map = FxHashMap::default();
+ +        map.insert("span_lint", "utils::span_lint");
+ +        map.insert("struct_span_lint", "utils::span_lint");
+ +        map.insert("lint", "utils::span_lint");
+ +        map.insert("span_lint_note", "utils::span_lint_and_note");
+ +        map.insert("span_lint_help", "utils::span_lint_and_help");
+ +        Self { map }
+ +    }
+ +}
+ +
+ +impl_lint_pass!(CompilerLintFunctions => [COMPILER_LINT_FUNCTIONS]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for CompilerLintFunctions {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        if is_lint_allowed(cx, COMPILER_LINT_FUNCTIONS, expr.hir_id) {
+ +            return;
+ +        }
+ +
+ +        if_chain! {
+ +            if let ExprKind::MethodCall(path, [self_arg, ..], _) = &expr.kind;
+ +            let fn_name = path.ident;
+ +            if let Some(sugg) = self.map.get(&*fn_name.as_str());
+ +            let ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+ +            if match_type(cx, ty, &paths::EARLY_CONTEXT)
+ +                || match_type(cx, ty, &paths::LATE_CONTEXT);
+ +            then {
+ +                span_lint_and_help(
+ +                    cx,
+ +                    COMPILER_LINT_FUNCTIONS,
+ +                    path.ident.span,
+ +                    "usage of a compiler lint function",
+ +                    None,
+ +                    &format!("please use the Clippy variant of this function: `{}`", sugg),
+ +                );
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+ +        if is_lint_allowed(cx, OUTER_EXPN_EXPN_DATA, expr.hir_id) {
+ +            return;
+ +        }
+ +
+ +        let (method_names, arg_lists, spans) = method_calls(expr, 2);
+ +        let method_names: Vec<&str> = method_names.iter().map(Symbol::as_str).collect();
+ +        if_chain! {
+ +            if let ["expn_data", "outer_expn"] = method_names.as_slice();
+ +            let args = arg_lists[1];
+ +            if args.len() == 1;
+ +            let self_arg = &args[0];
+ +            let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs();
+ +            if match_type(cx, self_ty, &paths::SYNTAX_CONTEXT);
+ +            then {
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    OUTER_EXPN_EXPN_DATA,
+ +                    spans[1].with_hi(expr.span.hi()),
+ +                    "usage of `outer_expn().expn_data()`",
+ +                    "try",
+ +                    "outer_expn_data()".to_string(),
+ +                    Applicability::MachineApplicable,
+ +                );
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +declare_lint_pass!(ProduceIce => [PRODUCE_ICE]);
+ +
+ +impl EarlyLintPass for ProduceIce {
+ +    fn check_fn(&mut self, _: &EarlyContext<'_>, fn_kind: FnKind<'_>, _: Span, _: NodeId) {
+ +        assert!(!is_trigger_fn(fn_kind), "Would you like some help with that?");
+ +    }
+ +}
+ +
+ +fn is_trigger_fn(fn_kind: FnKind<'_>) -> bool {
+ +    match fn_kind {
+ +        FnKind::Fn(_, ident, ..) => ident.name.as_str() == "it_looks_like_you_are_trying_to_kill_clippy",
+ +        FnKind::Closure(..) => false,
+ +    }
+ +}
+ +
+ +declare_lint_pass!(CollapsibleCalls => [COLLAPSIBLE_SPAN_LINT_CALLS]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for CollapsibleCalls {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+ +        if is_lint_allowed(cx, COLLAPSIBLE_SPAN_LINT_CALLS, expr.hir_id) {
+ +            return;
+ +        }
+ +
+ +        if_chain! {
+ +            if let ExprKind::Call(func, and_then_args) = expr.kind;
+ +            if is_expr_path_def_path(cx, func, &["clippy_utils", "diagnostics", "span_lint_and_then"]);
+ +            if and_then_args.len() == 5;
+ +            if let ExprKind::Closure(_, _, body_id, _, _) = &and_then_args[4].kind;
+ +            let body = cx.tcx.hir().body(*body_id);
+ +            let only_expr = peel_blocks_with_stmt(&body.value);
+ +            if let ExprKind::MethodCall(ps, span_call_args, _) = &only_expr.kind;
+ +            then {
+ +                let and_then_snippets = get_and_then_snippets(cx, and_then_args);
+ +                let mut sle = SpanlessEq::new(cx).deny_side_effects();
+ +                match &*ps.ident.as_str() {
+ +                    "span_suggestion" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+ +                        suggest_suggestion(cx, expr, &and_then_snippets, &span_suggestion_snippets(cx, span_call_args));
+ +                    },
+ +                    "span_help" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+ +                        let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+ +                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), true);
+ +                    },
+ +                    "span_note" if sle.eq_expr(&and_then_args[2], &span_call_args[1]) => {
+ +                        let note_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+ +                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), true);
+ +                    },
+ +                    "help" => {
+ +                        let help_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+ +                        suggest_help(cx, expr, &and_then_snippets, help_snippet.borrow(), false);
+ +                    }
+ +                    "note" => {
+ +                        let note_snippet = snippet(cx, span_call_args[1].span, r#""...""#);
+ +                        suggest_note(cx, expr, &and_then_snippets, note_snippet.borrow(), false);
+ +                    }
+ +                    _  => (),
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +struct AndThenSnippets<'a> {
+ +    cx: Cow<'a, str>,
+ +    lint: Cow<'a, str>,
+ +    span: Cow<'a, str>,
+ +    msg: Cow<'a, str>,
+ +}
+ +
+ +fn get_and_then_snippets<'a, 'hir>(cx: &LateContext<'_>, and_then_snippets: &'hir [Expr<'hir>]) -> AndThenSnippets<'a> {
+ +    let cx_snippet = snippet(cx, and_then_snippets[0].span, "cx");
+ +    let lint_snippet = snippet(cx, and_then_snippets[1].span, "..");
+ +    let span_snippet = snippet(cx, and_then_snippets[2].span, "span");
+ +    let msg_snippet = snippet(cx, and_then_snippets[3].span, r#""...""#);
+ +
+ +    AndThenSnippets {
+ +        cx: cx_snippet,
+ +        lint: lint_snippet,
+ +        span: span_snippet,
+ +        msg: msg_snippet,
+ +    }
+ +}
+ +
+ +struct SpanSuggestionSnippets<'a> {
+ +    help: Cow<'a, str>,
+ +    sugg: Cow<'a, str>,
+ +    applicability: Cow<'a, str>,
+ +}
+ +
+ +fn span_suggestion_snippets<'a, 'hir>(
+ +    cx: &LateContext<'_>,
+ +    span_call_args: &'hir [Expr<'hir>],
+ +) -> SpanSuggestionSnippets<'a> {
+ +    let help_snippet = snippet(cx, span_call_args[2].span, r#""...""#);
+ +    let sugg_snippet = snippet(cx, span_call_args[3].span, "..");
+ +    let applicability_snippet = snippet(cx, span_call_args[4].span, "Applicability::MachineApplicable");
+ +
+ +    SpanSuggestionSnippets {
+ +        help: help_snippet,
+ +        sugg: sugg_snippet,
+ +        applicability: applicability_snippet,
+ +    }
+ +}
+ +
+ +fn suggest_suggestion(
+ +    cx: &LateContext<'_>,
+ +    expr: &Expr<'_>,
+ +    and_then_snippets: &AndThenSnippets<'_>,
+ +    span_suggestion_snippets: &SpanSuggestionSnippets<'_>,
+ +) {
+ +    span_lint_and_sugg(
+ +        cx,
+ +        COLLAPSIBLE_SPAN_LINT_CALLS,
+ +        expr.span,
+ +        "this call is collapsible",
+ +        "collapse into",
+ +        format!(
+ +            "span_lint_and_sugg({}, {}, {}, {}, {}, {}, {})",
+ +            and_then_snippets.cx,
+ +            and_then_snippets.lint,
+ +            and_then_snippets.span,
+ +            and_then_snippets.msg,
+ +            span_suggestion_snippets.help,
+ +            span_suggestion_snippets.sugg,
+ +            span_suggestion_snippets.applicability
+ +        ),
+ +        Applicability::MachineApplicable,
+ +    );
+ +}
+ +
+ +fn suggest_help(
+ +    cx: &LateContext<'_>,
+ +    expr: &Expr<'_>,
+ +    and_then_snippets: &AndThenSnippets<'_>,
+ +    help: &str,
+ +    with_span: bool,
+ +) {
+ +    let option_span = if with_span {
+ +        format!("Some({})", and_then_snippets.span)
+ +    } else {
+ +        "None".to_string()
+ +    };
+ +
+ +    span_lint_and_sugg(
+ +        cx,
+ +        COLLAPSIBLE_SPAN_LINT_CALLS,
+ +        expr.span,
+ +        "this call is collapsible",
+ +        "collapse into",
+ +        format!(
+ +            "span_lint_and_help({}, {}, {}, {}, {}, {})",
+ +            and_then_snippets.cx,
+ +            and_then_snippets.lint,
+ +            and_then_snippets.span,
+ +            and_then_snippets.msg,
+ +            &option_span,
+ +            help
+ +        ),
+ +        Applicability::MachineApplicable,
+ +    );
+ +}
+ +
+ +fn suggest_note(
+ +    cx: &LateContext<'_>,
+ +    expr: &Expr<'_>,
+ +    and_then_snippets: &AndThenSnippets<'_>,
+ +    note: &str,
+ +    with_span: bool,
+ +) {
+ +    let note_span = if with_span {
+ +        format!("Some({})", and_then_snippets.span)
+ +    } else {
+ +        "None".to_string()
+ +    };
+ +
+ +    span_lint_and_sugg(
+ +        cx,
+ +        COLLAPSIBLE_SPAN_LINT_CALLS,
+ +        expr.span,
+ +        "this call is collspible",
+ +        "collapse into",
+ +        format!(
+ +            "span_lint_and_note({}, {}, {}, {}, {}, {})",
+ +            and_then_snippets.cx,
+ +            and_then_snippets.lint,
+ +            and_then_snippets.span,
+ +            and_then_snippets.msg,
+ +            note_span,
+ +            note
+ +        ),
+ +        Applicability::MachineApplicable,
+ +    );
+ +}
+ +
+ +declare_lint_pass!(MatchTypeOnDiagItem => [MATCH_TYPE_ON_DIAGNOSTIC_ITEM]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for MatchTypeOnDiagItem {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+ +        if is_lint_allowed(cx, MATCH_TYPE_ON_DIAGNOSTIC_ITEM, expr.hir_id) {
+ +            return;
+ +        }
+ +
+ +        if_chain! {
+ +            // Check if this is a call to utils::match_type()
+ +            if let ExprKind::Call(fn_path, [context, ty, ty_path]) = expr.kind;
+ +            if is_expr_path_def_path(cx, fn_path, &["clippy_utils", "ty", "match_type"]);
+ +            // Extract the path to the matched type
+ +            if let Some(segments) = path_to_matched_type(cx, ty_path);
+ +            let segments: Vec<&str> = segments.iter().map(Symbol::as_str).collect();
-     if path_to_res(cx, path) != Res::Err {
++            if let Some(ty_did) = def_path_res(cx, &segments[..]).opt_def_id();
+ +            // Check if the matched type is a diagnostic item
+ +            if let Some(item_name) = cx.tcx.get_diagnostic_name(ty_did);
+ +            then {
+ +                // TODO: check paths constants from external crates.
+ +                let cx_snippet = snippet(cx, context.span, "_");
+ +                let ty_snippet = snippet(cx, ty.span, "_");
+ +
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    MATCH_TYPE_ON_DIAGNOSTIC_ITEM,
+ +                    expr.span,
+ +                    "usage of `clippy_utils::ty::match_type()` on a type diagnostic item",
+ +                    "try",
+ +                    format!("clippy_utils::ty::is_type_diagnostic_item({}, {}, sym::{})", cx_snippet, ty_snippet, item_name),
+ +                    Applicability::MaybeIncorrect,
+ +                );
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +fn path_to_matched_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Vec<Symbol>> {
+ +    use rustc_hir::ItemKind;
+ +
+ +    match &expr.kind {
+ +        ExprKind::AddrOf(.., expr) => return path_to_matched_type(cx, expr),
+ +        ExprKind::Path(qpath) => match cx.qpath_res(qpath, expr.hir_id) {
+ +            Res::Local(hir_id) => {
+ +                let parent_id = cx.tcx.hir().get_parent_node(hir_id);
+ +                if let Some(Node::Local(local)) = cx.tcx.hir().find(parent_id) {
+ +                    if let Some(init) = local.init {
+ +                        return path_to_matched_type(cx, init);
+ +                    }
+ +                }
+ +            },
+ +            Res::Def(DefKind::Const | DefKind::Static, def_id) => {
+ +                if let Some(Node::Item(item)) = cx.tcx.hir().get_if_local(def_id) {
+ +                    if let ItemKind::Const(.., body_id) | ItemKind::Static(.., body_id) = item.kind {
+ +                        let body = cx.tcx.hir().body(body_id);
+ +                        return path_to_matched_type(cx, &body.value);
+ +                    }
+ +                }
+ +            },
+ +            _ => {},
+ +        },
+ +        ExprKind::Array(exprs) => {
+ +            let segments: Vec<Symbol> = exprs
+ +                .iter()
+ +                .filter_map(|expr| {
+ +                    if let ExprKind::Lit(lit) = &expr.kind {
+ +                        if let LitKind::Str(sym, _) = lit.node {
+ +                            return Some(sym);
+ +                        }
+ +                    }
+ +
+ +                    None
+ +                })
+ +                .collect();
+ +
+ +            if segments.len() == exprs.len() {
+ +                return Some(segments);
+ +            }
+ +        },
+ +        _ => {},
+ +    }
+ +
+ +    None
+ +}
+ +
+ +// This is not a complete resolver for paths. It works on all the paths currently used in the paths
+ +// module.  That's all it does and all it needs to do.
+ +pub fn check_path(cx: &LateContext<'_>, path: &[&str]) -> bool {
-             if let Some(def_id) = path_to_res(cx, module).opt_def_id() {
++    if def_path_res(cx, path) != Res::Err {
+ +        return true;
+ +    }
+ +
+ +    // Some implementations can't be found by `path_to_res`, particularly inherent
+ +    // implementations of native types. Check lang items.
+ +    let path_syms: Vec<_> = path.iter().map(|p| Symbol::intern(p)).collect();
+ +    let lang_items = cx.tcx.lang_items();
+ +    for item_def_id in lang_items.items().iter().flatten() {
+ +        let lang_item_path = cx.get_def_path(*item_def_id);
+ +        if path_syms.starts_with(&lang_item_path) {
+ +            if let [item] = &path_syms[lang_item_path.len()..] {
+ +                if matches!(
+ +                    cx.tcx.def_kind(*item_def_id),
+ +                    DefKind::Mod | DefKind::Enum | DefKind::Trait
+ +                ) {
+ +                    for child in cx.tcx.module_children(*item_def_id) {
+ +                        if child.ident.name == *item {
+ +                            return true;
+ +                        }
+ +                    }
+ +                } else {
+ +                    for child in cx.tcx.associated_item_def_ids(*item_def_id) {
+ +                        if cx.tcx.item_name(*child) == *item {
+ +                            return true;
+ +                        }
+ +                    }
+ +                }
+ +            }
+ +        }
+ +    }
+ +
+ +    false
+ +}
+ +
+ +declare_lint_pass!(InvalidPaths => [INVALID_PATHS]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
+ +    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
+ +        let local_def_id = &cx.tcx.parent_module(item.hir_id());
+ +        let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
+ +        if_chain! {
+ +            if mod_name.as_str() == "paths";
+ +            if let hir::ItemKind::Const(ty, body_id) = item.kind;
+ +            let ty = hir_ty_to_ty(cx.tcx, ty);
+ +            if let ty::Array(el_ty, _) = &ty.kind();
+ +            if let ty::Ref(_, el_ty, _) = &el_ty.kind();
+ +            if el_ty.is_str();
+ +            let body = cx.tcx.hir().body(body_id);
+ +            let typeck_results = cx.tcx.typeck_body(body_id);
+ +            if let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, &body.value);
+ +            let path: Vec<&str> = path.iter().map(|x| {
+ +                    if let Constant::Str(s) = x {
+ +                        s.as_str()
+ +                    } else {
+ +                        // We checked the type of the constant above
+ +                        unreachable!()
+ +                    }
+ +                }).collect();
+ +            if !check_path(cx, &path[..]);
+ +            then {
+ +                span_lint(cx, INVALID_PATHS, item.span, "invalid path");
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +#[derive(Default)]
+ +pub struct InterningDefinedSymbol {
+ +    // Maps the symbol value to the constant DefId.
+ +    symbol_map: FxHashMap<u32, DefId>,
+ +}
+ +
+ +impl_lint_pass!(InterningDefinedSymbol => [INTERNING_DEFINED_SYMBOL, UNNECESSARY_SYMBOL_STR]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
+ +    fn check_crate(&mut self, cx: &LateContext<'_>) {
+ +        if !self.symbol_map.is_empty() {
+ +            return;
+ +        }
+ +
+ +        for &module in &[&paths::KW_MODULE, &paths::SYM_MODULE] {
++            if let Some(def_id) = def_path_res(cx, module).opt_def_id() {
+ +                for item in cx.tcx.module_children(def_id).iter() {
+ +                    if_chain! {
+ +                        if let Res::Def(DefKind::Const, item_def_id) = item.res;
+ +                        let ty = cx.tcx.type_of(item_def_id);
+ +                        if match_type(cx, ty, &paths::SYMBOL);
+ +                        if let Ok(ConstValue::Scalar(value)) = cx.tcx.const_eval_poly(item_def_id);
+ +                        if let Ok(value) = value.to_u32();
+ +                        then {
+ +                            self.symbol_map.insert(value, item_def_id);
+ +                        }
+ +                    }
+ +                }
+ +            }
+ +        }
+ +    }
+ +
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+ +        if_chain! {
+ +            if let ExprKind::Call(func, [arg]) = &expr.kind;
+ +            if let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind();
+ +            if match_def_path(cx, *def_id, &paths::SYMBOL_INTERN);
+ +            if let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg);
+ +            let value = Symbol::intern(&arg).as_u32();
+ +            if let Some(&def_id) = self.symbol_map.get(&value);
+ +            then {
+ +                span_lint_and_sugg(
+ +                    cx,
+ +                    INTERNING_DEFINED_SYMBOL,
+ +                    is_expn_of(expr.span, "sym").unwrap_or(expr.span),
+ +                    "interning a defined symbol",
+ +                    "try",
+ +                    cx.tcx.def_path_str(def_id),
+ +                    Applicability::MachineApplicable,
+ +                );
+ +            }
+ +        }
+ +        if let ExprKind::Binary(op, left, right) = expr.kind {
+ +            if matches!(op.node, BinOpKind::Eq | BinOpKind::Ne) {
+ +                let data = [
+ +                    (left, self.symbol_str_expr(left, cx)),
+ +                    (right, self.symbol_str_expr(right, cx)),
+ +                ];
+ +                match data {
+ +                    // both operands are a symbol string
+ +                    [(_, Some(left)), (_, Some(right))] => {
+ +                        span_lint_and_sugg(
+ +                            cx,
+ +                            UNNECESSARY_SYMBOL_STR,
+ +                            expr.span,
+ +                            "unnecessary `Symbol` to string conversion",
+ +                            "try",
+ +                            format!(
+ +                                "{} {} {}",
+ +                                left.as_symbol_snippet(cx),
+ +                                op.node.as_str(),
+ +                                right.as_symbol_snippet(cx),
+ +                            ),
+ +                            Applicability::MachineApplicable,
+ +                        );
+ +                    },
+ +                    // one of the operands is a symbol string
+ +                    [(expr, Some(symbol)), _] | [_, (expr, Some(symbol))] => {
+ +                        // creating an owned string for comparison
+ +                        if matches!(symbol, SymbolStrExpr::Expr { is_to_owned: true, .. }) {
+ +                            span_lint_and_sugg(
+ +                                cx,
+ +                                UNNECESSARY_SYMBOL_STR,
+ +                                expr.span,
+ +                                "unnecessary string allocation",
+ +                                "try",
+ +                                format!("{}.as_str()", symbol.as_symbol_snippet(cx)),
+ +                                Applicability::MachineApplicable,
+ +                            );
+ +                        }
+ +                    },
+ +                    // nothing found
+ +                    [(_, None), (_, None)] => {},
+ +                }
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +impl InterningDefinedSymbol {
+ +    fn symbol_str_expr<'tcx>(&self, expr: &'tcx Expr<'tcx>, cx: &LateContext<'tcx>) -> Option<SymbolStrExpr<'tcx>> {
+ +        static IDENT_STR_PATHS: &[&[&str]] = &[&paths::IDENT_AS_STR, &paths::TO_STRING_METHOD];
+ +        static SYMBOL_STR_PATHS: &[&[&str]] = &[
+ +            &paths::SYMBOL_AS_STR,
+ +            &paths::SYMBOL_TO_IDENT_STRING,
+ +            &paths::TO_STRING_METHOD,
+ +        ];
+ +        let call = if_chain! {
+ +            if let ExprKind::AddrOf(_, _, e) = expr.kind;
+ +            if let ExprKind::Unary(UnOp::Deref, e) = e.kind;
+ +            then { e } else { expr }
+ +        };
+ +        if_chain! {
+ +            // is a method call
+ +            if let ExprKind::MethodCall(_, [item], _) = call.kind;
+ +            if let Some(did) = cx.typeck_results().type_dependent_def_id(call.hir_id);
+ +            let ty = cx.typeck_results().expr_ty(item);
+ +            // ...on either an Ident or a Symbol
+ +            if let Some(is_ident) = if match_type(cx, ty, &paths::SYMBOL) {
+ +                Some(false)
+ +            } else if match_type(cx, ty, &paths::IDENT) {
+ +                Some(true)
+ +            } else {
+ +                None
+ +            };
+ +            // ...which converts it to a string
+ +            let paths = if is_ident { IDENT_STR_PATHS } else { SYMBOL_STR_PATHS };
+ +            if let Some(path) = paths.iter().find(|path| match_def_path(cx, did, path));
+ +            then {
+ +                let is_to_owned = path.last().unwrap().ends_with("string");
+ +                return Some(SymbolStrExpr::Expr {
+ +                    item,
+ +                    is_ident,
+ +                    is_to_owned,
+ +                });
+ +            }
+ +        }
+ +        // is a string constant
+ +        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+ +            let value = Symbol::intern(&s).as_u32();
+ +            // ...which matches a symbol constant
+ +            if let Some(&def_id) = self.symbol_map.get(&value) {
+ +                return Some(SymbolStrExpr::Const(def_id));
+ +            }
+ +        }
+ +        None
+ +    }
+ +}
+ +
+ +enum SymbolStrExpr<'tcx> {
+ +    /// a string constant with a corresponding symbol constant
+ +    Const(DefId),
+ +    /// a "symbol to string" expression like `symbol.as_str()`
+ +    Expr {
+ +        /// part that evaluates to `Symbol` or `Ident`
+ +        item: &'tcx Expr<'tcx>,
+ +        is_ident: bool,
+ +        /// whether an owned `String` is created like `to_ident_string()`
+ +        is_to_owned: bool,
+ +    },
+ +}
+ +
+ +impl<'tcx> SymbolStrExpr<'tcx> {
+ +    /// Returns a snippet that evaluates to a `Symbol` and is const if possible
+ +    fn as_symbol_snippet(&self, cx: &LateContext<'_>) -> Cow<'tcx, str> {
+ +        match *self {
+ +            Self::Const(def_id) => cx.tcx.def_path_str(def_id).into(),
+ +            Self::Expr { item, is_ident, .. } => {
+ +                let mut snip = snippet(cx, item.span.source_callsite(), "..");
+ +                if is_ident {
+ +                    // get `Ident.name`
+ +                    snip.to_mut().push_str(".name");
+ +                }
+ +                snip
+ +            },
+ +        }
+ +    }
+ +}
+ +
+ +declare_lint_pass!(IfChainStyle => [IF_CHAIN_STYLE]);
+ +
+ +impl<'tcx> LateLintPass<'tcx> for IfChainStyle {
+ +    fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
+ +        let (local, after, if_chain_span) = if_chain! {
+ +            if let [Stmt { kind: StmtKind::Local(local), .. }, after @ ..] = block.stmts;
+ +            if let Some(if_chain_span) = is_expn_of(block.span, "if_chain");
+ +            then { (local, after, if_chain_span) } else { return }
+ +        };
+ +        if is_first_if_chain_expr(cx, block.hir_id, if_chain_span) {
+ +            span_lint(
+ +                cx,
+ +                IF_CHAIN_STYLE,
+ +                if_chain_local_span(cx, local, if_chain_span),
+ +                "`let` expression should be above the `if_chain!`",
+ +            );
+ +        } else if local.span.ctxt() == block.span.ctxt() && is_if_chain_then(after, block.expr, if_chain_span) {
+ +            span_lint(
+ +                cx,
+ +                IF_CHAIN_STYLE,
+ +                if_chain_local_span(cx, local, if_chain_span),
+ +                "`let` expression should be inside `then { .. }`",
+ +            );
+ +        }
+ +    }
+ +
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+ +        let (cond, then, els) = if let Some(higher::IfOrIfLet { cond, r#else, then }) = higher::IfOrIfLet::hir(expr) {
+ +            (cond, then, r#else.is_some())
+ +        } else {
+ +            return;
+ +        };
+ +        let then_block = match then.kind {
+ +            ExprKind::Block(block, _) => block,
+ +            _ => return,
+ +        };
+ +        let if_chain_span = is_expn_of(expr.span, "if_chain");
+ +        if !els {
+ +            check_nested_if_chains(cx, expr, then_block, if_chain_span);
+ +        }
+ +        let if_chain_span = match if_chain_span {
+ +            None => return,
+ +            Some(span) => span,
+ +        };
+ +        // check for `if a && b;`
+ +        if_chain! {
+ +            if let ExprKind::Binary(op, _, _) = cond.kind;
+ +            if op.node == BinOpKind::And;
+ +            if cx.sess().source_map().is_multiline(cond.span);
+ +            then {
+ +                span_lint(cx, IF_CHAIN_STYLE, cond.span, "`if a && b;` should be `if a; if b;`");
+ +            }
+ +        }
+ +        if is_first_if_chain_expr(cx, expr.hir_id, if_chain_span)
+ +            && is_if_chain_then(then_block.stmts, then_block.expr, if_chain_span)
+ +        {
+ +            span_lint(cx, IF_CHAIN_STYLE, expr.span, "`if_chain!` only has one `if`");
+ +        }
+ +    }
+ +}
+ +
+ +fn check_nested_if_chains(
+ +    cx: &LateContext<'_>,
+ +    if_expr: &Expr<'_>,
+ +    then_block: &Block<'_>,
+ +    if_chain_span: Option<Span>,
+ +) {
+ +    #[rustfmt::skip]
+ +    let (head, tail) = match *then_block {
+ +        Block { stmts, expr: Some(tail), .. } => (stmts, tail),
+ +        Block {
+ +            stmts: &[
+ +                ref head @ ..,
+ +                Stmt { kind: StmtKind::Expr(tail) | StmtKind::Semi(tail), .. }
+ +            ],
+ +            ..
+ +        } => (head, tail),
+ +        _ => return,
+ +    };
+ +    if_chain! {
+ +        if let Some(higher::IfOrIfLet { r#else: None, .. }) = higher::IfOrIfLet::hir(tail);
+ +        let sm = cx.sess().source_map();
+ +        if head
+ +            .iter()
+ +            .all(|stmt| matches!(stmt.kind, StmtKind::Local(..)) && !sm.is_multiline(stmt.span));
+ +        if if_chain_span.is_some() || !is_else_clause(cx.tcx, if_expr);
+ +        then {} else { return }
+ +    }
+ +    let (span, msg) = match (if_chain_span, is_expn_of(tail.span, "if_chain")) {
+ +        (None, Some(_)) => (if_expr.span, "this `if` can be part of the inner `if_chain!`"),
+ +        (Some(_), None) => (tail.span, "this `if` can be part of the outer `if_chain!`"),
+ +        (Some(a), Some(b)) if a != b => (b, "this `if_chain!` can be merged with the outer `if_chain!`"),
+ +        _ => return,
+ +    };
+ +    span_lint_and_then(cx, IF_CHAIN_STYLE, span, msg, |diag| {
+ +        let (span, msg) = match head {
+ +            [] => return,
+ +            [stmt] => (stmt.span, "this `let` statement can also be in the `if_chain!`"),
+ +            [a, .., b] => (
+ +                a.span.to(b.span),
+ +                "these `let` statements can also be in the `if_chain!`",
+ +            ),
+ +        };
+ +        diag.span_help(span, msg);
+ +    });
+ +}
+ +
+ +fn is_first_if_chain_expr(cx: &LateContext<'_>, hir_id: HirId, if_chain_span: Span) -> bool {
+ +    cx.tcx
+ +        .hir()
+ +        .parent_iter(hir_id)
+ +        .find(|(_, node)| {
+ +            #[rustfmt::skip]
+ +            !matches!(node, Node::Expr(Expr { kind: ExprKind::Block(..), .. }) | Node::Stmt(_))
+ +        })
+ +        .map_or(false, |(id, _)| {
+ +            is_expn_of(cx.tcx.hir().span(id), "if_chain") != Some(if_chain_span)
+ +        })
+ +}
+ +
+ +/// Checks a trailing slice of statements and expression of a `Block` to see if they are part
+ +/// of the `then {..}` portion of an `if_chain!`
+ +fn is_if_chain_then(stmts: &[Stmt<'_>], expr: Option<&Expr<'_>>, if_chain_span: Span) -> bool {
+ +    let span = if let [stmt, ..] = stmts {
+ +        stmt.span
+ +    } else if let Some(expr) = expr {
+ +        expr.span
+ +    } else {
+ +        // empty `then {}`
+ +        return true;
+ +    };
+ +    is_expn_of(span, "if_chain").map_or(true, |span| span != if_chain_span)
+ +}
+ +
+ +/// Creates a `Span` for `let x = ..;` in an `if_chain!` call.
+ +fn if_chain_local_span(cx: &LateContext<'_>, local: &Local<'_>, if_chain_span: Span) -> Span {
+ +    let mut span = local.pat.span;
+ +    if let Some(init) = local.init {
+ +        span = span.to(init.span);
+ +    }
+ +    span.adjust(if_chain_span.ctxt().outer_expn());
+ +    let sm = cx.sess().source_map();
+ +    let span = sm.span_extend_to_prev_str(span, "let", false);
+ +    let span = sm.span_extend_to_next_char(span, ';', false);
+ +    Span::new(
+ +        span.lo() - BytePos(3),
+ +        span.hi() + BytePos(1),
+ +        span.ctxt(),
+ +        span.parent(),
+ +    )
+ +}
diff --cc src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs

index 3547f0b4e0ae05266096e2a214e80fea4e3b85c4,0000000000000000000000000000000000000000..56633490eaa1a7d51d1c4744eaba273226ccaa09

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@@ -1,924 -1,0 +1,924 @@@
-     for (group_name, lints, _) in &cx.lint_store.get_lint_groups() {
-         if IGNORED_LINT_GROUPS.contains(group_name) {
+ +//! This lint is used to collect metadata about clippy lints. This metadata is exported as a json
+ +//! file and then used to generate the [clippy lint list](https://rust-lang.github.io/rust-clippy/master/index.html)
+ +//!
+ +//! This module and therefore the entire lint is guarded by a feature flag called `internal`
+ +//!
+ +//! The module transforms all lint names to ascii lowercase to ensure that we don't have mismatches
+ +//! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
+ +//! a simple mistake)
+ +
+ +use crate::utils::internal_lints::{extract_clippy_version_value, is_lint_ref_type};
+ +
+ +use clippy_utils::diagnostics::span_lint;
+ +use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
+ +use clippy_utils::{last_path_segment, match_def_path, match_function_call, match_path, paths};
+ +use if_chain::if_chain;
+ +use rustc_ast as ast;
+ +use rustc_data_structures::fx::FxHashMap;
+ +use rustc_hir::{
+ +    self as hir, def::DefKind, intravisit, intravisit::Visitor, ExprKind, Item, ItemKind, Mutability, QPath,
+ +};
+ +use rustc_lint::{CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
+ +use rustc_middle::hir::nested_filter;
+ +use rustc_session::{declare_tool_lint, impl_lint_pass};
+ +use rustc_span::symbol::Ident;
+ +use rustc_span::{sym, Loc, Span, Symbol};
+ +use serde::{ser::SerializeStruct, Serialize, Serializer};
+ +use std::collections::BinaryHeap;
+ +use std::fmt;
+ +use std::fs::{self, OpenOptions};
+ +use std::io::prelude::*;
+ +use std::path::Path;
+ +
+ +/// This is the output file of the lint collector.
+ +const OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
+ +/// These lints are excluded from the export.
+ +const BLACK_LISTED_LINTS: [&str; 3] = ["lint_author", "deep_code_inspection", "internal_metadata_collector"];
+ +/// These groups will be ignored by the lint group matcher. This is useful for collections like
+ +/// `clippy::all`
+ +const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
+ +/// Lints within this group will be excluded from the collection. These groups
+ +/// have to be defined without the `clippy::` prefix.
+ +const EXCLUDED_LINT_GROUPS: [&str; 1] = ["internal"];
+ +/// Collected deprecated lint will be assigned to this group in the JSON output
+ +const DEPRECATED_LINT_GROUP_STR: &str = "deprecated";
+ +/// This is the lint level for deprecated lints that will be displayed in the lint list
+ +const DEPRECATED_LINT_LEVEL: &str = "none";
+ +/// This array holds Clippy's lint groups with their corresponding default lint level. The
+ +/// lint level for deprecated lints is set in `DEPRECATED_LINT_LEVEL`.
+ +const DEFAULT_LINT_LEVELS: &[(&str, &str)] = &[
+ +    ("correctness", "deny"),
+ +    ("suspicious", "warn"),
+ +    ("restriction", "allow"),
+ +    ("style", "warn"),
+ +    ("pedantic", "allow"),
+ +    ("complexity", "warn"),
+ +    ("perf", "warn"),
+ +    ("cargo", "allow"),
+ +    ("nursery", "allow"),
+ +];
+ +/// This prefix is in front of the lint groups in the lint store. The prefix will be trimmed
+ +/// to only keep the actual lint group in the output.
+ +const CLIPPY_LINT_GROUP_PREFIX: &str = "clippy::";
+ +
+ +/// This template will be used to format the configuration section in the lint documentation.
+ +/// The `configurations` parameter will be replaced with one or multiple formatted
+ +/// `ClippyConfiguration` instances. See `CONFIGURATION_VALUE_TEMPLATE` for further customizations
+ +macro_rules! CONFIGURATION_SECTION_TEMPLATE {
+ +    () => {
+ +        r#"
+ +### Configuration
+ +This lint has the following configuration variables:
+ +
+ +{configurations}
+ +"#
+ +    };
+ +}
+ +/// This template will be used to format an individual `ClippyConfiguration` instance in the
+ +/// lint documentation.
+ +///
+ +/// The format function will provide strings for the following parameters: `name`, `ty`, `doc` and
+ +/// `default`
+ +macro_rules! CONFIGURATION_VALUE_TEMPLATE {
+ +    () => {
+ +        "* `{name}`: `{ty}`: {doc} (defaults to `{default}`)\n"
+ +    };
+ +}
+ +
+ +const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
+ +    &["clippy_utils", "diagnostics", "span_lint"],
+ +    &["clippy_utils", "diagnostics", "span_lint_and_help"],
+ +    &["clippy_utils", "diagnostics", "span_lint_and_note"],
+ +    &["clippy_utils", "diagnostics", "span_lint_hir"],
+ +    &["clippy_utils", "diagnostics", "span_lint_and_sugg"],
+ +    &["clippy_utils", "diagnostics", "span_lint_and_then"],
+ +    &["clippy_utils", "diagnostics", "span_lint_hir_and_then"],
+ +];
+ +const SUGGESTION_DIAGNOSTIC_BUILDER_METHODS: [(&str, bool); 9] = [
+ +    ("span_suggestion", false),
+ +    ("span_suggestion_short", false),
+ +    ("span_suggestion_verbose", false),
+ +    ("span_suggestion_hidden", false),
+ +    ("tool_only_span_suggestion", false),
+ +    ("multipart_suggestion", true),
+ +    ("multipart_suggestions", true),
+ +    ("tool_only_multipart_suggestion", true),
+ +    ("span_suggestions", true),
+ +];
+ +const SUGGESTION_FUNCTIONS: [&[&str]; 2] = [
+ +    &["clippy_utils", "diagnostics", "multispan_sugg"],
+ +    &["clippy_utils", "diagnostics", "multispan_sugg_with_applicability"],
+ +];
+ +const DEPRECATED_LINT_TYPE: [&str; 3] = ["clippy_lints", "deprecated_lints", "ClippyDeprecatedLint"];
+ +
+ +/// The index of the applicability name of `paths::APPLICABILITY_VALUES`
+ +const APPLICABILITY_NAME_INDEX: usize = 2;
+ +/// This applicability will be set for unresolved applicability values.
+ +const APPLICABILITY_UNRESOLVED_STR: &str = "Unresolved";
+ +/// The version that will be displayed if none has been defined
+ +const VERION_DEFAULT_STR: &str = "Unknown";
+ +
+ +declare_clippy_lint! {
+ +    /// ### What it does
+ +    /// Collects metadata about clippy lints for the website.
+ +    ///
+ +    /// This lint will be used to report problems of syntax parsing. You should hopefully never
+ +    /// see this but never say never I guess ^^
+ +    ///
+ +    /// ### Why is this bad?
+ +    /// This is not a bad thing but definitely a hacky way to do it. See
+ +    /// issue [#4310](https://github.com/rust-lang/rust-clippy/issues/4310) for a discussion
+ +    /// about the implementation.
+ +    ///
+ +    /// ### Known problems
+ +    /// Hopefully none. It would be pretty uncool to have a problem here :)
+ +    ///
+ +    /// ### Example output
+ +    /// ```json,ignore
+ +    /// {
+ +    ///     "id": "internal_metadata_collector",
+ +    ///     "id_span": {
+ +    ///         "path": "clippy_lints/src/utils/internal_lints/metadata_collector.rs",
+ +    ///         "line": 1
+ +    ///     },
+ +    ///     "group": "clippy::internal",
+ +    ///     "docs": " ### What it does\nCollects metadata about clippy lints for the website. [...] "
+ +    /// }
+ +    /// ```
+ +    #[clippy::version = "1.56.0"]
+ +    pub INTERNAL_METADATA_COLLECTOR,
+ +    internal_warn,
+ +    "A busy bee collection metadata about lints"
+ +}
+ +
+ +impl_lint_pass!(MetadataCollector => [INTERNAL_METADATA_COLLECTOR]);
+ +
+ +#[allow(clippy::module_name_repetitions)]
+ +#[derive(Debug, Clone)]
+ +pub struct MetadataCollector {
+ +    /// All collected lints
+ +    ///
+ +    /// We use a Heap here to have the lints added in alphabetic order in the export
+ +    lints: BinaryHeap<LintMetadata>,
+ +    applicability_info: FxHashMap<String, ApplicabilityInfo>,
+ +    config: Vec<ClippyConfiguration>,
+ +}
+ +
+ +impl MetadataCollector {
+ +    pub fn new() -> Self {
+ +        Self {
+ +            lints: BinaryHeap::<LintMetadata>::default(),
+ +            applicability_info: FxHashMap::<String, ApplicabilityInfo>::default(),
+ +            config: collect_configs(),
+ +        }
+ +    }
+ +
+ +    fn get_lint_configs(&self, lint_name: &str) -> Option<String> {
+ +        self.config
+ +            .iter()
+ +            .filter(|config| config.lints.iter().any(|lint| lint == lint_name))
+ +            .map(ToString::to_string)
+ +            .reduce(|acc, x| acc + &x)
+ +            .map(|configurations| format!(CONFIGURATION_SECTION_TEMPLATE!(), configurations = configurations))
+ +    }
+ +}
+ +
+ +impl Drop for MetadataCollector {
+ +    /// You might ask: How hacky is this?
+ +    /// My answer:     YES
+ +    fn drop(&mut self) {
+ +        // The metadata collector gets dropped twice, this makes sure that we only write
+ +        // when the list is full
+ +        if self.lints.is_empty() {
+ +            return;
+ +        }
+ +
+ +        let mut applicability_info = std::mem::take(&mut self.applicability_info);
+ +
+ +        // Mapping the final data
+ +        let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
+ +        lints
+ +            .iter_mut()
+ +            .for_each(|x| x.applicability = Some(applicability_info.remove(&x.id).unwrap_or_default()));
+ +
+ +        // Outputting
+ +        if Path::new(OUTPUT_FILE).exists() {
+ +            fs::remove_file(OUTPUT_FILE).unwrap();
+ +        }
+ +        let mut file = OpenOptions::new().write(true).create(true).open(OUTPUT_FILE).unwrap();
+ +        writeln!(file, "{}", serde_json::to_string_pretty(&lints).unwrap()).unwrap();
+ +    }
+ +}
+ +
+ +#[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
+ +struct LintMetadata {
+ +    id: String,
+ +    id_span: SerializableSpan,
+ +    group: String,
+ +    level: String,
+ +    docs: String,
+ +    version: String,
+ +    /// This field is only used in the output and will only be
+ +    /// mapped shortly before the actual output.
+ +    applicability: Option<ApplicabilityInfo>,
+ +}
+ +
+ +impl LintMetadata {
+ +    fn new(
+ +        id: String,
+ +        id_span: SerializableSpan,
+ +        group: String,
+ +        level: &'static str,
+ +        version: String,
+ +        docs: String,
+ +    ) -> Self {
+ +        Self {
+ +            id,
+ +            id_span,
+ +            group,
+ +            level: level.to_string(),
+ +            version,
+ +            docs,
+ +            applicability: None,
+ +        }
+ +    }
+ +}
+ +
+ +#[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
+ +struct SerializableSpan {
+ +    path: String,
+ +    line: usize,
+ +}
+ +
+ +impl std::fmt::Display for SerializableSpan {
+ +    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ +        write!(f, "{}:{}", self.path.rsplit('/').next().unwrap_or_default(), self.line)
+ +    }
+ +}
+ +
+ +impl SerializableSpan {
+ +    fn from_item(cx: &LateContext<'_>, item: &Item<'_>) -> Self {
+ +        Self::from_span(cx, item.ident.span)
+ +    }
+ +
+ +    fn from_span(cx: &LateContext<'_>, span: Span) -> Self {
+ +        let loc: Loc = cx.sess().source_map().lookup_char_pos(span.lo());
+ +
+ +        Self {
+ +            path: format!("{}", loc.file.name.prefer_remapped()),
+ +            line: loc.line,
+ +        }
+ +    }
+ +}
+ +
+ +#[derive(Debug, Clone, Default, PartialEq, Eq, PartialOrd, Ord)]
+ +struct ApplicabilityInfo {
+ +    /// Indicates if any of the lint emissions uses multiple spans. This is related to
+ +    /// [rustfix#141](https://github.com/rust-lang/rustfix/issues/141) as such suggestions can
+ +    /// currently not be applied automatically.
+ +    is_multi_part_suggestion: bool,
+ +    applicability: Option<usize>,
+ +}
+ +
+ +impl Serialize for ApplicabilityInfo {
+ +    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ +    where
+ +        S: Serializer,
+ +    {
+ +        let mut s = serializer.serialize_struct("ApplicabilityInfo", 2)?;
+ +        s.serialize_field("is_multi_part_suggestion", &self.is_multi_part_suggestion)?;
+ +        if let Some(index) = self.applicability {
+ +            s.serialize_field(
+ +                "applicability",
+ +                &paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX],
+ +            )?;
+ +        } else {
+ +            s.serialize_field("applicability", APPLICABILITY_UNRESOLVED_STR)?;
+ +        }
+ +        s.end()
+ +    }
+ +}
+ +
+ +// ==================================================================
+ +// Configuration
+ +// ==================================================================
+ +#[derive(Debug, Clone, Default)]
+ +pub struct ClippyConfiguration {
+ +    name: String,
+ +    config_type: &'static str,
+ +    default: String,
+ +    lints: Vec<String>,
+ +    doc: String,
+ +    #[allow(dead_code)]
+ +    deprecation_reason: Option<&'static str>,
+ +}
+ +
+ +impl ClippyConfiguration {
+ +    pub fn new(
+ +        name: &'static str,
+ +        config_type: &'static str,
+ +        default: String,
+ +        doc_comment: &'static str,
+ +        deprecation_reason: Option<&'static str>,
+ +    ) -> Self {
+ +        let (lints, doc) = parse_config_field_doc(doc_comment)
+ +            .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
+ +
+ +        Self {
+ +            name: to_kebab(name),
+ +            lints,
+ +            doc,
+ +            config_type,
+ +            default,
+ +            deprecation_reason,
+ +        }
+ +    }
+ +}
+ +
+ +fn collect_configs() -> Vec<ClippyConfiguration> {
+ +    crate::utils::conf::metadata::get_configuration_metadata()
+ +}
+ +
+ +/// This parses the field documentation of the config struct.
+ +///
+ +/// ```rust, ignore
+ +/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
+ +/// ```
+ +///
+ +/// Would yield:
+ +/// ```rust, ignore
+ +/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
+ +/// ```
+ +fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
+ +    const DOC_START: &str = " Lint: ";
+ +    if_chain! {
+ +        if doc_comment.starts_with(DOC_START);
+ +        if let Some(split_pos) = doc_comment.find('.');
+ +        then {
+ +            let mut doc_comment = doc_comment.to_string();
+ +            let mut documentation = doc_comment.split_off(split_pos);
+ +
+ +            // Extract lints
+ +            doc_comment.make_ascii_lowercase();
+ +            let lints: Vec<String> = doc_comment.split_off(DOC_START.len()).split(", ").map(str::to_string).collect();
+ +
+ +            // Format documentation correctly
+ +            // split off leading `.` from lint name list and indent for correct formatting
+ +            documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n    ");
+ +
+ +            Some((lints, documentation))
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +}
+ +
+ +/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
+ +fn to_kebab(config_name: &str) -> String {
+ +    config_name.replace('_', "-")
+ +}
+ +
+ +impl fmt::Display for ClippyConfiguration {
+ +    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> fmt::Result {
+ +        write!(
+ +            f,
+ +            CONFIGURATION_VALUE_TEMPLATE!(),
+ +            name = self.name,
+ +            ty = self.config_type,
+ +            doc = self.doc,
+ +            default = self.default
+ +        )
+ +    }
+ +}
+ +
+ +// ==================================================================
+ +// Lint pass
+ +// ==================================================================
+ +impl<'hir> LateLintPass<'hir> for MetadataCollector {
+ +    /// Collecting lint declarations like:
+ +    /// ```rust, ignore
+ +    /// declare_clippy_lint! {
+ +    ///     /// ### What it does
+ +    ///     /// Something IDK.
+ +    ///     pub SOME_LINT,
+ +    ///     internal,
+ +    ///     "Who am I?"
+ +    /// }
+ +    /// ```
+ +    fn check_item(&mut self, cx: &LateContext<'hir>, item: &'hir Item<'_>) {
+ +        if let ItemKind::Static(ty, Mutability::Not, _) = item.kind {
+ +            // Normal lint
+ +            if_chain! {
+ +                // item validation
+ +                if is_lint_ref_type(cx, ty);
+ +                // blacklist check
+ +                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
+ +                if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
+ +                // metadata extraction
+ +                if let Some((group, level)) = get_lint_group_and_level_or_lint(cx, &lint_name, item);
+ +                if let Some(mut docs) = extract_attr_docs_or_lint(cx, item);
+ +                then {
+ +                    if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
+ +                        docs.push_str(&configuration_section);
+ +                    }
+ +                    let version = get_lint_version(cx, item);
+ +
+ +                    self.lints.push(LintMetadata::new(
+ +                        lint_name,
+ +                        SerializableSpan::from_item(cx, item),
+ +                        group,
+ +                        level,
+ +                        version,
+ +                        docs,
+ +                    ));
+ +                }
+ +            }
+ +
+ +            if_chain! {
+ +                if is_deprecated_lint(cx, ty);
+ +                // blacklist check
+ +                let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase();
+ +                if !BLACK_LISTED_LINTS.contains(&lint_name.as_str());
+ +                // Metadata the little we can get from a deprecated lint
+ +                if let Some(docs) = extract_attr_docs_or_lint(cx, item);
+ +                then {
+ +                    let version = get_lint_version(cx, item);
+ +
+ +                    self.lints.push(LintMetadata::new(
+ +                        lint_name,
+ +                        SerializableSpan::from_item(cx, item),
+ +                        DEPRECATED_LINT_GROUP_STR.to_string(),
+ +                        DEPRECATED_LINT_LEVEL,
+ +                        version,
+ +                        docs,
+ +                    ));
+ +                }
+ +            }
+ +        }
+ +    }
+ +
+ +    /// Collecting constant applicability from the actual lint emissions
+ +    ///
+ +    /// Example:
+ +    /// ```rust, ignore
+ +    /// span_lint_and_sugg(
+ +    ///     cx,
+ +    ///     SOME_LINT,
+ +    ///     item.span,
+ +    ///     "Le lint message",
+ +    ///     "Here comes help:",
+ +    ///     "#![allow(clippy::all)]",
+ +    ///     Applicability::MachineApplicable, // <-- Extracts this constant value
+ +    /// );
+ +    /// ```
+ +    fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) {
+ +        if let Some(args) = match_lint_emission(cx, expr) {
+ +            let mut emission_info = extract_emission_info(cx, args);
+ +            if emission_info.is_empty() {
+ +                // See:
+ +                // - src/misc.rs:734:9
+ +                // - src/methods/mod.rs:3545:13
+ +                // - src/methods/mod.rs:3496:13
+ +                // We are basically unable to resolve the lint name itself.
+ +                return;
+ +            }
+ +
+ +            for (lint_name, applicability, is_multi_part) in emission_info.drain(..) {
+ +                let app_info = self.applicability_info.entry(lint_name).or_default();
+ +                app_info.applicability = applicability;
+ +                app_info.is_multi_part_suggestion = is_multi_part;
+ +            }
+ +        }
+ +    }
+ +}
+ +
+ +// ==================================================================
+ +// Lint definition extraction
+ +// ==================================================================
+ +fn sym_to_string(sym: Symbol) -> String {
+ +    sym.as_str().to_string()
+ +}
+ +
+ +fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
+ +    extract_attr_docs(cx, item).or_else(|| {
+ +        lint_collection_error_item(cx, item, "could not collect the lint documentation");
+ +        None
+ +    })
+ +}
+ +
+ +/// This function collects all documentation that has been added to an item using
+ +/// `#[doc = r""]` attributes. Several attributes are aggravated using line breaks
+ +///
+ +/// ```ignore
+ +/// #[doc = r"Hello world!"]
+ +/// #[doc = r"=^.^="]
+ +/// struct SomeItem {}
+ +/// ```
+ +///
+ +/// Would result in `Hello world!\n=^.^=\n`
+ +///
+ +/// ---
+ +///
+ +/// This function may modify the doc comment to ensure that the string can be displayed using a
+ +/// markdown viewer in Clippy's lint list. The following modifications could be applied:
+ +/// * Removal of leading space after a new line. (Important to display tables)
+ +/// * Ensures that code blocks only contain language information
+ +fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
+ +    let attrs = cx.tcx.hir().attrs(item.hir_id());
+ +    let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
+ +    let mut docs = String::from(&*lines.next()?.as_str());
+ +    let mut in_code_block = false;
+ +    let mut is_code_block_rust = false;
+ +    for line in lines {
+ +        let line = line.as_str();
+ +        let line = &*line;
+ +
+ +        // Rustdoc hides code lines starting with `# ` and this removes them from Clippy's lint list :)
+ +        if is_code_block_rust && line.trim_start().starts_with("# ") {
+ +            continue;
+ +        }
+ +
+ +        // The line should be represented in the lint list, even if it's just an empty line
+ +        docs.push('\n');
+ +        if let Some(info) = line.trim_start().strip_prefix("```") {
+ +            in_code_block = !in_code_block;
+ +            is_code_block_rust = false;
+ +            if in_code_block {
+ +                let lang = info
+ +                    .trim()
+ +                    .split(',')
+ +                    // remove rustdoc directives
+ +                    .find(|&s| !matches!(s, "" | "ignore" | "no_run" | "should_panic"))
+ +                    // if no language is present, fill in "rust"
+ +                    .unwrap_or("rust");
+ +                docs.push_str("```");
+ +                docs.push_str(lang);
+ +
+ +                is_code_block_rust = lang == "rust";
+ +                continue;
+ +            }
+ +        }
+ +        // This removes the leading space that the macro translation introduces
+ +        if let Some(stripped_doc) = line.strip_prefix(' ') {
+ +            docs.push_str(stripped_doc);
+ +        } else if !line.is_empty() {
+ +            docs.push_str(line);
+ +        }
+ +    }
+ +    Some(docs)
+ +}
+ +
+ +fn get_lint_version(cx: &LateContext<'_>, item: &Item<'_>) -> String {
+ +    extract_clippy_version_value(cx, item).map_or_else(
+ +        || VERION_DEFAULT_STR.to_string(),
+ +        |version| version.as_str().to_string(),
+ +    )
+ +}
+ +
+ +fn get_lint_group_and_level_or_lint(
+ +    cx: &LateContext<'_>,
+ +    lint_name: &str,
+ +    item: &Item<'_>,
+ +) -> Option<(String, &'static str)> {
+ +    let result = cx.lint_store.check_lint_name(
+ +        lint_name,
+ +        Some(sym::clippy),
+ +        &[Ident::with_dummy_span(sym::clippy)].into_iter().collect(),
+ +    );
+ +    if let CheckLintNameResult::Tool(Ok(lint_lst)) = result {
+ +        if let Some(group) = get_lint_group(cx, lint_lst[0]) {
+ +            if EXCLUDED_LINT_GROUPS.contains(&group.as_str()) {
+ +                return None;
+ +            }
+ +
+ +            if let Some(level) = get_lint_level_from_group(&group) {
+ +                Some((group, level))
+ +            } else {
+ +                lint_collection_error_item(
+ +                    cx,
+ +                    item,
+ +                    &format!("Unable to determine lint level for found group `{}`", group),
+ +                );
+ +                None
+ +            }
+ +        } else {
+ +            lint_collection_error_item(cx, item, "Unable to determine lint group");
+ +            None
+ +        }
+ +    } else {
+ +        lint_collection_error_item(cx, item, "Unable to find lint in lint_store");
+ +        None
+ +    }
+ +}
+ +
+ +fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
++    for (group_name, lints, _) in cx.lint_store.get_lint_groups() {
++        if IGNORED_LINT_GROUPS.contains(&group_name) {
+ +            continue;
+ +        }
+ +
+ +        if lints.iter().any(|group_lint| *group_lint == lint_id) {
+ +            let group = group_name.strip_prefix(CLIPPY_LINT_GROUP_PREFIX).unwrap_or(group_name);
+ +            return Some((*group).to_string());
+ +        }
+ +    }
+ +
+ +    None
+ +}
+ +
+ +fn get_lint_level_from_group(lint_group: &str) -> Option<&'static str> {
+ +    DEFAULT_LINT_LEVELS
+ +        .iter()
+ +        .find_map(|(group_name, group_level)| (*group_name == lint_group).then(|| *group_level))
+ +}
+ +
+ +fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+ +    if let hir::TyKind::Path(ref path) = ty.kind {
+ +        if let hir::def::Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, ty.hir_id) {
+ +            return match_def_path(cx, def_id, &DEPRECATED_LINT_TYPE);
+ +        }
+ +    }
+ +
+ +    false
+ +}
+ +
+ +// ==================================================================
+ +// Lint emission
+ +// ==================================================================
+ +fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
+ +    span_lint(
+ +        cx,
+ +        INTERNAL_METADATA_COLLECTOR,
+ +        item.ident.span,
+ +        &format!("metadata collection error for `{}`: {}", item.ident.name, message),
+ +    );
+ +}
+ +
+ +// ==================================================================
+ +// Applicability
+ +// ==================================================================
+ +/// This function checks if a given expression is equal to a simple lint emission function call.
+ +/// It will return the function arguments if the emission matched any function.
+ +fn match_lint_emission<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) -> Option<&'hir [hir::Expr<'hir>]> {
+ +    LINT_EMISSION_FUNCTIONS
+ +        .iter()
+ +        .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
+ +}
+ +
+ +fn take_higher_applicability(a: Option<usize>, b: Option<usize>) -> Option<usize> {
+ +    a.map_or(b, |a| a.max(b.unwrap_or_default()).into())
+ +}
+ +
+ +fn extract_emission_info<'hir>(
+ +    cx: &LateContext<'hir>,
+ +    args: &'hir [hir::Expr<'hir>],
+ +) -> Vec<(String, Option<usize>, bool)> {
+ +    let mut lints = Vec::new();
+ +    let mut applicability = None;
+ +    let mut multi_part = false;
+ +
+ +    for arg in args {
+ +        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(arg));
+ +
+ +        if match_type(cx, arg_ty, &paths::LINT) {
+ +            // If we found the lint arg, extract the lint name
+ +            let mut resolved_lints = resolve_lints(cx, arg);
+ +            lints.append(&mut resolved_lints);
+ +        } else if match_type(cx, arg_ty, &paths::APPLICABILITY) {
+ +            applicability = resolve_applicability(cx, arg);
+ +        } else if arg_ty.is_closure() {
+ +            multi_part |= check_is_multi_part(cx, arg);
+ +            applicability = applicability.or_else(|| resolve_applicability(cx, arg));
+ +        }
+ +    }
+ +
+ +    lints
+ +        .drain(..)
+ +        .map(|lint_name| (lint_name, applicability, multi_part))
+ +        .collect()
+ +}
+ +
+ +/// Resolves the possible lints that this expression could reference
+ +fn resolve_lints<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Vec<String> {
+ +    let mut resolver = LintResolver::new(cx);
+ +    resolver.visit_expr(expr);
+ +    resolver.lints
+ +}
+ +
+ +/// This function tries to resolve the linked applicability to the given expression.
+ +fn resolve_applicability<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<usize> {
+ +    let mut resolver = ApplicabilityResolver::new(cx);
+ +    resolver.visit_expr(expr);
+ +    resolver.complete()
+ +}
+ +
+ +fn check_is_multi_part<'hir>(cx: &LateContext<'hir>, closure_expr: &'hir hir::Expr<'hir>) -> bool {
+ +    if let ExprKind::Closure(_, _, body_id, _, _) = closure_expr.kind {
+ +        let mut scanner = IsMultiSpanScanner::new(cx);
+ +        intravisit::walk_body(&mut scanner, cx.tcx.hir().body(body_id));
+ +        return scanner.is_multi_part();
+ +    } else if let Some(local) = get_parent_local(cx, closure_expr) {
+ +        if let Some(local_init) = local.init {
+ +            return check_is_multi_part(cx, local_init);
+ +        }
+ +    }
+ +
+ +    false
+ +}
+ +
+ +struct LintResolver<'a, 'hir> {
+ +    cx: &'a LateContext<'hir>,
+ +    lints: Vec<String>,
+ +}
+ +
+ +impl<'a, 'hir> LintResolver<'a, 'hir> {
+ +    fn new(cx: &'a LateContext<'hir>) -> Self {
+ +        Self {
+ +            cx,
+ +            lints: Vec::<String>::default(),
+ +        }
+ +    }
+ +}
+ +
+ +impl<'a, 'hir> intravisit::Visitor<'hir> for LintResolver<'a, 'hir> {
+ +    type NestedFilter = nested_filter::All;
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +
+ +    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+ +        if_chain! {
+ +            if let ExprKind::Path(qpath) = &expr.kind;
+ +            if let QPath::Resolved(_, path) = qpath;
+ +
+ +            let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
+ +            if match_type(self.cx, expr_ty, &paths::LINT);
+ +            then {
+ +                if let hir::def::Res::Def(DefKind::Static, _) = path.res {
+ +                    let lint_name = last_path_segment(qpath).ident.name;
+ +                    self.lints.push(sym_to_string(lint_name).to_ascii_lowercase());
+ +                } else if let Some(local) = get_parent_local(self.cx, expr) {
+ +                    if let Some(local_init) = local.init {
+ +                        intravisit::walk_expr(self, local_init);
+ +                    }
+ +                }
+ +            }
+ +        }
+ +
+ +        intravisit::walk_expr(self, expr);
+ +    }
+ +}
+ +
+ +/// This visitor finds the highest applicability value in the visited expressions
+ +struct ApplicabilityResolver<'a, 'hir> {
+ +    cx: &'a LateContext<'hir>,
+ +    /// This is the index of hightest `Applicability` for `paths::APPLICABILITY_VALUES`
+ +    applicability_index: Option<usize>,
+ +}
+ +
+ +impl<'a, 'hir> ApplicabilityResolver<'a, 'hir> {
+ +    fn new(cx: &'a LateContext<'hir>) -> Self {
+ +        Self {
+ +            cx,
+ +            applicability_index: None,
+ +        }
+ +    }
+ +
+ +    fn add_new_index(&mut self, new_index: usize) {
+ +        self.applicability_index = take_higher_applicability(self.applicability_index, Some(new_index));
+ +    }
+ +
+ +    fn complete(self) -> Option<usize> {
+ +        self.applicability_index
+ +    }
+ +}
+ +
+ +impl<'a, 'hir> intravisit::Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
+ +    type NestedFilter = nested_filter::All;
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +
+ +    fn visit_path(&mut self, path: &'hir hir::Path<'hir>, _id: hir::HirId) {
+ +        for (index, enum_value) in paths::APPLICABILITY_VALUES.iter().enumerate() {
+ +            if match_path(path, enum_value) {
+ +                self.add_new_index(index);
+ +                return;
+ +            }
+ +        }
+ +    }
+ +
+ +    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+ +        let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
+ +
+ +        if_chain! {
+ +            if match_type(self.cx, expr_ty, &paths::APPLICABILITY);
+ +            if let Some(local) = get_parent_local(self.cx, expr);
+ +            if let Some(local_init) = local.init;
+ +            then {
+ +                intravisit::walk_expr(self, local_init);
+ +            }
+ +        };
+ +
+ +        intravisit::walk_expr(self, expr);
+ +    }
+ +}
+ +
+ +/// This returns the parent local node if the expression is a reference one
+ +fn get_parent_local<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<&'hir hir::Local<'hir>> {
+ +    if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind {
+ +        if let hir::def::Res::Local(local_hir) = path.res {
+ +            return get_parent_local_hir_id(cx, local_hir);
+ +        }
+ +    }
+ +
+ +    None
+ +}
+ +
+ +fn get_parent_local_hir_id<'hir>(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::Local<'hir>> {
+ +    let map = cx.tcx.hir();
+ +
+ +    match map.find(map.get_parent_node(hir_id)) {
+ +        Some(hir::Node::Local(local)) => Some(local),
+ +        Some(hir::Node::Pat(pattern)) => get_parent_local_hir_id(cx, pattern.hir_id),
+ +        _ => None,
+ +    }
+ +}
+ +
+ +/// This visitor finds the highest applicability value in the visited expressions
+ +struct IsMultiSpanScanner<'a, 'hir> {
+ +    cx: &'a LateContext<'hir>,
+ +    suggestion_count: usize,
+ +}
+ +
+ +impl<'a, 'hir> IsMultiSpanScanner<'a, 'hir> {
+ +    fn new(cx: &'a LateContext<'hir>) -> Self {
+ +        Self {
+ +            cx,
+ +            suggestion_count: 0,
+ +        }
+ +    }
+ +
+ +    /// Add a new single expression suggestion to the counter
+ +    fn add_single_span_suggestion(&mut self) {
+ +        self.suggestion_count += 1;
+ +    }
+ +
+ +    /// Signals that a suggestion with possible multiple spans was found
+ +    fn add_multi_part_suggestion(&mut self) {
+ +        self.suggestion_count += 2;
+ +    }
+ +
+ +    /// Checks if the suggestions include multiple spanns
+ +    fn is_multi_part(&self) -> bool {
+ +        self.suggestion_count > 1
+ +    }
+ +}
+ +
+ +impl<'a, 'hir> intravisit::Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
+ +    type NestedFilter = nested_filter::All;
+ +
+ +    fn nested_visit_map(&mut self) -> Self::Map {
+ +        self.cx.tcx.hir()
+ +    }
+ +
+ +    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
+ +        // Early return if the lint is already multi span
+ +        if self.is_multi_part() {
+ +            return;
+ +        }
+ +
+ +        match &expr.kind {
+ +            ExprKind::Call(fn_expr, _args) => {
+ +                let found_function = SUGGESTION_FUNCTIONS
+ +                    .iter()
+ +                    .any(|func_path| match_function_call(self.cx, fn_expr, func_path).is_some());
+ +                if found_function {
+ +                    // These functions are all multi part suggestions
+ +                    self.add_single_span_suggestion();
+ +                }
+ +            },
+ +            ExprKind::MethodCall(path, arg, _arg_span) => {
+ +                let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(&arg[0]));
+ +                if match_type(self.cx, self_ty, &paths::DIAGNOSTIC_BUILDER) {
+ +                    let called_method = path.ident.name.as_str().to_string();
+ +                    for (method_name, is_multi_part) in &SUGGESTION_DIAGNOSTIC_BUILDER_METHODS {
+ +                        if *method_name == called_method {
+ +                            if *is_multi_part {
+ +                                self.add_multi_part_suggestion();
+ +                            } else {
+ +                                self.add_single_span_suggestion();
+ +                            }
+ +                            break;
+ +                        }
+ +                    }
+ +                }
+ +            },
+ +            _ => {},
+ +        }
+ +
+ +        intravisit::walk_expr(self, expr);
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_utils/src/consts.rs

index 34c5af848a6dbe1bfaa92ec1efbfae3e4b4624bf,0000000000000000000000000000000000000000..3f604d5166bf7d7dcf8f41ba0b9b39aeb996ebd8

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_utils/src/consts.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_utils/src/consts.rs
@@@ -1,644 -1,0 +1,643 @@@
-                        let value = match int_impl {
-                            "<impl i8>" => i8::MAX as u128,
-                            "<impl i16>" => i16::MAX as u128,
-                            "<impl i32>" => i32::MAX as u128,
-                            "<impl i64>" => i64::MAX as u128,
-                            "<impl i128>" => i128::MAX as u128,
-                            _ => return None,
-                        };
-                        Some(Constant::Int(value))
-                     }
-                     else {
+ +#![allow(clippy::float_cmp)]
+ +
+ +use crate::{clip, is_direct_expn_of, sext, unsext};
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::{self, LitFloatType, LitKind};
+ +use rustc_data_structures::sync::Lrc;
+ +use rustc_hir::def::{DefKind, Res};
+ +use rustc_hir::{BinOp, BinOpKind, Block, Expr, ExprKind, HirId, QPath, UnOp};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::mir::interpret::Scalar;
+ +use rustc_middle::ty::subst::{Subst, SubstsRef};
+ +use rustc_middle::ty::{self, FloatTy, ScalarInt, Ty, TyCtxt};
+ +use rustc_middle::{bug, span_bug};
+ +use rustc_span::symbol::Symbol;
+ +use std::cmp::Ordering::{self, Equal};
+ +use std::convert::TryInto;
+ +use std::hash::{Hash, Hasher};
+ +use std::iter;
+ +
+ +/// A `LitKind`-like enum to fold constant `Expr`s into.
+ +#[derive(Debug, Clone)]
+ +pub enum Constant {
+ +    /// A `String` (e.g., "abc").
+ +    Str(String),
+ +    /// A binary string (e.g., `b"abc"`).
+ +    Binary(Lrc<[u8]>),
+ +    /// A single `char` (e.g., `'a'`).
+ +    Char(char),
+ +    /// An integer's bit representation.
+ +    Int(u128),
+ +    /// An `f32`.
+ +    F32(f32),
+ +    /// An `f64`.
+ +    F64(f64),
+ +    /// `true` or `false`.
+ +    Bool(bool),
+ +    /// An array of constants.
+ +    Vec(Vec<Constant>),
+ +    /// Also an array, but with only one constant, repeated N times.
+ +    Repeat(Box<Constant>, u64),
+ +    /// A tuple of constants.
+ +    Tuple(Vec<Constant>),
+ +    /// A raw pointer.
+ +    RawPtr(u128),
+ +    /// A reference
+ +    Ref(Box<Constant>),
+ +    /// A literal with syntax error.
+ +    Err(Symbol),
+ +}
+ +
+ +impl PartialEq for Constant {
+ +    fn eq(&self, other: &Self) -> bool {
+ +        match (self, other) {
+ +            (&Self::Str(ref ls), &Self::Str(ref rs)) => ls == rs,
+ +            (&Self::Binary(ref l), &Self::Binary(ref r)) => l == r,
+ +            (&Self::Char(l), &Self::Char(r)) => l == r,
+ +            (&Self::Int(l), &Self::Int(r)) => l == r,
+ +            (&Self::F64(l), &Self::F64(r)) => {
+ +                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
+ +                // `Fw32 == Fw64`, so don’t compare them.
+ +                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+ +                l.to_bits() == r.to_bits()
+ +            },
+ +            (&Self::F32(l), &Self::F32(r)) => {
+ +                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
+ +                // `Fw32 == Fw64`, so don’t compare them.
+ +                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+ +                f64::from(l).to_bits() == f64::from(r).to_bits()
+ +            },
+ +            (&Self::Bool(l), &Self::Bool(r)) => l == r,
+ +            (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => l == r,
+ +            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => ls == rs && lv == rv,
+ +            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => *lb == *rb,
+ +            // TODO: are there inter-type equalities?
+ +            _ => false,
+ +        }
+ +    }
+ +}
+ +
+ +impl Hash for Constant {
+ +    fn hash<H>(&self, state: &mut H)
+ +    where
+ +        H: Hasher,
+ +    {
+ +        std::mem::discriminant(self).hash(state);
+ +        match *self {
+ +            Self::Str(ref s) => {
+ +                s.hash(state);
+ +            },
+ +            Self::Binary(ref b) => {
+ +                b.hash(state);
+ +            },
+ +            Self::Char(c) => {
+ +                c.hash(state);
+ +            },
+ +            Self::Int(i) => {
+ +                i.hash(state);
+ +            },
+ +            Self::F32(f) => {
+ +                f64::from(f).to_bits().hash(state);
+ +            },
+ +            Self::F64(f) => {
+ +                f.to_bits().hash(state);
+ +            },
+ +            Self::Bool(b) => {
+ +                b.hash(state);
+ +            },
+ +            Self::Vec(ref v) | Self::Tuple(ref v) => {
+ +                v.hash(state);
+ +            },
+ +            Self::Repeat(ref c, l) => {
+ +                c.hash(state);
+ +                l.hash(state);
+ +            },
+ +            Self::RawPtr(u) => {
+ +                u.hash(state);
+ +            },
+ +            Self::Ref(ref r) => {
+ +                r.hash(state);
+ +            },
+ +            Self::Err(ref s) => {
+ +                s.hash(state);
+ +            },
+ +        }
+ +    }
+ +}
+ +
+ +impl Constant {
+ +    pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
+ +        match (left, right) {
+ +            (&Self::Str(ref ls), &Self::Str(ref rs)) => Some(ls.cmp(rs)),
+ +            (&Self::Char(ref l), &Self::Char(ref r)) => Some(l.cmp(r)),
+ +            (&Self::Int(l), &Self::Int(r)) => {
+ +                if let ty::Int(int_ty) = *cmp_type.kind() {
+ +                    Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty)))
+ +                } else {
+ +                    Some(l.cmp(&r))
+ +                }
+ +            },
+ +            (&Self::F64(l), &Self::F64(r)) => l.partial_cmp(&r),
+ +            (&Self::F32(l), &Self::F32(r)) => l.partial_cmp(&r),
+ +            (&Self::Bool(ref l), &Self::Bool(ref r)) => Some(l.cmp(r)),
+ +            (&Self::Tuple(ref l), &Self::Tuple(ref r)) | (&Self::Vec(ref l), &Self::Vec(ref r)) => iter::zip(l, r)
+ +                .map(|(li, ri)| Self::partial_cmp(tcx, cmp_type, li, ri))
+ +                .find(|r| r.map_or(true, |o| o != Ordering::Equal))
+ +                .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
+ +            (&Self::Repeat(ref lv, ref ls), &Self::Repeat(ref rv, ref rs)) => {
+ +                match Self::partial_cmp(tcx, cmp_type, lv, rv) {
+ +                    Some(Equal) => Some(ls.cmp(rs)),
+ +                    x => x,
+ +                }
+ +            },
+ +            (&Self::Ref(ref lb), &Self::Ref(ref rb)) => Self::partial_cmp(tcx, cmp_type, lb, rb),
+ +            // TODO: are there any useful inter-type orderings?
+ +            _ => None,
+ +        }
+ +    }
+ +
+ +    /// Returns the integer value or `None` if `self` or `val_type` is not integer type.
+ +    pub fn int_value(&self, cx: &LateContext<'_>, val_type: Ty<'_>) -> Option<FullInt> {
+ +        if let Constant::Int(const_int) = *self {
+ +            match *val_type.kind() {
+ +                ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
+ +                ty::Uint(_) => Some(FullInt::U(const_int)),
+ +                _ => None,
+ +            }
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +
+ +    #[must_use]
+ +    pub fn peel_refs(mut self) -> Self {
+ +        while let Constant::Ref(r) = self {
+ +            self = *r;
+ +        }
+ +        self
+ +    }
+ +}
+ +
+ +/// Parses a `LitKind` to a `Constant`.
+ +pub fn lit_to_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
+ +    match *lit {
+ +        LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
+ +        LitKind::Byte(b) => Constant::Int(u128::from(b)),
+ +        LitKind::ByteStr(ref s) => Constant::Binary(Lrc::clone(s)),
+ +        LitKind::Char(c) => Constant::Char(c),
+ +        LitKind::Int(n, _) => Constant::Int(n),
+ +        LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
+ +            ast::FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
+ +            ast::FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
+ +        },
+ +        LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind() {
+ +            ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
+ +            ty::Float(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
+ +            _ => bug!(),
+ +        },
+ +        LitKind::Bool(b) => Constant::Bool(b),
+ +        LitKind::Err(s) => Constant::Err(s),
+ +    }
+ +}
+ +
+ +pub fn constant<'tcx>(
+ +    lcx: &LateContext<'tcx>,
+ +    typeck_results: &ty::TypeckResults<'tcx>,
+ +    e: &Expr<'_>,
+ +) -> Option<(Constant, bool)> {
+ +    let mut cx = ConstEvalLateContext {
+ +        lcx,
+ +        typeck_results,
+ +        param_env: lcx.param_env,
+ +        needed_resolution: false,
+ +        substs: lcx.tcx.intern_substs(&[]),
+ +    };
+ +    cx.expr(e).map(|cst| (cst, cx.needed_resolution))
+ +}
+ +
+ +pub fn constant_simple<'tcx>(
+ +    lcx: &LateContext<'tcx>,
+ +    typeck_results: &ty::TypeckResults<'tcx>,
+ +    e: &Expr<'_>,
+ +) -> Option<Constant> {
+ +    constant(lcx, typeck_results, e).and_then(|(cst, res)| if res { None } else { Some(cst) })
+ +}
+ +
+ +pub fn constant_full_int<'tcx>(
+ +    lcx: &LateContext<'tcx>,
+ +    typeck_results: &ty::TypeckResults<'tcx>,
+ +    e: &Expr<'_>,
+ +) -> Option<FullInt> {
+ +    constant_simple(lcx, typeck_results, e)?.int_value(lcx, typeck_results.expr_ty(e))
+ +}
+ +
+ +#[derive(Copy, Clone, Debug, Eq)]
+ +pub enum FullInt {
+ +    S(i128),
+ +    U(u128),
+ +}
+ +
+ +impl PartialEq for FullInt {
+ +    #[must_use]
+ +    fn eq(&self, other: &Self) -> bool {
+ +        self.cmp(other) == Ordering::Equal
+ +    }
+ +}
+ +
+ +impl PartialOrd for FullInt {
+ +    #[must_use]
+ +    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ +        Some(self.cmp(other))
+ +    }
+ +}
+ +
+ +impl Ord for FullInt {
+ +    #[must_use]
+ +    fn cmp(&self, other: &Self) -> Ordering {
+ +        use FullInt::{S, U};
+ +
+ +        fn cmp_s_u(s: i128, u: u128) -> Ordering {
+ +            u128::try_from(s).map_or(Ordering::Less, |x| x.cmp(&u))
+ +        }
+ +
+ +        match (*self, *other) {
+ +            (S(s), S(o)) => s.cmp(&o),
+ +            (U(s), U(o)) => s.cmp(&o),
+ +            (S(s), U(o)) => cmp_s_u(s, o),
+ +            (U(s), S(o)) => cmp_s_u(o, s).reverse(),
+ +        }
+ +    }
+ +}
+ +
+ +/// Creates a `ConstEvalLateContext` from the given `LateContext` and `TypeckResults`.
+ +pub fn constant_context<'a, 'tcx>(
+ +    lcx: &'a LateContext<'tcx>,
+ +    typeck_results: &'a ty::TypeckResults<'tcx>,
+ +) -> ConstEvalLateContext<'a, 'tcx> {
+ +    ConstEvalLateContext {
+ +        lcx,
+ +        typeck_results,
+ +        param_env: lcx.param_env,
+ +        needed_resolution: false,
+ +        substs: lcx.tcx.intern_substs(&[]),
+ +    }
+ +}
+ +
+ +pub struct ConstEvalLateContext<'a, 'tcx> {
+ +    lcx: &'a LateContext<'tcx>,
+ +    typeck_results: &'a ty::TypeckResults<'tcx>,
+ +    param_env: ty::ParamEnv<'tcx>,
+ +    needed_resolution: bool,
+ +    substs: SubstsRef<'tcx>,
+ +}
+ +
+ +impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
+ +    /// Simple constant folding: Insert an expression, get a constant or none.
+ +    pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant> {
+ +        match e.kind {
+ +            ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id, self.typeck_results.expr_ty(e)),
+ +            ExprKind::Block(block, _) => self.block(block),
+ +            ExprKind::Lit(ref lit) => {
+ +                if is_direct_expn_of(e.span, "cfg").is_some() {
+ +                    None
+ +                } else {
+ +                    Some(lit_to_constant(&lit.node, self.typeck_results.expr_ty_opt(e)))
+ +                }
+ +            },
+ +            ExprKind::Array(vec) => self.multi(vec).map(Constant::Vec),
+ +            ExprKind::Tup(tup) => self.multi(tup).map(Constant::Tuple),
+ +            ExprKind::Repeat(value, _) => {
+ +                let n = match self.typeck_results.expr_ty(e).kind() {
+ +                    ty::Array(_, n) => n.try_eval_usize(self.lcx.tcx, self.lcx.param_env)?,
+ +                    _ => span_bug!(e.span, "typeck error"),
+ +                };
+ +                self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
+ +            },
+ +            ExprKind::Unary(op, operand) => self.expr(operand).and_then(|o| match op {
+ +                UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
+ +                UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
+ +                UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
+ +            }),
+ +            ExprKind::If(cond, then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
+ +            ExprKind::Binary(op, left, right) => self.binop(op, left, right),
+ +            ExprKind::Call(callee, args) => {
+ +                // We only handle a few const functions for now.
+ +                if_chain! {
+ +                    if args.is_empty();
+ +                    if let ExprKind::Path(qpath) = &callee.kind;
+ +                    let res = self.typeck_results.qpath_res(qpath, callee.hir_id);
+ +                    if let Some(def_id) = res.opt_def_id();
+ +                    let def_path = self.lcx.get_def_path(def_id);
+ +                    let def_path: Vec<&str> = def_path.iter().take(4).map(Symbol::as_str).collect();
+ +                    if let ["core", "num", int_impl, "max_value"] = *def_path;
+ +                    then {
++                        let value = match int_impl {
++                            "<impl i8>" => i8::MAX as u128,
++                            "<impl i16>" => i16::MAX as u128,
++                            "<impl i32>" => i32::MAX as u128,
++                            "<impl i64>" => i64::MAX as u128,
++                            "<impl i128>" => i128::MAX as u128,
++                            _ => return None,
++                        };
++                        Some(Constant::Int(value))
++                    } else {
+ +                        None
+ +                    }
+ +                }
+ +            },
+ +            ExprKind::Index(arr, index) => self.index(arr, index),
+ +            ExprKind::AddrOf(_, _, inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
+ +            // TODO: add other expressions.
+ +            _ => None,
+ +        }
+ +    }
+ +
+ +    #[allow(clippy::cast_possible_wrap)]
+ +    fn constant_not(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
+ +        use self::Constant::{Bool, Int};
+ +        match *o {
+ +            Bool(b) => Some(Bool(!b)),
+ +            Int(value) => {
+ +                let value = !value;
+ +                match *ty.kind() {
+ +                    ty::Int(ity) => Some(Int(unsext(self.lcx.tcx, value as i128, ity))),
+ +                    ty::Uint(ity) => Some(Int(clip(self.lcx.tcx, value, ity))),
+ +                    _ => None,
+ +                }
+ +            },
+ +            _ => None,
+ +        }
+ +    }
+ +
+ +    fn constant_negate(&self, o: &Constant, ty: Ty<'_>) -> Option<Constant> {
+ +        use self::Constant::{Int, F32, F64};
+ +        match *o {
+ +            Int(value) => {
+ +                let ity = match *ty.kind() {
+ +                    ty::Int(ity) => ity,
+ +                    _ => return None,
+ +                };
+ +                // sign extend
+ +                let value = sext(self.lcx.tcx, value, ity);
+ +                let value = value.checked_neg()?;
+ +                // clear unused bits
+ +                Some(Int(unsext(self.lcx.tcx, value, ity)))
+ +            },
+ +            F32(f) => Some(F32(-f)),
+ +            F64(f) => Some(F64(-f)),
+ +            _ => None,
+ +        }
+ +    }
+ +
+ +    /// Create `Some(Vec![..])` of all constants, unless there is any
+ +    /// non-constant part.
+ +    fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant>> {
+ +        vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
+ +    }
+ +
+ +    /// Lookup a possibly constant expression from an `ExprKind::Path`.
+ +    fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<Constant> {
+ +        let res = self.typeck_results.qpath_res(qpath, id);
+ +        match res {
+ +            Res::Def(DefKind::Const | DefKind::AssocConst, def_id) => {
+ +                let substs = self.typeck_results.node_substs(id);
+ +                let substs = if self.substs.is_empty() {
+ +                    substs
+ +                } else {
+ +                    substs.subst(self.lcx.tcx, self.substs)
+ +                };
+ +
+ +                let result = self
+ +                    .lcx
+ +                    .tcx
+ +                    .const_eval_resolve(
+ +                        self.param_env,
+ +                        ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs),
+ +                        None,
+ +                    )
+ +                    .ok()
+ +                    .map(|val| rustc_middle::ty::Const::from_value(self.lcx.tcx, val, ty))?;
+ +                let result = miri_to_const(result);
+ +                if result.is_some() {
+ +                    self.needed_resolution = true;
+ +                }
+ +                result
+ +            },
+ +            // FIXME: cover all usable cases.
+ +            _ => None,
+ +        }
+ +    }
+ +
+ +    fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant> {
+ +        let lhs = self.expr(lhs);
+ +        let index = self.expr(index);
+ +
+ +        match (lhs, index) {
+ +            (Some(Constant::Vec(vec)), Some(Constant::Int(index))) => match vec.get(index as usize) {
+ +                Some(Constant::F32(x)) => Some(Constant::F32(*x)),
+ +                Some(Constant::F64(x)) => Some(Constant::F64(*x)),
+ +                _ => None,
+ +            },
+ +            (Some(Constant::Vec(vec)), _) => {
+ +                if !vec.is_empty() && vec.iter().all(|x| *x == vec[0]) {
+ +                    match vec.get(0) {
+ +                        Some(Constant::F32(x)) => Some(Constant::F32(*x)),
+ +                        Some(Constant::F64(x)) => Some(Constant::F64(*x)),
+ +                        _ => None,
+ +                    }
+ +                } else {
+ +                    None
+ +                }
+ +            },
+ +            _ => None,
+ +        }
+ +    }
+ +
+ +    /// A block can only yield a constant if it only has one constant expression.
+ +    fn block(&mut self, block: &Block<'_>) -> Option<Constant> {
+ +        if block.stmts.is_empty() {
+ +            block.expr.as_ref().and_then(|b| self.expr(b))
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +
+ +    fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant> {
+ +        if let Some(Constant::Bool(b)) = self.expr(cond) {
+ +            if b {
+ +                self.expr(&*then)
+ +            } else {
+ +                otherwise.as_ref().and_then(|expr| self.expr(expr))
+ +            }
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +
+ +    fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant> {
+ +        let l = self.expr(left)?;
+ +        let r = self.expr(right);
+ +        match (l, r) {
+ +            (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck_results.expr_ty_opt(left)?.kind() {
+ +                ty::Int(ity) => {
+ +                    let l = sext(self.lcx.tcx, l, ity);
+ +                    let r = sext(self.lcx.tcx, r, ity);
+ +                    let zext = |n: i128| Constant::Int(unsext(self.lcx.tcx, n, ity));
+ +                    match op.node {
+ +                        BinOpKind::Add => l.checked_add(r).map(zext),
+ +                        BinOpKind::Sub => l.checked_sub(r).map(zext),
+ +                        BinOpKind::Mul => l.checked_mul(r).map(zext),
+ +                        BinOpKind::Div if r != 0 => l.checked_div(r).map(zext),
+ +                        BinOpKind::Rem if r != 0 => l.checked_rem(r).map(zext),
+ +                        BinOpKind::Shr => l.checked_shr(r.try_into().expect("invalid shift")).map(zext),
+ +                        BinOpKind::Shl => l.checked_shl(r.try_into().expect("invalid shift")).map(zext),
+ +                        BinOpKind::BitXor => Some(zext(l ^ r)),
+ +                        BinOpKind::BitOr => Some(zext(l | r)),
+ +                        BinOpKind::BitAnd => Some(zext(l & r)),
+ +                        BinOpKind::Eq => Some(Constant::Bool(l == r)),
+ +                        BinOpKind::Ne => Some(Constant::Bool(l != r)),
+ +                        BinOpKind::Lt => Some(Constant::Bool(l < r)),
+ +                        BinOpKind::Le => Some(Constant::Bool(l <= r)),
+ +                        BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+ +                        BinOpKind::Gt => Some(Constant::Bool(l > r)),
+ +                        _ => None,
+ +                    }
+ +                },
+ +                ty::Uint(_) => match op.node {
+ +                    BinOpKind::Add => l.checked_add(r).map(Constant::Int),
+ +                    BinOpKind::Sub => l.checked_sub(r).map(Constant::Int),
+ +                    BinOpKind::Mul => l.checked_mul(r).map(Constant::Int),
+ +                    BinOpKind::Div => l.checked_div(r).map(Constant::Int),
+ +                    BinOpKind::Rem => l.checked_rem(r).map(Constant::Int),
+ +                    BinOpKind::Shr => l.checked_shr(r.try_into().expect("shift too large")).map(Constant::Int),
+ +                    BinOpKind::Shl => l.checked_shl(r.try_into().expect("shift too large")).map(Constant::Int),
+ +                    BinOpKind::BitXor => Some(Constant::Int(l ^ r)),
+ +                    BinOpKind::BitOr => Some(Constant::Int(l | r)),
+ +                    BinOpKind::BitAnd => Some(Constant::Int(l & r)),
+ +                    BinOpKind::Eq => Some(Constant::Bool(l == r)),
+ +                    BinOpKind::Ne => Some(Constant::Bool(l != r)),
+ +                    BinOpKind::Lt => Some(Constant::Bool(l < r)),
+ +                    BinOpKind::Le => Some(Constant::Bool(l <= r)),
+ +                    BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+ +                    BinOpKind::Gt => Some(Constant::Bool(l > r)),
+ +                    _ => None,
+ +                },
+ +                _ => None,
+ +            },
+ +            (Constant::F32(l), Some(Constant::F32(r))) => match op.node {
+ +                BinOpKind::Add => Some(Constant::F32(l + r)),
+ +                BinOpKind::Sub => Some(Constant::F32(l - r)),
+ +                BinOpKind::Mul => Some(Constant::F32(l * r)),
+ +                BinOpKind::Div => Some(Constant::F32(l / r)),
+ +                BinOpKind::Rem => Some(Constant::F32(l % r)),
+ +                BinOpKind::Eq => Some(Constant::Bool(l == r)),
+ +                BinOpKind::Ne => Some(Constant::Bool(l != r)),
+ +                BinOpKind::Lt => Some(Constant::Bool(l < r)),
+ +                BinOpKind::Le => Some(Constant::Bool(l <= r)),
+ +                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+ +                BinOpKind::Gt => Some(Constant::Bool(l > r)),
+ +                _ => None,
+ +            },
+ +            (Constant::F64(l), Some(Constant::F64(r))) => match op.node {
+ +                BinOpKind::Add => Some(Constant::F64(l + r)),
+ +                BinOpKind::Sub => Some(Constant::F64(l - r)),
+ +                BinOpKind::Mul => Some(Constant::F64(l * r)),
+ +                BinOpKind::Div => Some(Constant::F64(l / r)),
+ +                BinOpKind::Rem => Some(Constant::F64(l % r)),
+ +                BinOpKind::Eq => Some(Constant::Bool(l == r)),
+ +                BinOpKind::Ne => Some(Constant::Bool(l != r)),
+ +                BinOpKind::Lt => Some(Constant::Bool(l < r)),
+ +                BinOpKind::Le => Some(Constant::Bool(l <= r)),
+ +                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
+ +                BinOpKind::Gt => Some(Constant::Bool(l > r)),
+ +                _ => None,
+ +            },
+ +            (l, r) => match (op.node, l, r) {
+ +                (BinOpKind::And, Constant::Bool(false), _) => Some(Constant::Bool(false)),
+ +                (BinOpKind::Or, Constant::Bool(true), _) => Some(Constant::Bool(true)),
+ +                (BinOpKind::And, Constant::Bool(true), Some(r)) | (BinOpKind::Or, Constant::Bool(false), Some(r)) => {
+ +                    Some(r)
+ +                },
+ +                (BinOpKind::BitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)),
+ +                (BinOpKind::BitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)),
+ +                (BinOpKind::BitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)),
+ +                _ => None,
+ +            },
+ +        }
+ +    }
+ +}
+ +
+ +pub fn miri_to_const(result: &ty::Const<'_>) -> Option<Constant> {
+ +    use rustc_middle::mir::interpret::ConstValue;
+ +    match result.val {
+ +        ty::ConstKind::Value(ConstValue::Scalar(Scalar::Int(int))) => {
+ +            match result.ty.kind() {
+ +                ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
+ +                ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.assert_bits(int.size()))),
+ +                ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits(
+ +                    int.try_into().expect("invalid f32 bit representation"),
+ +                ))),
+ +                ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(
+ +                    int.try_into().expect("invalid f64 bit representation"),
+ +                ))),
+ +                ty::RawPtr(type_and_mut) => {
+ +                    if let ty::Uint(_) = type_and_mut.ty.kind() {
+ +                        return Some(Constant::RawPtr(int.assert_bits(int.size())));
+ +                    }
+ +                    None
+ +                },
+ +                // FIXME: implement other conversions.
+ +                _ => None,
+ +            }
+ +        },
+ +        ty::ConstKind::Value(ConstValue::Slice { data, start, end }) => match result.ty.kind() {
+ +            ty::Ref(_, tam, _) => match tam.kind() {
+ +                ty::Str => String::from_utf8(
+ +                    data.inspect_with_uninit_and_ptr_outside_interpreter(start..end)
+ +                        .to_owned(),
+ +                )
+ +                .ok()
+ +                .map(Constant::Str),
+ +                _ => None,
+ +            },
+ +            _ => None,
+ +        },
+ +        ty::ConstKind::Value(ConstValue::ByRef { alloc, offset: _ }) => match result.ty.kind() {
+ +            ty::Array(sub_type, len) => match sub_type.kind() {
+ +                ty::Float(FloatTy::F32) => match miri_to_const(len) {
+ +                    Some(Constant::Int(len)) => alloc
+ +                        .inspect_with_uninit_and_ptr_outside_interpreter(0..(4 * len as usize))
+ +                        .to_owned()
+ +                        .chunks(4)
+ +                        .map(|chunk| {
+ +                            Some(Constant::F32(f32::from_le_bytes(
+ +                                chunk.try_into().expect("this shouldn't happen"),
+ +                            )))
+ +                        })
+ +                        .collect::<Option<Vec<Constant>>>()
+ +                        .map(Constant::Vec),
+ +                    _ => None,
+ +                },
+ +                ty::Float(FloatTy::F64) => match miri_to_const(len) {
+ +                    Some(Constant::Int(len)) => alloc
+ +                        .inspect_with_uninit_and_ptr_outside_interpreter(0..(8 * len as usize))
+ +                        .to_owned()
+ +                        .chunks(8)
+ +                        .map(|chunk| {
+ +                            Some(Constant::F64(f64::from_le_bytes(
+ +                                chunk.try_into().expect("this shouldn't happen"),
+ +                            )))
+ +                        })
+ +                        .collect::<Option<Vec<Constant>>>()
+ +                        .map(Constant::Vec),
+ +                    _ => None,
+ +                },
+ +                // FIXME: implement other array type conversions.
+ +                _ => None,
+ +            },
+ +            _ => None,
+ +        },
+ +        // FIXME: implement other conversions.
+ +        _ => None,
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_utils/src/higher.rs

index 160a51740cd7cde24cf8f31fa13a52fb02925ff8,0000000000000000000000000000000000000000..2095fc966c5dc7535f3be122d08bef255130de57

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_utils/src/higher.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_utils/src/higher.rs
@@@ -1,475 -1,0 +1,472 @@@
-                 }
-                 else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
+ +//! This module contains functions that retrieve specific elements.
+ +
+ +#![deny(clippy::missing_docs_in_private_items)]
+ +
+ +use crate::ty::is_type_diagnostic_item;
+ +use crate::{is_expn_of, match_def_path, paths};
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::{self, LitKind};
+ +use rustc_hir as hir;
+ +use rustc_hir::{Arm, Block, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath};
+ +use rustc_lint::LateContext;
+ +use rustc_span::{sym, symbol, Span};
+ +
+ +/// The essential nodes of a desugared for loop as well as the entire span:
+ +/// `for pat in arg { body }` becomes `(pat, arg, body)`. Return `(pat, arg, body, span)`.
+ +pub struct ForLoop<'tcx> {
+ +    /// `for` loop item
+ +    pub pat: &'tcx hir::Pat<'tcx>,
+ +    /// `IntoIterator` argument
+ +    pub arg: &'tcx hir::Expr<'tcx>,
+ +    /// `for` loop body
+ +    pub body: &'tcx hir::Expr<'tcx>,
+ +    /// Compare this against `hir::Destination.target`
+ +    pub loop_id: HirId,
+ +    /// entire `for` loop span
+ +    pub span: Span,
+ +}
+ +
+ +impl<'tcx> ForLoop<'tcx> {
+ +    /// Parses a desugared `for` loop
+ +    pub fn hir(expr: &Expr<'tcx>) -> Option<Self> {
+ +        if_chain! {
+ +            if let hir::ExprKind::DropTemps(e) = expr.kind;
+ +            if let hir::ExprKind::Match(iterexpr, [arm], hir::MatchSource::ForLoopDesugar) = e.kind;
+ +            if let hir::ExprKind::Call(_, [arg]) = iterexpr.kind;
+ +            if let hir::ExprKind::Loop(block, ..) = arm.body.kind;
+ +            if let [stmt] = &*block.stmts;
+ +            if let hir::StmtKind::Expr(e) = stmt.kind;
+ +            if let hir::ExprKind::Match(_, [_, some_arm], _) = e.kind;
+ +            if let hir::PatKind::Struct(_, [field], _) = some_arm.pat.kind;
+ +            then {
+ +                return Some(Self {
+ +                    pat: field.pat,
+ +                    arg,
+ +                    body: some_arm.body,
+ +                    loop_id: arm.body.hir_id,
+ +                    span: expr.span.ctxt().outer_expn_data().call_site,
+ +                });
+ +            }
+ +        }
+ +        None
+ +    }
+ +}
+ +
+ +/// An `if` expression without `DropTemps`
+ +pub struct If<'hir> {
+ +    /// `if` condition
+ +    pub cond: &'hir Expr<'hir>,
+ +    /// `if` then expression
+ +    pub then: &'hir Expr<'hir>,
+ +    /// `else` expression
+ +    pub r#else: Option<&'hir Expr<'hir>>,
+ +}
+ +
+ +impl<'hir> If<'hir> {
+ +    #[inline]
+ +    /// Parses an `if` expression
+ +    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
+ +        if let ExprKind::If(
+ +            Expr {
+ +                kind: ExprKind::DropTemps(cond),
+ +                ..
+ +            },
+ +            then,
+ +            r#else,
+ +        ) = expr.kind
+ +        {
+ +            Some(Self { cond, then, r#else })
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +}
+ +
+ +/// An `if let` expression
+ +pub struct IfLet<'hir> {
+ +    /// `if let` pattern
+ +    pub let_pat: &'hir Pat<'hir>,
+ +    /// `if let` scrutinee
+ +    pub let_expr: &'hir Expr<'hir>,
+ +    /// `if let` then expression
+ +    pub if_then: &'hir Expr<'hir>,
+ +    /// `if let` else expression
+ +    pub if_else: Option<&'hir Expr<'hir>>,
+ +}
+ +
+ +impl<'hir> IfLet<'hir> {
+ +    /// Parses an `if let` expression
+ +    pub fn hir(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
+ +        if let ExprKind::If(
+ +            Expr {
+ +                kind:
+ +                    ExprKind::Let(hir::Let {
+ +                        pat: let_pat,
+ +                        init: let_expr,
+ +                        ..
+ +                    }),
+ +                ..
+ +            },
+ +            if_then,
+ +            if_else,
+ +        ) = expr.kind
+ +        {
+ +            let mut iter = cx.tcx.hir().parent_iter(expr.hir_id);
+ +            if let Some((_, Node::Block(Block { stmts: [], .. }))) = iter.next() {
+ +                if let Some((
+ +                    _,
+ +                    Node::Expr(Expr {
+ +                        kind: ExprKind::Loop(_, _, LoopSource::While, _),
+ +                        ..
+ +                    }),
+ +                )) = iter.next()
+ +                {
+ +                    // while loop desugar
+ +                    return None;
+ +                }
+ +            }
+ +            return Some(Self {
+ +                let_pat,
+ +                let_expr,
+ +                if_then,
+ +                if_else,
+ +            });
+ +        }
+ +        None
+ +    }
+ +}
+ +
+ +/// An `if let` or `match` expression. Useful for lints that trigger on one or the other.
+ +pub enum IfLetOrMatch<'hir> {
+ +    /// Any `match` expression
+ +    Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource),
+ +    /// scrutinee, pattern, then block, else block
+ +    IfLet(
+ +        &'hir Expr<'hir>,
+ +        &'hir Pat<'hir>,
+ +        &'hir Expr<'hir>,
+ +        Option<&'hir Expr<'hir>>,
+ +    ),
+ +}
+ +
+ +impl<'hir> IfLetOrMatch<'hir> {
+ +    /// Parses an `if let` or `match` expression
+ +    pub fn parse(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
+ +        match expr.kind {
+ +            ExprKind::Match(expr, arms, source) => Some(Self::Match(expr, arms, source)),
+ +            _ => IfLet::hir(cx, expr).map(
+ +                |IfLet {
+ +                     let_expr,
+ +                     let_pat,
+ +                     if_then,
+ +                     if_else,
+ +                 }| { Self::IfLet(let_expr, let_pat, if_then, if_else) },
+ +            ),
+ +        }
+ +    }
+ +}
+ +
+ +/// An `if` or `if let` expression
+ +pub struct IfOrIfLet<'hir> {
+ +    /// `if` condition that is maybe a `let` expression
+ +    pub cond: &'hir Expr<'hir>,
+ +    /// `if` then expression
+ +    pub then: &'hir Expr<'hir>,
+ +    /// `else` expression
+ +    pub r#else: Option<&'hir Expr<'hir>>,
+ +}
+ +
+ +impl<'hir> IfOrIfLet<'hir> {
+ +    #[inline]
+ +    /// Parses an `if` or `if let` expression
+ +    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
+ +        if let ExprKind::If(cond, then, r#else) = expr.kind {
+ +            if let ExprKind::DropTemps(new_cond) = cond.kind {
+ +                return Some(Self {
+ +                    cond: new_cond,
+ +                    r#else,
+ +                    then,
+ +                });
+ +            }
+ +            if let ExprKind::Let(..) = cond.kind {
+ +                return Some(Self { cond, then, r#else });
+ +            }
+ +        }
+ +        None
+ +    }
+ +}
+ +
+ +/// Represent a range akin to `ast::ExprKind::Range`.
+ +#[derive(Debug, Copy, Clone)]
+ +pub struct Range<'a> {
+ +    /// The lower bound of the range, or `None` for ranges such as `..X`.
+ +    pub start: Option<&'a hir::Expr<'a>>,
+ +    /// The upper bound of the range, or `None` for ranges such as `X..`.
+ +    pub end: Option<&'a hir::Expr<'a>>,
+ +    /// Whether the interval is open or closed.
+ +    pub limits: ast::RangeLimits,
+ +}
+ +
+ +impl<'a> Range<'a> {
+ +    /// Higher a `hir` range to something similar to `ast::ExprKind::Range`.
+ +    pub fn hir(expr: &'a hir::Expr<'_>) -> Option<Range<'a>> {
+ +        /// Finds the field named `name` in the field. Always return `Some` for
+ +        /// convenience.
+ +        fn get_field<'c>(name: &str, fields: &'c [hir::ExprField<'_>]) -> Option<&'c hir::Expr<'c>> {
+ +            let expr = &fields.iter().find(|field| field.ident.name.as_str() == name)?.expr;
+ +            Some(expr)
+ +        }
+ +
+ +        match expr.kind {
+ +            hir::ExprKind::Call(path, args)
+ +                if matches!(
+ +                    path.kind,
+ +                    hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, ..))
+ +                ) =>
+ +            {
+ +                Some(Range {
+ +                    start: Some(&args[0]),
+ +                    end: Some(&args[1]),
+ +                    limits: ast::RangeLimits::Closed,
+ +                })
+ +            },
+ +            hir::ExprKind::Struct(path, fields, None) => match &path {
+ +                hir::QPath::LangItem(hir::LangItem::RangeFull, ..) => Some(Range {
+ +                    start: None,
+ +                    end: None,
+ +                    limits: ast::RangeLimits::HalfOpen,
+ +                }),
+ +                hir::QPath::LangItem(hir::LangItem::RangeFrom, ..) => Some(Range {
+ +                    start: Some(get_field("start", fields)?),
+ +                    end: None,
+ +                    limits: ast::RangeLimits::HalfOpen,
+ +                }),
+ +                hir::QPath::LangItem(hir::LangItem::Range, ..) => Some(Range {
+ +                    start: Some(get_field("start", fields)?),
+ +                    end: Some(get_field("end", fields)?),
+ +                    limits: ast::RangeLimits::HalfOpen,
+ +                }),
+ +                hir::QPath::LangItem(hir::LangItem::RangeToInclusive, ..) => Some(Range {
+ +                    start: None,
+ +                    end: Some(get_field("end", fields)?),
+ +                    limits: ast::RangeLimits::Closed,
+ +                }),
+ +                hir::QPath::LangItem(hir::LangItem::RangeTo, ..) => Some(Range {
+ +                    start: None,
+ +                    end: Some(get_field("end", fields)?),
+ +                    limits: ast::RangeLimits::HalfOpen,
+ +                }),
+ +                _ => None,
+ +            },
+ +            _ => None,
+ +        }
+ +    }
+ +}
+ +
+ +/// Represent the pre-expansion arguments of a `vec!` invocation.
+ +pub enum VecArgs<'a> {
+ +    /// `vec![elem; len]`
+ +    Repeat(&'a hir::Expr<'a>, &'a hir::Expr<'a>),
+ +    /// `vec![a, b, c]`
+ +    Vec(&'a [hir::Expr<'a>]),
+ +}
+ +
+ +impl<'a> VecArgs<'a> {
+ +    /// Returns the arguments of the `vec!` macro if this expression was expanded
+ +    /// from `vec!`.
+ +    pub fn hir(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) -> Option<VecArgs<'a>> {
+ +        if_chain! {
+ +            if let hir::ExprKind::Call(fun, args) = expr.kind;
+ +            if let hir::ExprKind::Path(ref qpath) = fun.kind;
+ +            if is_expn_of(fun.span, "vec").is_some();
+ +            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+ +            then {
+ +                return if match_def_path(cx, fun_def_id, &paths::VEC_FROM_ELEM) && args.len() == 2 {
+ +                    // `vec![elem; size]` case
+ +                    Some(VecArgs::Repeat(&args[0], &args[1]))
-                 }
-                 else if match_def_path(cx, fun_def_id, &paths::VEC_NEW) && args.is_empty() {
++                } else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
+ +                    // `vec![a, b, c]` case
+ +                    if_chain! {
+ +                        if let hir::ExprKind::Box(boxed) = args[0].kind;
+ +                        if let hir::ExprKind::Array(args) = boxed.kind;
+ +                        then {
+ +                            return Some(VecArgs::Vec(args));
+ +                        }
+ +                    }
+ +
+ +                    None
-                 }
-                 else {
++                } else if match_def_path(cx, fun_def_id, &paths::VEC_NEW) && args.is_empty() {
+ +                    Some(VecArgs::Vec(&[]))
-                             return Some(VecInitKind::WithLiteralCapacity(num.try_into().ok()?))
++                } else {
+ +                    None
+ +                };
+ +            }
+ +        }
+ +
+ +        None
+ +    }
+ +}
+ +
+ +/// A desugared `while` loop
+ +pub struct While<'hir> {
+ +    /// `while` loop condition
+ +    pub condition: &'hir Expr<'hir>,
+ +    /// `while` loop body
+ +    pub body: &'hir Expr<'hir>,
+ +}
+ +
+ +impl<'hir> While<'hir> {
+ +    #[inline]
+ +    /// Parses a desugared `while` loop
+ +    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
+ +        if let ExprKind::Loop(
+ +            Block {
+ +                expr:
+ +                    Some(Expr {
+ +                        kind:
+ +                            ExprKind::If(
+ +                                Expr {
+ +                                    kind: ExprKind::DropTemps(condition),
+ +                                    ..
+ +                                },
+ +                                body,
+ +                                _,
+ +                            ),
+ +                        ..
+ +                    }),
+ +                ..
+ +            },
+ +            _,
+ +            LoopSource::While,
+ +            _,
+ +        ) = expr.kind
+ +        {
+ +            return Some(Self { condition, body });
+ +        }
+ +        None
+ +    }
+ +}
+ +
+ +/// A desugared `while let` loop
+ +pub struct WhileLet<'hir> {
+ +    /// `while let` loop item pattern
+ +    pub let_pat: &'hir Pat<'hir>,
+ +    /// `while let` loop scrutinee
+ +    pub let_expr: &'hir Expr<'hir>,
+ +    /// `while let` loop body
+ +    pub if_then: &'hir Expr<'hir>,
+ +}
+ +
+ +impl<'hir> WhileLet<'hir> {
+ +    #[inline]
+ +    /// Parses a desugared `while let` loop
+ +    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
+ +        if let ExprKind::Loop(
+ +            Block {
+ +                expr:
+ +                    Some(Expr {
+ +                        kind:
+ +                            ExprKind::If(
+ +                                Expr {
+ +                                    kind:
+ +                                        ExprKind::Let(hir::Let {
+ +                                            pat: let_pat,
+ +                                            init: let_expr,
+ +                                            ..
+ +                                        }),
+ +                                    ..
+ +                                },
+ +                                if_then,
+ +                                _,
+ +                            ),
+ +                        ..
+ +                    }),
+ +                ..
+ +            },
+ +            _,
+ +            LoopSource::While,
+ +            _,
+ +        ) = expr.kind
+ +        {
+ +            return Some(Self {
+ +                let_pat,
+ +                let_expr,
+ +                if_then,
+ +            });
+ +        }
+ +        None
+ +    }
+ +}
+ +
+ +/// Converts a hir binary operator to the corresponding `ast` type.
+ +#[must_use]
+ +pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
+ +    match op {
+ +        hir::BinOpKind::Eq => ast::BinOpKind::Eq,
+ +        hir::BinOpKind::Ge => ast::BinOpKind::Ge,
+ +        hir::BinOpKind::Gt => ast::BinOpKind::Gt,
+ +        hir::BinOpKind::Le => ast::BinOpKind::Le,
+ +        hir::BinOpKind::Lt => ast::BinOpKind::Lt,
+ +        hir::BinOpKind::Ne => ast::BinOpKind::Ne,
+ +        hir::BinOpKind::Or => ast::BinOpKind::Or,
+ +        hir::BinOpKind::Add => ast::BinOpKind::Add,
+ +        hir::BinOpKind::And => ast::BinOpKind::And,
+ +        hir::BinOpKind::BitAnd => ast::BinOpKind::BitAnd,
+ +        hir::BinOpKind::BitOr => ast::BinOpKind::BitOr,
+ +        hir::BinOpKind::BitXor => ast::BinOpKind::BitXor,
+ +        hir::BinOpKind::Div => ast::BinOpKind::Div,
+ +        hir::BinOpKind::Mul => ast::BinOpKind::Mul,
+ +        hir::BinOpKind::Rem => ast::BinOpKind::Rem,
+ +        hir::BinOpKind::Shl => ast::BinOpKind::Shl,
+ +        hir::BinOpKind::Shr => ast::BinOpKind::Shr,
+ +        hir::BinOpKind::Sub => ast::BinOpKind::Sub,
+ +    }
+ +}
+ +
+ +/// A parsed `Vec` initialization expression
+ +#[derive(Clone, Copy)]
+ +pub enum VecInitKind {
+ +    /// `Vec::new()`
+ +    New,
+ +    /// `Vec::default()` or `Default::default()`
+ +    Default,
+ +    /// `Vec::with_capacity(123)`
+ +    WithLiteralCapacity(u64),
+ +    /// `Vec::with_capacity(slice.len())`
+ +    WithExprCapacity(HirId),
+ +}
+ +
+ +/// Checks if given expression is an initialization of `Vec` and returns its kind.
+ +pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
+ +    if let ExprKind::Call(func, args) = expr.kind {
+ +        match func.kind {
+ +            ExprKind::Path(QPath::TypeRelative(ty, name))
+ +                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::Vec) =>
+ +            {
+ +                if name.ident.name == sym::new {
+ +                    return Some(VecInitKind::New);
+ +                } else if name.ident.name == symbol::kw::Default {
+ +                    return Some(VecInitKind::Default);
+ +                } else if name.ident.name.as_str() == "with_capacity" {
+ +                    let arg = args.get(0)?;
+ +                    if_chain! {
+ +                        if let ExprKind::Lit(lit) = &arg.kind;
+ +                        if let LitKind::Int(num, _) = lit.node;
+ +                        then {
++                            return Some(VecInitKind::WithLiteralCapacity(num.try_into().ok()?));
+ +                        }
+ +                    }
+ +                    return Some(VecInitKind::WithExprCapacity(arg.hir_id));
+ +                }
+ +            },
+ +            ExprKind::Path(QPath::Resolved(_, path))
+ +                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
+ +                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec) =>
+ +            {
+ +                return Some(VecInitKind::Default);
+ +            },
+ +            _ => (),
+ +        }
+ +    }
+ +    None
+ +}
diff --cc src/tools/clippy/clippy_utils/src/hir_utils.rs

index 7b5c5af8f79bfb1d761e92db4597a77443ea0160,0000000000000000000000000000000000000000..9654895060f85bde17984d509fb4fc2f0906adf4

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_utils/src/hir_utils.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@@ -1,988 -1,0 +1,987 @@@
- use crate::differing_macro_contexts;
+ +use crate::consts::{constant_context, constant_simple};
-         if !self.inner.allow_side_effects && differing_macro_contexts(left.span, right.span) {
+ +use crate::source::snippet_opt;
+ +use rustc_ast::ast::InlineAsmTemplatePiece;
+ +use rustc_data_structures::fx::FxHasher;
+ +use rustc_hir::def::Res;
+ +use rustc_hir::HirIdMap;
+ +use rustc_hir::{
+ +    ArrayLen, BinOpKind, Block, BodyId, Expr, ExprField, ExprKind, FnRetTy, GenericArg, GenericArgs, Guard, HirId,
+ +    InlineAsmOperand, Let, Lifetime, LifetimeName, ParamName, Pat, PatField, PatKind, Path, PathSegment, QPath, Stmt,
+ +    StmtKind, Ty, TyKind, TypeBinding,
+ +};
+ +use rustc_lexer::{tokenize, TokenKind};
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::TypeckResults;
+ +use rustc_span::Symbol;
+ +use std::hash::{Hash, Hasher};
+ +
+ +/// Type used to check whether two ast are the same. This is different from the
+ +/// operator
+ +/// `==` on ast types as this operator would compare true equality with ID and
+ +/// span.
+ +///
+ +/// Note that some expressions kinds are not considered but could be added.
+ +pub struct SpanlessEq<'a, 'tcx> {
+ +    /// Context used to evaluate constant expressions.
+ +    cx: &'a LateContext<'tcx>,
+ +    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
+ +    allow_side_effects: bool,
+ +    expr_fallback: Option<Box<dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a>>,
+ +}
+ +
+ +impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
+ +    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
+ +        Self {
+ +            cx,
+ +            maybe_typeck_results: cx.maybe_typeck_results(),
+ +            allow_side_effects: true,
+ +            expr_fallback: None,
+ +        }
+ +    }
+ +
+ +    /// Consider expressions containing potential side effects as not equal.
+ +    #[must_use]
+ +    pub fn deny_side_effects(self) -> Self {
+ +        Self {
+ +            allow_side_effects: false,
+ +            ..self
+ +        }
+ +    }
+ +
+ +    #[must_use]
+ +    pub fn expr_fallback(self, expr_fallback: impl FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
+ +        Self {
+ +            expr_fallback: Some(Box::new(expr_fallback)),
+ +            ..self
+ +        }
+ +    }
+ +
+ +    /// Use this method to wrap comparisons that may involve inter-expression context.
+ +    /// See `self.locals`.
+ +    pub fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
+ +        HirEqInterExpr {
+ +            inner: self,
+ +            locals: HirIdMap::default(),
+ +        }
+ +    }
+ +
+ +    #[allow(dead_code)]
+ +    pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
+ +        self.inter_expr().eq_block(left, right)
+ +    }
+ +
+ +    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+ +        self.inter_expr().eq_expr(left, right)
+ +    }
+ +
+ +    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
+ +        self.inter_expr().eq_path_segment(left, right)
+ +    }
+ +
+ +    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
+ +        self.inter_expr().eq_path_segments(left, right)
+ +    }
+ +}
+ +
+ +pub struct HirEqInterExpr<'a, 'b, 'tcx> {
+ +    inner: &'a mut SpanlessEq<'b, 'tcx>,
+ +
+ +    // When binding are declared, the binding ID in the left expression is mapped to the one on the
+ +    // right. For example, when comparing `{ let x = 1; x + 2 }` and `{ let y = 1; y + 2 }`,
+ +    // these blocks are considered equal since `x` is mapped to `y`.
+ +    locals: HirIdMap<HirId>,
+ +}
+ +
+ +impl HirEqInterExpr<'_, '_, '_> {
+ +    pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
+ +        match (&left.kind, &right.kind) {
+ +            (&StmtKind::Local(l), &StmtKind::Local(r)) => {
+ +                // This additional check ensures that the type of the locals are equivalent even if the init
+ +                // expression or type have some inferred parts.
+ +                if let Some(typeck) = self.inner.maybe_typeck_results {
+ +                    let l_ty = typeck.pat_ty(l.pat);
+ +                    let r_ty = typeck.pat_ty(r.pat);
+ +                    if l_ty != r_ty {
+ +                        return false;
+ +                    }
+ +                }
+ +
+ +                // eq_pat adds the HirIds to the locals map. We therefor call it last to make sure that
+ +                // these only get added if the init and type is equal.
+ +                both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
+ +                    && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r))
+ +                    && self.eq_pat(l.pat, r.pat)
+ +            },
+ +            (&StmtKind::Expr(l), &StmtKind::Expr(r)) | (&StmtKind::Semi(l), &StmtKind::Semi(r)) => self.eq_expr(l, r),
+ +            _ => false,
+ +        }
+ +    }
+ +
+ +    /// Checks whether two blocks are the same.
+ +    fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
+ +        match (left.stmts, left.expr, right.stmts, right.expr) {
+ +            ([], None, [], None) => {
+ +                // For empty blocks, check to see if the tokens are equal. This will catch the case where a macro
+ +                // expanded to nothing, or the cfg attribute was used.
+ +                let (left, right) = match (
+ +                    snippet_opt(self.inner.cx, left.span),
+ +                    snippet_opt(self.inner.cx, right.span),
+ +                ) {
+ +                    (Some(left), Some(right)) => (left, right),
+ +                    _ => return true,
+ +                };
+ +                let mut left_pos = 0;
+ +                let left = tokenize(&left)
+ +                    .map(|t| {
+ +                        let end = left_pos + t.len;
+ +                        let s = &left[left_pos..end];
+ +                        left_pos = end;
+ +                        (t, s)
+ +                    })
+ +                    .filter(|(t, _)| {
+ +                        !matches!(
+ +                            t.kind,
+ +                            TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
+ +                        )
+ +                    })
+ +                    .map(|(_, s)| s);
+ +                let mut right_pos = 0;
+ +                let right = tokenize(&right)
+ +                    .map(|t| {
+ +                        let end = right_pos + t.len;
+ +                        let s = &right[right_pos..end];
+ +                        right_pos = end;
+ +                        (t, s)
+ +                    })
+ +                    .filter(|(t, _)| {
+ +                        !matches!(
+ +                            t.kind,
+ +                            TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
+ +                        )
+ +                    })
+ +                    .map(|(_, s)| s);
+ +                left.eq(right)
+ +            },
+ +            _ => {
+ +                over(left.stmts, right.stmts, |l, r| self.eq_stmt(l, r))
+ +                    && both(&left.expr, &right.expr, |l, r| self.eq_expr(l, r))
+ +            },
+ +        }
+ +    }
+ +
+ +    pub fn eq_array_length(&mut self, left: ArrayLen, right: ArrayLen) -> bool {
+ +        match (left, right) {
+ +            (ArrayLen::Infer(..), ArrayLen::Infer(..)) => true,
+ +            (ArrayLen::Body(l_ct), ArrayLen::Body(r_ct)) => self.eq_body(l_ct.body, r_ct.body),
+ +            (_, _) => false,
+ +        }
+ +    }
+ +
+ +    pub fn eq_body(&mut self, left: BodyId, right: BodyId) -> bool {
+ +        let cx = self.inner.cx;
+ +        let eval_const = |body| constant_context(cx, cx.tcx.typeck_body(body)).expr(&cx.tcx.hir().body(body).value);
+ +        eval_const(left) == eval_const(right)
+ +    }
+ +
+ +    #[allow(clippy::similar_names)]
+ +    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
++        if !self.inner.allow_side_effects && left.span.ctxt() != right.span.ctxt() {
+ +            return false;
+ +        }
+ +
+ +        if let Some(typeck_results) = self.inner.maybe_typeck_results {
+ +            if let (Some(l), Some(r)) = (
+ +                constant_simple(self.inner.cx, typeck_results, left),
+ +                constant_simple(self.inner.cx, typeck_results, right),
+ +            ) {
+ +                if l == r {
+ +                    return true;
+ +                }
+ +            }
+ +        }
+ +
+ +        let is_eq = match (
+ +            reduce_exprkind(self.inner.cx, &left.kind),
+ +            reduce_exprkind(self.inner.cx, &right.kind),
+ +        ) {
+ +            (&ExprKind::AddrOf(lb, l_mut, le), &ExprKind::AddrOf(rb, r_mut, re)) => {
+ +                lb == rb && l_mut == r_mut && self.eq_expr(le, re)
+ +            },
+ +            (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
+ +                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
+ +            },
+ +            (&ExprKind::Assign(ll, lr, _), &ExprKind::Assign(rl, rr, _)) => {
+ +                self.inner.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+ +            },
+ +            (&ExprKind::AssignOp(ref lo, ll, lr), &ExprKind::AssignOp(ref ro, rl, rr)) => {
+ +                self.inner.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+ +            },
+ +            (&ExprKind::Block(l, _), &ExprKind::Block(r, _)) => self.eq_block(l, r),
+ +            (&ExprKind::Binary(l_op, ll, lr), &ExprKind::Binary(r_op, rl, rr)) => {
+ +                l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+ +                    || swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| {
+ +                        l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
+ +                    })
+ +            },
+ +            (&ExprKind::Break(li, ref le), &ExprKind::Break(ri, ref re)) => {
+ +                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
+ +                    && both(le, re, |l, r| self.eq_expr(l, r))
+ +            },
+ +            (&ExprKind::Box(l), &ExprKind::Box(r)) => self.eq_expr(l, r),
+ +            (&ExprKind::Call(l_fun, l_args), &ExprKind::Call(r_fun, r_args)) => {
+ +                self.inner.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
+ +            },
+ +            (&ExprKind::Cast(lx, lt), &ExprKind::Cast(rx, rt)) | (&ExprKind::Type(lx, lt), &ExprKind::Type(rx, rt)) => {
+ +                self.eq_expr(lx, rx) && self.eq_ty(lt, rt)
+ +            },
+ +            (&ExprKind::Field(l_f_exp, ref l_f_ident), &ExprKind::Field(r_f_exp, ref r_f_ident)) => {
+ +                l_f_ident.name == r_f_ident.name && self.eq_expr(l_f_exp, r_f_exp)
+ +            },
+ +            (&ExprKind::Index(la, li), &ExprKind::Index(ra, ri)) => self.eq_expr(la, ra) && self.eq_expr(li, ri),
+ +            (&ExprKind::If(lc, lt, ref le), &ExprKind::If(rc, rt, ref re)) => {
+ +                self.eq_expr(lc, rc) && self.eq_expr(lt, rt) && both(le, re, |l, r| self.eq_expr(l, r))
+ +            },
+ +            (&ExprKind::Let(l), &ExprKind::Let(r)) => {
+ +                self.eq_pat(l.pat, r.pat) && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && self.eq_expr(l.init, r.init)
+ +            },
+ +            (&ExprKind::Lit(ref l), &ExprKind::Lit(ref r)) => l.node == r.node,
+ +            (&ExprKind::Loop(lb, ref ll, ref lls, _), &ExprKind::Loop(rb, ref rl, ref rls, _)) => {
+ +                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
+ +            },
+ +            (&ExprKind::Match(le, la, ref ls), &ExprKind::Match(re, ra, ref rs)) => {
+ +                ls == rs
+ +                    && self.eq_expr(le, re)
+ +                    && over(la, ra, |l, r| {
+ +                        self.eq_pat(l.pat, r.pat)
+ +                            && both(&l.guard, &r.guard, |l, r| self.eq_guard(l, r))
+ +                            && self.eq_expr(l.body, r.body)
+ +                    })
+ +            },
+ +            (&ExprKind::MethodCall(l_path, l_args, _), &ExprKind::MethodCall(r_path, r_args, _)) => {
+ +                self.inner.allow_side_effects && self.eq_path_segment(l_path, r_path) && self.eq_exprs(l_args, r_args)
+ +            },
+ +            (&ExprKind::Repeat(le, ll), &ExprKind::Repeat(re, rl)) => {
+ +                self.eq_expr(le, re) && self.eq_array_length(ll, rl)
+ +            },
+ +            (&ExprKind::Ret(ref l), &ExprKind::Ret(ref r)) => both(l, r, |l, r| self.eq_expr(l, r)),
+ +            (&ExprKind::Path(ref l), &ExprKind::Path(ref r)) => self.eq_qpath(l, r),
+ +            (&ExprKind::Struct(l_path, lf, ref lo), &ExprKind::Struct(r_path, rf, ref ro)) => {
+ +                self.eq_qpath(l_path, r_path)
+ +                    && both(lo, ro, |l, r| self.eq_expr(l, r))
+ +                    && over(lf, rf, |l, r| self.eq_expr_field(l, r))
+ +            },
+ +            (&ExprKind::Tup(l_tup), &ExprKind::Tup(r_tup)) => self.eq_exprs(l_tup, r_tup),
+ +            (&ExprKind::Unary(l_op, le), &ExprKind::Unary(r_op, re)) => l_op == r_op && self.eq_expr(le, re),
+ +            (&ExprKind::Array(l), &ExprKind::Array(r)) => self.eq_exprs(l, r),
+ +            (&ExprKind::DropTemps(le), &ExprKind::DropTemps(re)) => self.eq_expr(le, re),
+ +            _ => false,
+ +        };
+ +        is_eq || self.inner.expr_fallback.as_mut().map_or(false, |f| f(left, right))
+ +    }
+ +
+ +    fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
+ +        over(left, right, |l, r| self.eq_expr(l, r))
+ +    }
+ +
+ +    fn eq_expr_field(&mut self, left: &ExprField<'_>, right: &ExprField<'_>) -> bool {
+ +        left.ident.name == right.ident.name && self.eq_expr(left.expr, right.expr)
+ +    }
+ +
+ +    fn eq_guard(&mut self, left: &Guard<'_>, right: &Guard<'_>) -> bool {
+ +        match (left, right) {
+ +            (Guard::If(l), Guard::If(r)) => self.eq_expr(l, r),
+ +            (Guard::IfLet(lp, le), Guard::IfLet(rp, re)) => self.eq_pat(lp, rp) && self.eq_expr(le, re),
+ +            _ => false,
+ +        }
+ +    }
+ +
+ +    fn eq_generic_arg(&mut self, left: &GenericArg<'_>, right: &GenericArg<'_>) -> bool {
+ +        match (left, right) {
+ +            (GenericArg::Const(l), GenericArg::Const(r)) => self.eq_body(l.value.body, r.value.body),
+ +            (GenericArg::Lifetime(l_lt), GenericArg::Lifetime(r_lt)) => Self::eq_lifetime(l_lt, r_lt),
+ +            (GenericArg::Type(l_ty), GenericArg::Type(r_ty)) => self.eq_ty(l_ty, r_ty),
+ +            (GenericArg::Infer(l_inf), GenericArg::Infer(r_inf)) => self.eq_ty(&l_inf.to_ty(), &r_inf.to_ty()),
+ +            _ => false,
+ +        }
+ +    }
+ +
+ +    fn eq_lifetime(left: &Lifetime, right: &Lifetime) -> bool {
+ +        left.name == right.name
+ +    }
+ +
+ +    fn eq_pat_field(&mut self, left: &PatField<'_>, right: &PatField<'_>) -> bool {
+ +        let (PatField { ident: li, pat: lp, .. }, PatField { ident: ri, pat: rp, .. }) = (&left, &right);
+ +        li.name == ri.name && self.eq_pat(lp, rp)
+ +    }
+ +
+ +    /// Checks whether two patterns are the same.
+ +    fn eq_pat(&mut self, left: &Pat<'_>, right: &Pat<'_>) -> bool {
+ +        match (&left.kind, &right.kind) {
+ +            (&PatKind::Box(l), &PatKind::Box(r)) => self.eq_pat(l, r),
+ +            (&PatKind::Struct(ref lp, la, ..), &PatKind::Struct(ref rp, ra, ..)) => {
+ +                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat_field(l, r))
+ +            },
+ +            (&PatKind::TupleStruct(ref lp, la, ls), &PatKind::TupleStruct(ref rp, ra, rs)) => {
+ +                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
+ +            },
+ +            (&PatKind::Binding(lb, li, _, ref lp), &PatKind::Binding(rb, ri, _, ref rp)) => {
+ +                let eq = lb == rb && both(lp, rp, |l, r| self.eq_pat(l, r));
+ +                if eq {
+ +                    self.locals.insert(li, ri);
+ +                }
+ +                eq
+ +            },
+ +            (&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
+ +            (&PatKind::Lit(l), &PatKind::Lit(r)) => self.eq_expr(l, r),
+ +            (&PatKind::Tuple(l, ls), &PatKind::Tuple(r, rs)) => ls == rs && over(l, r, |l, r| self.eq_pat(l, r)),
+ +            (&PatKind::Range(ref ls, ref le, li), &PatKind::Range(ref rs, ref re, ri)) => {
+ +                both(ls, rs, |a, b| self.eq_expr(a, b)) && both(le, re, |a, b| self.eq_expr(a, b)) && (li == ri)
+ +            },
+ +            (&PatKind::Ref(le, ref lm), &PatKind::Ref(re, ref rm)) => lm == rm && self.eq_pat(le, re),
+ +            (&PatKind::Slice(ls, ref li, le), &PatKind::Slice(rs, ref ri, re)) => {
+ +                over(ls, rs, |l, r| self.eq_pat(l, r))
+ +                    && over(le, re, |l, r| self.eq_pat(l, r))
+ +                    && both(li, ri, |l, r| self.eq_pat(l, r))
+ +            },
+ +            (&PatKind::Wild, &PatKind::Wild) => true,
+ +            _ => false,
+ +        }
+ +    }
+ +
+ +    #[allow(clippy::similar_names)]
+ +    fn eq_qpath(&mut self, left: &QPath<'_>, right: &QPath<'_>) -> bool {
+ +        match (left, right) {
+ +            (&QPath::Resolved(ref lty, lpath), &QPath::Resolved(ref rty, rpath)) => {
+ +                both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath)
+ +            },
+ +            (&QPath::TypeRelative(lty, lseg), &QPath::TypeRelative(rty, rseg)) => {
+ +                self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg)
+ +            },
+ +            (&QPath::LangItem(llang_item, ..), &QPath::LangItem(rlang_item, ..)) => llang_item == rlang_item,
+ +            _ => false,
+ +        }
+ +    }
+ +
+ +    fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
+ +        match (left.res, right.res) {
+ +            (Res::Local(l), Res::Local(r)) => l == r || self.locals.get(&l) == Some(&r),
+ +            (Res::Local(_), _) | (_, Res::Local(_)) => false,
+ +            _ => over(left.segments, right.segments, |l, r| self.eq_path_segment(l, r)),
+ +        }
+ +    }
+ +
+ +    fn eq_path_parameters(&mut self, left: &GenericArgs<'_>, right: &GenericArgs<'_>) -> bool {
+ +        if !(left.parenthesized || right.parenthesized) {
+ +            over(left.args, right.args, |l, r| self.eq_generic_arg(l, r)) // FIXME(flip1995): may not work
+ +                && over(left.bindings, right.bindings, |l, r| self.eq_type_binding(l, r))
+ +        } else if left.parenthesized && right.parenthesized {
+ +            over(left.inputs(), right.inputs(), |l, r| self.eq_ty(l, r))
+ +                && both(&Some(&left.bindings[0].ty()), &Some(&right.bindings[0].ty()), |l, r| {
+ +                    self.eq_ty(l, r)
+ +                })
+ +        } else {
+ +            false
+ +        }
+ +    }
+ +
+ +    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
+ +        left.len() == right.len() && left.iter().zip(right).all(|(l, r)| self.eq_path_segment(l, r))
+ +    }
+ +
+ +    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
+ +        // The == of idents doesn't work with different contexts,
+ +        // we have to be explicit about hygiene
+ +        left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
+ +    }
+ +
+ +    #[allow(clippy::similar_names)]
+ +    pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
+ +        match (&left.kind, &right.kind) {
+ +            (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
+ +            (&TyKind::Array(lt, ll), &TyKind::Array(rt, rl)) => self.eq_ty(lt, rt) && self.eq_array_length(ll, rl),
+ +            (&TyKind::Ptr(ref l_mut), &TyKind::Ptr(ref r_mut)) => {
+ +                l_mut.mutbl == r_mut.mutbl && self.eq_ty(&*l_mut.ty, &*r_mut.ty)
+ +            },
+ +            (&TyKind::Rptr(_, ref l_rmut), &TyKind::Rptr(_, ref r_rmut)) => {
+ +                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(&*l_rmut.ty, &*r_rmut.ty)
+ +            },
+ +            (&TyKind::Path(ref l), &TyKind::Path(ref r)) => self.eq_qpath(l, r),
+ +            (&TyKind::Tup(l), &TyKind::Tup(r)) => over(l, r, |l, r| self.eq_ty(l, r)),
+ +            (&TyKind::Infer, &TyKind::Infer) => true,
+ +            _ => false,
+ +        }
+ +    }
+ +
+ +    fn eq_type_binding(&mut self, left: &TypeBinding<'_>, right: &TypeBinding<'_>) -> bool {
+ +        left.ident.name == right.ident.name && self.eq_ty(left.ty(), right.ty())
+ +    }
+ +}
+ +
+ +/// Some simple reductions like `{ return }` => `return`
+ +fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'hir ExprKind<'hir> {
+ +    if let ExprKind::Block(block, _) = kind {
+ +        match (block.stmts, block.expr) {
+ +            // From an `if let` expression without an `else` block. The arm for the implicit wild pattern is an empty
+ +            // block with an empty span.
+ +            ([], None) if block.span.is_empty() => &ExprKind::Tup(&[]),
+ +            // `{}` => `()`
+ +            ([], None) => match snippet_opt(cx, block.span) {
+ +                // Don't reduce if there are any tokens contained in the braces
+ +                Some(snip)
+ +                    if tokenize(&snip)
+ +                        .map(|t| t.kind)
+ +                        .filter(|t| {
+ +                            !matches!(
+ +                                t,
+ +                                TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
+ +                            )
+ +                        })
+ +                        .ne([TokenKind::OpenBrace, TokenKind::CloseBrace].iter().copied()) =>
+ +                {
+ +                    kind
+ +                },
+ +                _ => &ExprKind::Tup(&[]),
+ +            },
+ +            ([], Some(expr)) => match expr.kind {
+ +                // `{ return .. }` => `return ..`
+ +                ExprKind::Ret(..) => &expr.kind,
+ +                _ => kind,
+ +            },
+ +            ([stmt], None) => match stmt.kind {
+ +                StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
+ +                    // `{ return ..; }` => `return ..`
+ +                    ExprKind::Ret(..) => &expr.kind,
+ +                    _ => kind,
+ +                },
+ +                _ => kind,
+ +            },
+ +            _ => kind,
+ +        }
+ +    } else {
+ +        kind
+ +    }
+ +}
+ +
+ +fn swap_binop<'a>(
+ +    binop: BinOpKind,
+ +    lhs: &'a Expr<'a>,
+ +    rhs: &'a Expr<'a>,
+ +) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
+ +    match binop {
+ +        BinOpKind::Add | BinOpKind::Eq | BinOpKind::Ne | BinOpKind::BitAnd | BinOpKind::BitXor | BinOpKind::BitOr => {
+ +            Some((binop, rhs, lhs))
+ +        },
+ +        BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
+ +        BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
+ +        BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
+ +        BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
+ +        BinOpKind::Mul // Not always commutative, e.g. with matrices. See issue #5698
+ +        | BinOpKind::Shl
+ +        | BinOpKind::Shr
+ +        | BinOpKind::Rem
+ +        | BinOpKind::Sub
+ +        | BinOpKind::Div
+ +        | BinOpKind::And
+ +        | BinOpKind::Or => None,
+ +    }
+ +}
+ +
+ +/// Checks if the two `Option`s are both `None` or some equal values as per
+ +/// `eq_fn`.
+ +pub fn both<X>(l: &Option<X>, r: &Option<X>, mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+ +    l.as_ref()
+ +        .map_or_else(|| r.is_none(), |x| r.as_ref().map_or(false, |y| eq_fn(x, y)))
+ +}
+ +
+ +/// Checks if two slices are equal as per `eq_fn`.
+ +pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
+ +    left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
+ +}
+ +
+ +/// Counts how many elements of the slices are equal as per `eq_fn`.
+ +pub fn count_eq<X: Sized>(
+ +    left: &mut dyn Iterator<Item = X>,
+ +    right: &mut dyn Iterator<Item = X>,
+ +    mut eq_fn: impl FnMut(&X, &X) -> bool,
+ +) -> usize {
+ +    left.zip(right).take_while(|(l, r)| eq_fn(l, r)).count()
+ +}
+ +
+ +/// Checks if two expressions evaluate to the same value, and don't contain any side effects.
+ +pub fn eq_expr_value(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>) -> bool {
+ +    SpanlessEq::new(cx).deny_side_effects().eq_expr(left, right)
+ +}
+ +
+ +/// Type used to hash an ast element. This is different from the `Hash` trait
+ +/// on ast types as this
+ +/// trait would consider IDs and spans.
+ +///
+ +/// All expressions kind are hashed, but some might have a weaker hash.
+ +pub struct SpanlessHash<'a, 'tcx> {
+ +    /// Context used to evaluate constant expressions.
+ +    cx: &'a LateContext<'tcx>,
+ +    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
+ +    s: FxHasher,
+ +}
+ +
+ +impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
+ +    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
+ +        Self {
+ +            cx,
+ +            maybe_typeck_results: cx.maybe_typeck_results(),
+ +            s: FxHasher::default(),
+ +        }
+ +    }
+ +
+ +    pub fn finish(self) -> u64 {
+ +        self.s.finish()
+ +    }
+ +
+ +    pub fn hash_block(&mut self, b: &Block<'_>) {
+ +        for s in b.stmts {
+ +            self.hash_stmt(s);
+ +        }
+ +
+ +        if let Some(e) = b.expr {
+ +            self.hash_expr(e);
+ +        }
+ +
+ +        std::mem::discriminant(&b.rules).hash(&mut self.s);
+ +    }
+ +
+ +    #[allow(clippy::too_many_lines)]
+ +    pub fn hash_expr(&mut self, e: &Expr<'_>) {
+ +        let simple_const = self
+ +            .maybe_typeck_results
+ +            .and_then(|typeck_results| constant_simple(self.cx, typeck_results, e));
+ +
+ +        // const hashing may result in the same hash as some unrelated node, so add a sort of
+ +        // discriminant depending on which path we're choosing next
+ +        simple_const.hash(&mut self.s);
+ +        if simple_const.is_some() {
+ +            return;
+ +        }
+ +
+ +        std::mem::discriminant(&e.kind).hash(&mut self.s);
+ +
+ +        match e.kind {
+ +            ExprKind::AddrOf(kind, m, e) => {
+ +                std::mem::discriminant(&kind).hash(&mut self.s);
+ +                m.hash(&mut self.s);
+ +                self.hash_expr(e);
+ +            },
+ +            ExprKind::Continue(i) => {
+ +                if let Some(i) = i.label {
+ +                    self.hash_name(i.ident.name);
+ +                }
+ +            },
+ +            ExprKind::Assign(l, r, _) => {
+ +                self.hash_expr(l);
+ +                self.hash_expr(r);
+ +            },
+ +            ExprKind::AssignOp(ref o, l, r) => {
+ +                std::mem::discriminant(&o.node).hash(&mut self.s);
+ +                self.hash_expr(l);
+ +                self.hash_expr(r);
+ +            },
+ +            ExprKind::Block(b, _) => {
+ +                self.hash_block(b);
+ +            },
+ +            ExprKind::Binary(op, l, r) => {
+ +                std::mem::discriminant(&op.node).hash(&mut self.s);
+ +                self.hash_expr(l);
+ +                self.hash_expr(r);
+ +            },
+ +            ExprKind::Break(i, ref j) => {
+ +                if let Some(i) = i.label {
+ +                    self.hash_name(i.ident.name);
+ +                }
+ +                if let Some(j) = *j {
+ +                    self.hash_expr(&*j);
+ +                }
+ +            },
+ +            ExprKind::Box(e) | ExprKind::DropTemps(e) | ExprKind::Yield(e, _) => {
+ +                self.hash_expr(e);
+ +            },
+ +            ExprKind::Call(fun, args) => {
+ +                self.hash_expr(fun);
+ +                self.hash_exprs(args);
+ +            },
+ +            ExprKind::Cast(e, ty) | ExprKind::Type(e, ty) => {
+ +                self.hash_expr(e);
+ +                self.hash_ty(ty);
+ +            },
+ +            ExprKind::Closure(cap, _, eid, _, _) => {
+ +                std::mem::discriminant(&cap).hash(&mut self.s);
+ +                // closures inherit TypeckResults
+ +                self.hash_expr(&self.cx.tcx.hir().body(eid).value);
+ +            },
+ +            ExprKind::Field(e, ref f) => {
+ +                self.hash_expr(e);
+ +                self.hash_name(f.name);
+ +            },
+ +            ExprKind::Index(a, i) => {
+ +                self.hash_expr(a);
+ +                self.hash_expr(i);
+ +            },
+ +            ExprKind::InlineAsm(asm) => {
+ +                for piece in asm.template {
+ +                    match piece {
+ +                        InlineAsmTemplatePiece::String(s) => s.hash(&mut self.s),
+ +                        InlineAsmTemplatePiece::Placeholder {
+ +                            operand_idx,
+ +                            modifier,
+ +                            span: _,
+ +                        } => {
+ +                            operand_idx.hash(&mut self.s);
+ +                            modifier.hash(&mut self.s);
+ +                        },
+ +                    }
+ +                }
+ +                asm.options.hash(&mut self.s);
+ +                for (op, _op_sp) in asm.operands {
+ +                    match op {
+ +                        InlineAsmOperand::In { reg, expr } => {
+ +                            reg.hash(&mut self.s);
+ +                            self.hash_expr(expr);
+ +                        },
+ +                        InlineAsmOperand::Out { reg, late, expr } => {
+ +                            reg.hash(&mut self.s);
+ +                            late.hash(&mut self.s);
+ +                            if let Some(expr) = expr {
+ +                                self.hash_expr(expr);
+ +                            }
+ +                        },
+ +                        InlineAsmOperand::InOut { reg, late, expr } => {
+ +                            reg.hash(&mut self.s);
+ +                            late.hash(&mut self.s);
+ +                            self.hash_expr(expr);
+ +                        },
+ +                        InlineAsmOperand::SplitInOut {
+ +                            reg,
+ +                            late,
+ +                            in_expr,
+ +                            out_expr,
+ +                        } => {
+ +                            reg.hash(&mut self.s);
+ +                            late.hash(&mut self.s);
+ +                            self.hash_expr(in_expr);
+ +                            if let Some(out_expr) = out_expr {
+ +                                self.hash_expr(out_expr);
+ +                            }
+ +                        },
+ +                        InlineAsmOperand::Const { anon_const } => self.hash_body(anon_const.body),
+ +                        InlineAsmOperand::Sym { expr } => self.hash_expr(expr),
+ +                    }
+ +                }
+ +            },
+ +            ExprKind::Let(Let { pat, init, ty, .. }) => {
+ +                self.hash_expr(init);
+ +                if let Some(ty) = ty {
+ +                    self.hash_ty(ty);
+ +                }
+ +                self.hash_pat(pat);
+ +            },
+ +            ExprKind::Err => {},
+ +            ExprKind::Lit(ref l) => {
+ +                l.node.hash(&mut self.s);
+ +            },
+ +            ExprKind::Loop(b, ref i, ..) => {
+ +                self.hash_block(b);
+ +                if let Some(i) = *i {
+ +                    self.hash_name(i.ident.name);
+ +                }
+ +            },
+ +            ExprKind::If(cond, then, ref else_opt) => {
+ +                self.hash_expr(cond);
+ +                self.hash_expr(then);
+ +                if let Some(e) = *else_opt {
+ +                    self.hash_expr(e);
+ +                }
+ +            },
+ +            ExprKind::Match(e, arms, ref s) => {
+ +                self.hash_expr(e);
+ +
+ +                for arm in arms {
+ +                    self.hash_pat(arm.pat);
+ +                    if let Some(ref e) = arm.guard {
+ +                        self.hash_guard(e);
+ +                    }
+ +                    self.hash_expr(arm.body);
+ +                }
+ +
+ +                s.hash(&mut self.s);
+ +            },
+ +            ExprKind::MethodCall(path, args, ref _fn_span) => {
+ +                self.hash_name(path.ident.name);
+ +                self.hash_exprs(args);
+ +            },
+ +            ExprKind::ConstBlock(ref l_id) => {
+ +                self.hash_body(l_id.body);
+ +            },
+ +            ExprKind::Repeat(e, len) => {
+ +                self.hash_expr(e);
+ +                self.hash_array_length(len);
+ +            },
+ +            ExprKind::Ret(ref e) => {
+ +                if let Some(e) = *e {
+ +                    self.hash_expr(e);
+ +                }
+ +            },
+ +            ExprKind::Path(ref qpath) => {
+ +                self.hash_qpath(qpath);
+ +            },
+ +            ExprKind::Struct(path, fields, ref expr) => {
+ +                self.hash_qpath(path);
+ +
+ +                for f in fields {
+ +                    self.hash_name(f.ident.name);
+ +                    self.hash_expr(f.expr);
+ +                }
+ +
+ +                if let Some(e) = *expr {
+ +                    self.hash_expr(e);
+ +                }
+ +            },
+ +            ExprKind::Tup(tup) => {
+ +                self.hash_exprs(tup);
+ +            },
+ +            ExprKind::Array(v) => {
+ +                self.hash_exprs(v);
+ +            },
+ +            ExprKind::Unary(lop, le) => {
+ +                std::mem::discriminant(&lop).hash(&mut self.s);
+ +                self.hash_expr(le);
+ +            },
+ +        }
+ +    }
+ +
+ +    pub fn hash_exprs(&mut self, e: &[Expr<'_>]) {
+ +        for e in e {
+ +            self.hash_expr(e);
+ +        }
+ +    }
+ +
+ +    pub fn hash_name(&mut self, n: Symbol) {
+ +        n.hash(&mut self.s);
+ +    }
+ +
+ +    pub fn hash_qpath(&mut self, p: &QPath<'_>) {
+ +        match *p {
+ +            QPath::Resolved(_, path) => {
+ +                self.hash_path(path);
+ +            },
+ +            QPath::TypeRelative(_, path) => {
+ +                self.hash_name(path.ident.name);
+ +            },
+ +            QPath::LangItem(lang_item, ..) => {
+ +                std::mem::discriminant(&lang_item).hash(&mut self.s);
+ +            },
+ +        }
+ +        // self.maybe_typeck_results.unwrap().qpath_res(p, id).hash(&mut self.s);
+ +    }
+ +
+ +    pub fn hash_pat(&mut self, pat: &Pat<'_>) {
+ +        std::mem::discriminant(&pat.kind).hash(&mut self.s);
+ +        match pat.kind {
+ +            PatKind::Binding(ann, _, _, pat) => {
+ +                std::mem::discriminant(&ann).hash(&mut self.s);
+ +                if let Some(pat) = pat {
+ +                    self.hash_pat(pat);
+ +                }
+ +            },
+ +            PatKind::Box(pat) => self.hash_pat(pat),
+ +            PatKind::Lit(expr) => self.hash_expr(expr),
+ +            PatKind::Or(pats) => {
+ +                for pat in pats {
+ +                    self.hash_pat(pat);
+ +                }
+ +            },
+ +            PatKind::Path(ref qpath) => self.hash_qpath(qpath),
+ +            PatKind::Range(s, e, i) => {
+ +                if let Some(s) = s {
+ +                    self.hash_expr(s);
+ +                }
+ +                if let Some(e) = e {
+ +                    self.hash_expr(e);
+ +                }
+ +                std::mem::discriminant(&i).hash(&mut self.s);
+ +            },
+ +            PatKind::Ref(pat, mu) => {
+ +                self.hash_pat(pat);
+ +                std::mem::discriminant(&mu).hash(&mut self.s);
+ +            },
+ +            PatKind::Slice(l, m, r) => {
+ +                for pat in l {
+ +                    self.hash_pat(pat);
+ +                }
+ +                if let Some(pat) = m {
+ +                    self.hash_pat(pat);
+ +                }
+ +                for pat in r {
+ +                    self.hash_pat(pat);
+ +                }
+ +            },
+ +            PatKind::Struct(ref qpath, fields, e) => {
+ +                self.hash_qpath(qpath);
+ +                for f in fields {
+ +                    self.hash_name(f.ident.name);
+ +                    self.hash_pat(f.pat);
+ +                }
+ +                e.hash(&mut self.s);
+ +            },
+ +            PatKind::Tuple(pats, e) => {
+ +                for pat in pats {
+ +                    self.hash_pat(pat);
+ +                }
+ +                e.hash(&mut self.s);
+ +            },
+ +            PatKind::TupleStruct(ref qpath, pats, e) => {
+ +                self.hash_qpath(qpath);
+ +                for pat in pats {
+ +                    self.hash_pat(pat);
+ +                }
+ +                e.hash(&mut self.s);
+ +            },
+ +            PatKind::Wild => {},
+ +        }
+ +    }
+ +
+ +    pub fn hash_path(&mut self, path: &Path<'_>) {
+ +        match path.res {
+ +            // constant hash since equality is dependant on inter-expression context
+ +            // e.g. The expressions `if let Some(x) = foo() {}` and `if let Some(y) = foo() {}` are considered equal
+ +            // even though the binding names are different and they have different `HirId`s.
+ +            Res::Local(_) => 1_usize.hash(&mut self.s),
+ +            _ => {
+ +                for seg in path.segments {
+ +                    self.hash_name(seg.ident.name);
+ +                    self.hash_generic_args(seg.args().args);
+ +                }
+ +            },
+ +        }
+ +    }
+ +
+ +    pub fn hash_stmt(&mut self, b: &Stmt<'_>) {
+ +        std::mem::discriminant(&b.kind).hash(&mut self.s);
+ +
+ +        match &b.kind {
+ +            StmtKind::Local(local) => {
+ +                self.hash_pat(local.pat);
+ +                if let Some(init) = local.init {
+ +                    self.hash_expr(init);
+ +                }
+ +            },
+ +            StmtKind::Item(..) => {},
+ +            StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
+ +                self.hash_expr(expr);
+ +            },
+ +        }
+ +    }
+ +
+ +    pub fn hash_guard(&mut self, g: &Guard<'_>) {
+ +        match g {
+ +            Guard::If(expr) | Guard::IfLet(_, expr) => {
+ +                self.hash_expr(expr);
+ +            },
+ +        }
+ +    }
+ +
+ +    pub fn hash_lifetime(&mut self, lifetime: Lifetime) {
+ +        std::mem::discriminant(&lifetime.name).hash(&mut self.s);
+ +        if let LifetimeName::Param(ref name) = lifetime.name {
+ +            std::mem::discriminant(name).hash(&mut self.s);
+ +            match name {
+ +                ParamName::Plain(ref ident) => {
+ +                    ident.name.hash(&mut self.s);
+ +                },
+ +                ParamName::Fresh(ref size) => {
+ +                    size.hash(&mut self.s);
+ +                },
+ +                ParamName::Error => {},
+ +            }
+ +        }
+ +    }
+ +
+ +    pub fn hash_ty(&mut self, ty: &Ty<'_>) {
+ +        std::mem::discriminant(&ty.kind).hash(&mut self.s);
+ +        self.hash_tykind(&ty.kind);
+ +    }
+ +
+ +    pub fn hash_tykind(&mut self, ty: &TyKind<'_>) {
+ +        match ty {
+ +            TyKind::Slice(ty) => {
+ +                self.hash_ty(ty);
+ +            },
+ +            &TyKind::Array(ty, len) => {
+ +                self.hash_ty(ty);
+ +                self.hash_array_length(len);
+ +            },
+ +            TyKind::Ptr(ref mut_ty) => {
+ +                self.hash_ty(mut_ty.ty);
+ +                mut_ty.mutbl.hash(&mut self.s);
+ +            },
+ +            TyKind::Rptr(lifetime, ref mut_ty) => {
+ +                self.hash_lifetime(*lifetime);
+ +                self.hash_ty(mut_ty.ty);
+ +                mut_ty.mutbl.hash(&mut self.s);
+ +            },
+ +            TyKind::BareFn(bfn) => {
+ +                bfn.unsafety.hash(&mut self.s);
+ +                bfn.abi.hash(&mut self.s);
+ +                for arg in bfn.decl.inputs {
+ +                    self.hash_ty(arg);
+ +                }
+ +                std::mem::discriminant(&bfn.decl.output).hash(&mut self.s);
+ +                match bfn.decl.output {
+ +                    FnRetTy::DefaultReturn(_) => {},
+ +                    FnRetTy::Return(ty) => {
+ +                        self.hash_ty(ty);
+ +                    },
+ +                }
+ +                bfn.decl.c_variadic.hash(&mut self.s);
+ +            },
+ +            TyKind::Tup(ty_list) => {
+ +                for ty in *ty_list {
+ +                    self.hash_ty(ty);
+ +                }
+ +            },
+ +            TyKind::Path(ref qpath) => self.hash_qpath(qpath),
+ +            TyKind::OpaqueDef(_, arg_list) => {
+ +                self.hash_generic_args(arg_list);
+ +            },
+ +            TyKind::TraitObject(_, lifetime, _) => {
+ +                self.hash_lifetime(*lifetime);
+ +            },
+ +            TyKind::Typeof(anon_const) => {
+ +                self.hash_body(anon_const.body);
+ +            },
+ +            TyKind::Err | TyKind::Infer | TyKind::Never => {},
+ +        }
+ +    }
+ +
+ +    pub fn hash_array_length(&mut self, length: ArrayLen) {
+ +        match length {
+ +            ArrayLen::Infer(..) => {},
+ +            ArrayLen::Body(anon_const) => self.hash_body(anon_const.body),
+ +        }
+ +    }
+ +
+ +    pub fn hash_body(&mut self, body_id: BodyId) {
+ +        // swap out TypeckResults when hashing a body
+ +        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body_id));
+ +        self.hash_expr(&self.cx.tcx.hir().body(body_id).value);
+ +        self.maybe_typeck_results = old_maybe_typeck_results;
+ +    }
+ +
+ +    fn hash_generic_args(&mut self, arg_list: &[GenericArg<'_>]) {
+ +        for arg in arg_list {
+ +            match *arg {
+ +                GenericArg::Lifetime(l) => self.hash_lifetime(l),
+ +                GenericArg::Type(ref ty) => self.hash_ty(ty),
+ +                GenericArg::Const(ref ca) => self.hash_body(ca.value.body),
+ +                GenericArg::Infer(ref inf) => self.hash_ty(&inf.to_ty()),
+ +            }
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_utils/src/lib.rs

index a2f1f4696513e067febb58cc2b688faef4c04c73,0000000000000000000000000000000000000000..42955080c966e10d37ca00c6feb89009b2797c19

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_utils/src/lib.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@@ -1,2236 -1,0 +1,2178 @@@
-     ExprKind, FnDecl, ForeignItem, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem,
-     Local, MatchSource, Mutability, Node, Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind,
-     Target, TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
+ +#![feature(box_patterns)]
+ +#![feature(control_flow_enum)]
+ +#![feature(let_else)]
+ +#![feature(once_cell)]
+ +#![feature(rustc_private)]
+ +#![recursion_limit = "512"]
+ +#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+ +#![allow(clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::must_use_candidate)]
+ +// warn on the same lints as `clippy_lints`
+ +#![warn(trivial_casts, trivial_numeric_casts)]
+ +// warn on lints, that are included in `rust-lang/rust`s bootstrap
+ +#![warn(rust_2018_idioms, unused_lifetimes)]
+ +// warn on rustc internal lints
+ +#![warn(rustc::internal)]
+ +
+ +// FIXME: switch to something more ergonomic here, once available.
+ +// (Currently there is no way to opt into sysroot crates without `extern crate`.)
+ +extern crate rustc_ast;
+ +extern crate rustc_ast_pretty;
+ +extern crate rustc_attr;
+ +extern crate rustc_data_structures;
+ +extern crate rustc_errors;
+ +extern crate rustc_hir;
+ +extern crate rustc_infer;
+ +extern crate rustc_lexer;
+ +extern crate rustc_lint;
+ +extern crate rustc_middle;
+ +extern crate rustc_session;
+ +extern crate rustc_span;
+ +extern crate rustc_target;
+ +extern crate rustc_trait_selection;
+ +extern crate rustc_typeck;
+ +
+ +#[macro_use]
+ +pub mod sym_helper;
+ +
+ +#[allow(clippy::module_name_repetitions)]
+ +pub mod ast_utils;
+ +pub mod attrs;
+ +pub mod comparisons;
+ +pub mod consts;
+ +pub mod diagnostics;
+ +pub mod eager_or_lazy;
+ +pub mod higher;
+ +mod hir_utils;
+ +pub mod macros;
+ +pub mod msrvs;
+ +pub mod numeric_literal;
+ +pub mod paths;
+ +pub mod ptr;
+ +pub mod qualify_min_const_fn;
+ +pub mod source;
+ +pub mod str_utils;
+ +pub mod sugg;
+ +pub mod ty;
+ +pub mod usage;
+ +pub mod visitors;
+ +
+ +pub use self::attrs::*;
+ +pub use self::hir_utils::{both, count_eq, eq_expr_value, over, SpanlessEq, SpanlessHash};
+ +
+ +use std::collections::hash_map::Entry;
+ +use std::hash::BuildHasherDefault;
+ +use std::lazy::SyncOnceCell;
+ +use std::sync::{Mutex, MutexGuard};
+ +
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::{self, Attribute, LitKind};
+ +use rustc_data_structures::fx::FxHashMap;
+ +use rustc_data_structures::unhash::UnhashMap;
+ +use rustc_hir as hir;
+ +use rustc_hir::def::{DefKind, Res};
+ +use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_ID};
+ +use rustc_hir::hir_id::{HirIdMap, HirIdSet};
+ +use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
+ +use rustc_hir::itemlikevisit::ItemLikeVisitor;
+ +use rustc_hir::LangItem::{OptionNone, ResultErr, ResultOk};
+ +use rustc_hir::{
+ +    def, lang_items, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Constness, Destination, Expr,
- /// Returns `true` if the two spans come from differing expansions (i.e., one is
- /// from a macro and one isn't).
- #[must_use]
- pub fn differing_macro_contexts(lhs: Span, rhs: Span) -> bool {
-     rhs.ctxt() != lhs.ctxt()
- }
- 
++    ExprKind, FnDecl, ForeignItem, HirId, Impl, ImplItem, ImplItemKind, IsAsync, Item, ItemKind, LangItem, Local,
++    MatchSource, Mutability, Node, Param, Pat, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, Target,
++    TraitItem, TraitItemKind, TraitRef, TyKind, UnOp,
+ +};
+ +use rustc_lint::{LateContext, Level, Lint, LintContext};
+ +use rustc_middle::hir::place::PlaceBase;
+ +use rustc_middle::ty as rustc_ty;
+ +use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
+ +use rustc_middle::ty::binding::BindingMode;
+ +use rustc_middle::ty::{layout::IntegerExt, BorrowKind, DefIdTree, Ty, TyCtxt, TypeAndMut, TypeFoldable, UpvarCapture};
+ +use rustc_semver::RustcVersion;
+ +use rustc_session::Session;
+ +use rustc_span::hygiene::{ExpnKind, MacroKind};
+ +use rustc_span::source_map::original_sp;
+ +use rustc_span::sym;
+ +use rustc_span::symbol::{kw, Symbol};
+ +use rustc_span::{Span, DUMMY_SP};
+ +use rustc_target::abi::Integer;
+ +
+ +use crate::consts::{constant, Constant};
+ +use crate::ty::{can_partially_move_ty, is_copy, is_recursively_primitive_type};
+ +use crate::visitors::expr_visitor_no_bodies;
+ +
+ +pub fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
+ +    if let Ok(version) = RustcVersion::parse(msrv) {
+ +        return Some(version);
+ +    } else if let Some(sess) = sess {
+ +        if let Some(span) = span {
+ +            sess.span_err(span, &format!("`{}` is not a valid Rust version", msrv));
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +pub fn meets_msrv(msrv: Option<&RustcVersion>, lint_msrv: &RustcVersion) -> bool {
+ +    msrv.map_or(true, |msrv| msrv.meets(*lint_msrv))
+ +}
+ +
+ +#[macro_export]
+ +macro_rules! extract_msrv_attr {
+ +    ($context:ident) => {
+ +        fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'_>, attrs: &[rustc_ast::ast::Attribute]) {
+ +            let sess = rustc_lint::LintContext::sess(cx);
+ +            match $crate::get_unique_inner_attr(sess, attrs, "msrv") {
+ +                Some(msrv_attr) => {
+ +                    if let Some(msrv) = msrv_attr.value_str() {
+ +                        self.msrv = $crate::parse_msrv(&msrv.to_string(), Some(sess), Some(msrv_attr.span));
+ +                    } else {
+ +                        sess.span_err(msrv_attr.span, "bad clippy attribute");
+ +                    }
+ +                },
+ +                _ => (),
+ +            }
+ +        }
+ +    };
+ +}
+ +
- /// Checks if the first type parameter is a lang item.
- pub fn is_ty_param_lang_item<'tcx>(
-     cx: &LateContext<'_>,
-     qpath: &QPath<'tcx>,
-     item: LangItem,
- ) -> Option<&'tcx hir::Ty<'tcx>> {
-     let ty = get_qpath_generic_tys(qpath).next()?;
- 
-     if let TyKind::Path(qpath) = &ty.kind {
-         cx.qpath_res(qpath, ty.hir_id)
-             .opt_def_id()
-             .map_or(false, |id| {
-                 cx.tcx.lang_items().require(item).map_or(false, |lang_id| id == lang_id)
-             })
-             .then(|| ty)
-     } else {
-         None
-     }
- }
- 
- /// Checks if the first type parameter is a diagnostic item.
- pub fn is_ty_param_diagnostic_item<'tcx>(
-     cx: &LateContext<'_>,
-     qpath: &QPath<'tcx>,
-     item: Symbol,
- ) -> Option<&'tcx hir::Ty<'tcx>> {
-     let ty = get_qpath_generic_tys(qpath).next()?;
- 
-     if let TyKind::Path(qpath) = &ty.kind {
-         cx.qpath_res(qpath, ty.hir_id)
-             .opt_def_id()
-             .map_or(false, |id| cx.tcx.is_diagnostic_item(item, id))
-             .then(|| ty)
-     } else {
-         None
-     }
- }
- 
+ +/// If the given expression is a local binding, find the initializer expression.
+ +/// If that initializer expression is another local binding, find its initializer again.
+ +/// This process repeats as long as possible (but usually no more than once). Initializer
+ +/// expressions with adjustments are ignored. If this is not desired, use [`find_binding_init`]
+ +/// instead.
+ +///
+ +/// Examples:
+ +/// ```
+ +/// let abc = 1;
+ +/// //        ^ output
+ +/// let def = abc;
+ +/// dbg!(def);
+ +/// //   ^^^ input
+ +///
+ +/// // or...
+ +/// let abc = 1;
+ +/// let def = abc + 2;
+ +/// //        ^^^^^^^ output
+ +/// dbg!(def);
+ +/// //   ^^^ input
+ +/// ```
+ +pub fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr<'b>) -> &'a Expr<'b> {
+ +    while let Some(init) = path_to_local(expr)
+ +        .and_then(|id| find_binding_init(cx, id))
+ +        .filter(|init| cx.typeck_results().expr_adjustments(init).is_empty())
+ +    {
+ +        expr = init;
+ +    }
+ +    expr
+ +}
+ +
+ +/// Finds the initializer expression for a local binding. Returns `None` if the binding is mutable.
+ +/// By only considering immutable bindings, we guarantee that the returned expression represents the
+ +/// value of the binding wherever it is referenced.
+ +///
+ +/// Example: For `let x = 1`, if the `HirId` of `x` is provided, the `Expr` `1` is returned.
+ +/// Note: If you have an expression that references a binding `x`, use `path_to_local` to get the
+ +/// canonical binding `HirId`.
+ +pub fn find_binding_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
+ +    let hir = cx.tcx.hir();
+ +    if_chain! {
+ +        if let Some(Node::Binding(pat)) = hir.find(hir_id);
+ +        if matches!(pat.kind, PatKind::Binding(BindingAnnotation::Unannotated, ..));
+ +        let parent = hir.get_parent_node(hir_id);
+ +        if let Some(Node::Local(local)) = hir.find(parent);
+ +        then {
+ +            return local.init;
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +/// Returns `true` if the given `NodeId` is inside a constant context
+ +///
+ +/// # Example
+ +///
+ +/// ```rust,ignore
+ +/// if in_constant(cx, expr.hir_id) {
+ +///     // Do something
+ +/// }
+ +/// ```
+ +pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
+ +    let parent_id = cx.tcx.hir().get_parent_item(id);
+ +    match cx.tcx.hir().get_by_def_id(parent_id) {
+ +        Node::Item(&Item {
+ +            kind: ItemKind::Const(..) | ItemKind::Static(..),
+ +            ..
+ +        })
+ +        | Node::TraitItem(&TraitItem {
+ +            kind: TraitItemKind::Const(..),
+ +            ..
+ +        })
+ +        | Node::ImplItem(&ImplItem {
+ +            kind: ImplItemKind::Const(..),
+ +            ..
+ +        })
+ +        | Node::AnonConst(_) => true,
+ +        Node::Item(&Item {
+ +            kind: ItemKind::Fn(ref sig, ..),
+ +            ..
+ +        })
+ +        | Node::ImplItem(&ImplItem {
+ +            kind: ImplItemKind::Fn(ref sig, _),
+ +            ..
+ +        }) => sig.header.constness == Constness::Const,
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Checks if a `QPath` resolves to a constructor of a `LangItem`.
+ +/// For example, use this to check whether a function call or a pattern is `Some(..)`.
+ +pub fn is_lang_ctor(cx: &LateContext<'_>, qpath: &QPath<'_>, lang_item: LangItem) -> bool {
+ +    if let QPath::Resolved(_, path) = qpath {
+ +        if let Res::Def(DefKind::Ctor(..), ctor_id) = path.res {
+ +            if let Ok(item_id) = cx.tcx.lang_items().require(lang_item) {
+ +                return cx.tcx.parent(ctor_id) == Some(item_id);
+ +            }
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +pub fn is_unit_expr(expr: &Expr<'_>) -> bool {
+ +    matches!(
+ +        expr.kind,
+ +        ExprKind::Block(
+ +            Block {
+ +                stmts: [],
+ +                expr: None,
+ +                ..
+ +            },
+ +            _
+ +        ) | ExprKind::Tup([])
+ +    )
+ +}
+ +
+ +/// Checks if given pattern is a wildcard (`_`)
+ +pub fn is_wild(pat: &Pat<'_>) -> bool {
+ +    matches!(pat.kind, PatKind::Wild)
+ +}
+ +
- pub fn get_qpath_generics<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx GenericArgs<'tcx>> {
-     match path {
-         QPath::Resolved(_, p) => p.segments.last().and_then(|s| s.args),
-         QPath::TypeRelative(_, s) => s.args,
-         QPath::LangItem(..) => None,
-     }
- }
- 
- pub fn get_qpath_generic_tys<'tcx>(path: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
-     get_qpath_generics(path)
-         .map_or([].as_ref(), |a| a.args)
+ +/// Checks if the method call given in `expr` belongs to the given trait.
+ +/// This is a deprecated function, consider using [`is_trait_method`].
+ +pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
+ +    let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
+ +    let trt_id = cx.tcx.trait_of_item(def_id);
+ +    trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
+ +}
+ +
+ +/// Checks if a method is defined in an impl of a diagnostic item
+ +pub fn is_diag_item_method(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
+ +    if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
+ +        if let Some(adt) = cx.tcx.type_of(impl_did).ty_adt_def() {
+ +            return cx.tcx.is_diagnostic_item(diag_item, adt.did);
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +/// Checks if a method is in a diagnostic item trait
+ +pub fn is_diag_trait_item(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
+ +    if let Some(trait_did) = cx.tcx.trait_of_item(def_id) {
+ +        return cx.tcx.is_diagnostic_item(diag_item, trait_did);
+ +    }
+ +    false
+ +}
+ +
+ +/// Checks if the method call given in `expr` belongs to the given trait.
+ +pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
+ +    cx.typeck_results()
+ +        .type_dependent_def_id(expr.hir_id)
+ +        .map_or(false, |did| is_diag_trait_item(cx, did, diag_item))
+ +}
+ +
+ +/// Checks if the given expression is a path referring an item on the trait
+ +/// that is marked with the given diagnostic item.
+ +///
+ +/// For checking method call expressions instead of path expressions, use
+ +/// [`is_trait_method`].
+ +///
+ +/// For example, this can be used to find if an expression like `u64::default`
+ +/// refers to an item of the trait `Default`, which is associated with the
+ +/// `diag_item` of `sym::Default`.
+ +pub fn is_trait_item(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
+ +    if let hir::ExprKind::Path(ref qpath) = expr.kind {
+ +        cx.qpath_res(qpath, expr.hir_id)
+ +            .opt_def_id()
+ +            .map_or(false, |def_id| is_diag_trait_item(cx, def_id, diag_item))
+ +    } else {
+ +        false
+ +    }
+ +}
+ +
+ +pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
+ +    match *path {
+ +        QPath::Resolved(_, path) => path.segments.last().expect("A path must have at least one segment"),
+ +        QPath::TypeRelative(_, seg) => seg,
+ +        QPath::LangItem(..) => panic!("last_path_segment: lang item has no path segments"),
+ +    }
+ +}
+ +
-         .filter_map(|a| {
-             if let hir::GenericArg::Type(ty) = a {
-                 Some(ty)
-             } else {
-                 None
-             }
++pub fn qpath_generic_tys<'tcx>(qpath: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
++    last_path_segment(qpath)
++        .args
++        .map_or(&[][..], |a| a.args)
+ +        .iter()
- pub fn single_segment_path<'tcx>(path: &QPath<'tcx>) -> Option<&'tcx PathSegment<'tcx>> {
-     match *path {
-         QPath::Resolved(_, path) => path.segments.get(0),
-         QPath::TypeRelative(_, seg) => Some(seg),
-         QPath::LangItem(..) => None,
-     }
- }
- 
++        .filter_map(|a| match a {
++            hir::GenericArg::Type(ty) => Some(ty),
++            _ => None,
+ +        })
+ +}
+ +
- /// If the expression is a path, resolve it. Otherwise, return `Res::Err`.
- pub fn expr_path_res(cx: &LateContext<'_>, expr: &Expr<'_>) -> Res {
-     if let ExprKind::Path(p) = &expr.kind {
-         cx.qpath_res(p, expr.hir_id)
-     } else {
-         Res::Err
-     }
- }
- 
- /// Resolves the path to a `DefId` and checks if it matches the given path.
- pub fn is_qpath_def_path(cx: &LateContext<'_>, path: &QPath<'_>, hir_id: HirId, segments: &[&str]) -> bool {
-     cx.qpath_res(path, hir_id)
-         .opt_def_id()
-         .map_or(false, |id| match_def_path(cx, id, segments))
- }
- 
+ +/// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
+ +/// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
+ +/// `QPath::Resolved.1.res.opt_def_id()`.
+ +///
+ +/// Matches a `QPath` against a slice of segment string literals.
+ +///
+ +/// There is also `match_path` if you are dealing with a `rustc_hir::Path` instead of a
+ +/// `rustc_hir::QPath`.
+ +///
+ +/// # Examples
+ +/// ```rust,ignore
+ +/// match_qpath(path, &["std", "rt", "begin_unwind"])
+ +/// ```
+ +pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
+ +    match *path {
+ +        QPath::Resolved(_, path) => match_path(path, segments),
+ +        QPath::TypeRelative(ty, segment) => match ty.kind {
+ +            TyKind::Path(ref inner_path) => {
+ +                if let [prefix @ .., end] = segments {
+ +                    if match_qpath(inner_path, prefix) {
+ +                        return segment.ident.name.as_str() == *end;
+ +                    }
+ +                }
+ +                false
+ +            },
+ +            _ => false,
+ +        },
+ +        QPath::LangItem(..) => false,
+ +    }
+ +}
+ +
-     expr_path_res(cx, expr)
-         .opt_def_id()
-         .map_or(false, |id| match_def_path(cx, id, segments))
+ +/// If the expression is a path, resolves it to a `DefId` and checks if it matches the given path.
+ +///
+ +/// Please use `is_expr_diagnostic_item` if the target is a diagnostic item.
+ +pub fn is_expr_path_def_path(cx: &LateContext<'_>, expr: &Expr<'_>, segments: &[&str]) -> bool {
-     expr_path_res(cx, expr)
-         .opt_def_id()
-         .map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
++    path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, segments))
+ +}
+ +
+ +/// If the expression is a path, resolves it to a `DefId` and checks if it matches the given
+ +/// diagnostic item.
+ +pub fn is_expr_diagnostic_item(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
- /// Gets the definition associated to a path.
- pub fn path_to_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
++    path_def_id(cx, expr).map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
+ +}
+ +
+ +/// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
+ +/// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
+ +/// `QPath::Resolved.1.res.opt_def_id()`.
+ +///
+ +/// Matches a `Path` against a slice of segment string literals.
+ +///
+ +/// There is also `match_qpath` if you are dealing with a `rustc_hir::QPath` instead of a
+ +/// `rustc_hir::Path`.
+ +///
+ +/// # Examples
+ +///
+ +/// ```rust,ignore
+ +/// if match_path(&trait_ref.path, &paths::HASH) {
+ +///     // This is the `std::hash::Hash` trait.
+ +/// }
+ +///
+ +/// if match_path(ty_path, &["rustc", "lint", "Lint"]) {
+ +///     // This is a `rustc_middle::lint::Lint`.
+ +/// }
+ +/// ```
+ +pub fn match_path(path: &Path<'_>, segments: &[&str]) -> bool {
+ +    path.segments
+ +        .iter()
+ +        .rev()
+ +        .zip(segments.iter().rev())
+ +        .all(|(a, b)| a.ident.name.as_str() == *b)
+ +}
+ +
+ +/// If the expression is a path to a local, returns the canonical `HirId` of the local.
+ +pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
+ +    if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind {
+ +        if let Res::Local(id) = path.res {
+ +            return Some(id);
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +/// Returns true if the expression is a path to a local with the specified `HirId`.
+ +/// Use this function to see if an expression matches a function argument or a match binding.
+ +pub fn path_to_local_id(expr: &Expr<'_>, id: HirId) -> bool {
+ +    path_to_local(expr) == Some(id)
+ +}
+ +
-     match path_to_res(cx, path) {
++pub trait MaybePath<'hir> {
++    fn hir_id(&self) -> HirId;
++    fn qpath_opt(&self) -> Option<&QPath<'hir>>;
++}
++
++macro_rules! maybe_path {
++    ($ty:ident, $kind:ident) => {
++        impl<'hir> MaybePath<'hir> for hir::$ty<'hir> {
++            fn hir_id(&self) -> HirId {
++                self.hir_id
++            }
++            fn qpath_opt(&self) -> Option<&QPath<'hir>> {
++                match &self.kind {
++                    hir::$kind::Path(qpath) => Some(qpath),
++                    _ => None,
++                }
++            }
++        }
++    };
++}
++maybe_path!(Expr, ExprKind);
++maybe_path!(Pat, PatKind);
++maybe_path!(Ty, TyKind);
++
++/// If `maybe_path` is a path node, resolves it, otherwise returns `Res::Err`
++pub fn path_res<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> Res {
++    match maybe_path.qpath_opt() {
++        None => Res::Err,
++        Some(qpath) => cx.qpath_res(qpath, maybe_path.hir_id()),
++    }
++}
++
++/// If `maybe_path` is a path node which resolves to an item, retrieves the item ID
++pub fn path_def_id<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> Option<DefId> {
++    path_res(cx, maybe_path).opt_def_id()
++}
++
++/// Resolves a def path like `std::vec::Vec`.
++/// This function is expensive and should be used sparingly.
++pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Res {
+ +    macro_rules! try_res {
+ +        ($e:expr) => {
+ +            match $e {
+ +                Some(e) => e,
+ +                None => return Res::Err,
+ +            }
+ +        };
+ +    }
+ +    fn item_child_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Option<Res> {
+ +        match tcx.def_kind(def_id) {
+ +            DefKind::Mod | DefKind::Enum | DefKind::Trait => tcx
+ +                .module_children(def_id)
+ +                .iter()
+ +                .find(|item| item.ident.name.as_str() == name)
+ +                .map(|child| child.res.expect_non_local()),
+ +            DefKind::Impl => tcx
+ +                .associated_item_def_ids(def_id)
+ +                .iter()
+ +                .copied()
+ +                .find(|assoc_def_id| tcx.item_name(*assoc_def_id).as_str() == name)
+ +                .map(|assoc_def_id| Res::Def(tcx.def_kind(assoc_def_id), assoc_def_id)),
+ +            _ => None,
+ +        }
+ +    }
+ +    fn find_primitive(tcx: TyCtxt<'_>, name: &str) -> Option<DefId> {
+ +        if let Some(&(index, Target::Impl)) = lang_items::ITEM_REFS.get(&Symbol::intern(name)) {
+ +            tcx.lang_items().items()[index]
+ +        } else {
+ +            None
+ +        }
+ +    }
+ +    fn find_crate(tcx: TyCtxt<'_>, name: &str) -> Option<DefId> {
+ +        tcx.crates(())
+ +            .iter()
+ +            .find(|&&num| tcx.crate_name(num).as_str() == name)
+ +            .map(CrateNum::as_def_id)
+ +    }
+ +
+ +    let (base, first, path) = match *path {
+ +        [base, first, ref path @ ..] => (base, first, path),
+ +        [primitive] => {
+ +            return PrimTy::from_name(Symbol::intern(primitive)).map_or(Res::Err, Res::PrimTy);
+ +        },
+ +        _ => return Res::Err,
+ +    };
+ +    let tcx = cx.tcx;
+ +    let first = try_res!(
+ +        find_primitive(tcx, base)
+ +            .or_else(|| find_crate(tcx, base))
+ +            .and_then(|id| item_child_by_name(tcx, id, first))
+ +    );
+ +
+ +    let last = path
+ +        .iter()
+ +        .copied()
+ +        // for each segment, find the child item
+ +        .try_fold(first, |res, segment| {
+ +            let def_id = res.def_id();
+ +            if let Some(item) = item_child_by_name(tcx, def_id, segment) {
+ +                Some(item)
+ +            } else if matches!(res, Res::Def(DefKind::Enum | DefKind::Struct, _)) {
+ +                // it is not a child item so check inherent impl items
+ +                tcx.inherent_impls(def_id)
+ +                    .iter()
+ +                    .find_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, segment))
+ +            } else {
+ +                None
+ +            }
+ +        });
+ +    try_res!(last).expect_non_local()
+ +}
+ +
+ +/// Convenience function to get the `DefId` of a trait by path.
+ +/// It could be a trait or trait alias.
+ +pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
-         then { return impl_.of_trait.as_ref(); }
++    match def_path_res(cx, path) {
+ +        Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
+ +        _ => None,
+ +    }
+ +}
+ +
+ +/// Gets the `hir::TraitRef` of the trait the given method is implemented for.
+ +///
+ +/// Use this if you want to find the `TraitRef` of the `Add` trait in this example:
+ +///
+ +/// ```rust
+ +/// struct Point(isize, isize);
+ +///
+ +/// impl std::ops::Add for Point {
+ +///     type Output = Self;
+ +///
+ +///     fn add(self, other: Self) -> Self {
+ +///         Point(0, 0)
+ +///     }
+ +/// }
+ +/// ```
+ +pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, def_id: LocalDefId) -> Option<&'tcx TraitRef<'tcx>> {
+ +    // Get the implemented trait for the current function
+ +    let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id);
+ +    let parent_impl = cx.tcx.hir().get_parent_item(hir_id);
+ +    if_chain! {
+ +        if parent_impl != CRATE_DEF_ID;
+ +        if let hir::Node::Item(item) = cx.tcx.hir().get_by_def_id(parent_impl);
+ +        if let hir::ItemKind::Impl(impl_) = &item.kind;
-         then {
-             true
-         }
-         else {
-             false
-         }
++        then {
++            return impl_.of_trait.as_ref();
++        }
+ +    }
+ +    None
+ +}
+ +
+ +/// This method will return tuple of projection stack and root of the expression,
+ +/// used in `can_mut_borrow_both`.
+ +///
+ +/// For example, if `e` represents the `v[0].a.b[x]`
+ +/// this method will return a tuple, composed of a `Vec`
+ +/// containing the `Expr`s for `v[0], v[0].a, v[0].a.b, v[0].a.b[x]`
+ +/// and an `Expr` for root of them, `v`
+ +fn projection_stack<'a, 'hir>(mut e: &'a Expr<'hir>) -> (Vec<&'a Expr<'hir>>, &'a Expr<'hir>) {
+ +    let mut result = vec![];
+ +    let root = loop {
+ +        match e.kind {
+ +            ExprKind::Index(ep, _) | ExprKind::Field(ep, _) => {
+ +                result.push(e);
+ +                e = ep;
+ +            },
+ +            _ => break e,
+ +        };
+ +    };
+ +    result.reverse();
+ +    (result, root)
+ +}
+ +
+ +/// Gets the mutability of the custom deref adjustment, if any.
+ +pub fn expr_custom_deref_adjustment(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<Mutability> {
+ +    cx.typeck_results()
+ +        .expr_adjustments(e)
+ +        .iter()
+ +        .find_map(|a| match a.kind {
+ +            Adjust::Deref(Some(d)) => Some(Some(d.mutbl)),
+ +            Adjust::Deref(None) => None,
+ +            _ => Some(None),
+ +        })
+ +        .and_then(|x| x)
+ +}
+ +
+ +/// Checks if two expressions can be mutably borrowed simultaneously
+ +/// and they aren't dependent on borrowing same thing twice
+ +pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -> bool {
+ +    let (s1, r1) = projection_stack(e1);
+ +    let (s2, r2) = projection_stack(e2);
+ +    if !eq_expr_value(cx, r1, r2) {
+ +        return true;
+ +    }
+ +    if expr_custom_deref_adjustment(cx, r1).is_some() || expr_custom_deref_adjustment(cx, r2).is_some() {
+ +        return false;
+ +    }
+ +
+ +    for (x1, x2) in s1.iter().zip(s2.iter()) {
+ +        if expr_custom_deref_adjustment(cx, x1).is_some() || expr_custom_deref_adjustment(cx, x2).is_some() {
+ +            return false;
+ +        }
+ +
+ +        match (&x1.kind, &x2.kind) {
+ +            (ExprKind::Field(_, i1), ExprKind::Field(_, i2)) => {
+ +                if i1 != i2 {
+ +                    return true;
+ +                }
+ +            },
+ +            (ExprKind::Index(_, i1), ExprKind::Index(_, i2)) => {
+ +                if !eq_expr_value(cx, i1, i2) {
+ +                    return false;
+ +                }
+ +            },
+ +            _ => return false,
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +/// Returns true if the `def_id` associated with the `path` is recognized as a "default-equivalent"
+ +/// constructor from the std library
+ +fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
+ +    let std_types_symbols = &[
+ +        sym::String,
+ +        sym::Vec,
+ +        sym::VecDeque,
+ +        sym::LinkedList,
+ +        sym::HashMap,
+ +        sym::BTreeMap,
+ +        sym::HashSet,
+ +        sym::BTreeSet,
+ +        sym::BinaryHeap,
+ +    ];
+ +
+ +    if let QPath::TypeRelative(_, method) = path {
+ +        if method.ident.name == sym::new {
+ +            if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
+ +                if let Some(adt) = cx.tcx.type_of(impl_did).ty_adt_def() {
+ +                    return std_types_symbols
+ +                        .iter()
+ +                        .any(|&symbol| cx.tcx.is_diagnostic_item(symbol, adt.did));
+ +                }
+ +            }
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +/// Return true if the expr is equal to `Default::default` when evaluated.
+ +pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) -> bool {
+ +    if_chain! {
+ +        if let hir::ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
+ +        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
+ +        if is_diag_trait_item(cx, repl_def_id, sym::Default)
+ +            || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
-             if (is_ok(cx, &arms[0]) && is_err(cx, &arms[1])) ||
-                 (is_ok(cx, &arms[1]) && is_err(cx, &arms[0]));
++        then { true } else { false }
+ +    }
+ +}
+ +
+ +/// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
+ +/// It doesn't cover all cases, for example indirect function calls (some of std
+ +/// functions are supported) but it is the best we have.
+ +pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+ +    match &e.kind {
+ +        ExprKind::Lit(lit) => match lit.node {
+ +            LitKind::Bool(false) | LitKind::Int(0, _) => true,
+ +            LitKind::Str(s, _) => s.is_empty(),
+ +            _ => false,
+ +        },
+ +        ExprKind::Tup(items) | ExprKind::Array(items) => items.iter().all(|x| is_default_equivalent(cx, x)),
+ +        ExprKind::Repeat(x, ArrayLen::Body(len)) => if_chain! {
+ +            if let ExprKind::Lit(ref const_lit) = cx.tcx.hir().body(len.body).value.kind;
+ +            if let LitKind::Int(v, _) = const_lit.node;
+ +            if v <= 32 && is_default_equivalent(cx, x);
+ +            then {
+ +                true
+ +            }
+ +            else {
+ +                false
+ +            }
+ +        },
+ +        ExprKind::Call(repl_func, _) => is_default_equivalent_call(cx, repl_func),
+ +        ExprKind::Path(qpath) => is_lang_ctor(cx, qpath, OptionNone),
+ +        ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Checks if the top level expression can be moved into a closure as is.
+ +/// Currently checks for:
+ +/// * Break/Continue outside the given loop HIR ids.
+ +/// * Yield/Return statements.
+ +/// * Inline assembly.
+ +/// * Usages of a field of a local where the type of the local can be partially moved.
+ +///
+ +/// For example, given the following function:
+ +///
+ +/// ```
+ +/// fn f<'a>(iter: &mut impl Iterator<Item = (usize, &'a mut String)>) {
+ +///     for item in iter {
+ +///         let s = item.1;
+ +///         if item.0 > 10 {
+ +///             continue;
+ +///         } else {
+ +///             s.clear();
+ +///         }
+ +///     }
+ +/// }
+ +/// ```
+ +///
+ +/// When called on the expression `item.0` this will return false unless the local `item` is in the
+ +/// `ignore_locals` set. The type `(usize, &mut String)` can have the second element moved, so it
+ +/// isn't always safe to move into a closure when only a single field is needed.
+ +///
+ +/// When called on the `continue` expression this will return false unless the outer loop expression
+ +/// is in the `loop_ids` set.
+ +///
+ +/// Note that this check is not recursive, so passing the `if` expression will always return true
+ +/// even though sub-expressions might return false.
+ +pub fn can_move_expr_to_closure_no_visit<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    expr: &'tcx Expr<'_>,
+ +    loop_ids: &[HirId],
+ +    ignore_locals: &HirIdSet,
+ +) -> bool {
+ +    match expr.kind {
+ +        ExprKind::Break(Destination { target_id: Ok(id), .. }, _)
+ +        | ExprKind::Continue(Destination { target_id: Ok(id), .. })
+ +            if loop_ids.contains(&id) =>
+ +        {
+ +            true
+ +        },
+ +        ExprKind::Break(..)
+ +        | ExprKind::Continue(_)
+ +        | ExprKind::Ret(_)
+ +        | ExprKind::Yield(..)
+ +        | ExprKind::InlineAsm(_) => false,
+ +        // Accessing a field of a local value can only be done if the type isn't
+ +        // partially moved.
+ +        ExprKind::Field(
+ +            &Expr {
+ +                hir_id,
+ +                kind:
+ +                    ExprKind::Path(QPath::Resolved(
+ +                        _,
+ +                        Path {
+ +                            res: Res::Local(local_id),
+ +                            ..
+ +                        },
+ +                    )),
+ +                ..
+ +            },
+ +            _,
+ +        ) if !ignore_locals.contains(local_id) && can_partially_move_ty(cx, cx.typeck_results().node_type(hir_id)) => {
+ +            // TODO: check if the local has been partially moved. Assume it has for now.
+ +            false
+ +        },
+ +        _ => true,
+ +    }
+ +}
+ +
+ +/// How a local is captured by a closure
+ +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+ +pub enum CaptureKind {
+ +    Value,
+ +    Ref(Mutability),
+ +}
+ +impl CaptureKind {
+ +    pub fn is_imm_ref(self) -> bool {
+ +        self == Self::Ref(Mutability::Not)
+ +    }
+ +}
+ +impl std::ops::BitOr for CaptureKind {
+ +    type Output = Self;
+ +    fn bitor(self, rhs: Self) -> Self::Output {
+ +        match (self, rhs) {
+ +            (CaptureKind::Value, _) | (_, CaptureKind::Value) => CaptureKind::Value,
+ +            (CaptureKind::Ref(Mutability::Mut), CaptureKind::Ref(_))
+ +            | (CaptureKind::Ref(_), CaptureKind::Ref(Mutability::Mut)) => CaptureKind::Ref(Mutability::Mut),
+ +            (CaptureKind::Ref(Mutability::Not), CaptureKind::Ref(Mutability::Not)) => CaptureKind::Ref(Mutability::Not),
+ +        }
+ +    }
+ +}
+ +impl std::ops::BitOrAssign for CaptureKind {
+ +    fn bitor_assign(&mut self, rhs: Self) {
+ +        *self = *self | rhs;
+ +    }
+ +}
+ +
+ +/// Given an expression referencing a local, determines how it would be captured in a closure.
+ +/// Note as this will walk up to parent expressions until the capture can be determined it should
+ +/// only be used while making a closure somewhere a value is consumed. e.g. a block, match arm, or
+ +/// function argument (other than a receiver).
+ +pub fn capture_local_usage<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> CaptureKind {
+ +    fn pat_capture_kind(cx: &LateContext<'_>, pat: &Pat<'_>) -> CaptureKind {
+ +        let mut capture = CaptureKind::Ref(Mutability::Not);
+ +        pat.each_binding_or_first(&mut |_, id, span, _| match cx
+ +            .typeck_results()
+ +            .extract_binding_mode(cx.sess(), id, span)
+ +            .unwrap()
+ +        {
+ +            BindingMode::BindByValue(_) if !is_copy(cx, cx.typeck_results().node_type(id)) => {
+ +                capture = CaptureKind::Value;
+ +            },
+ +            BindingMode::BindByReference(Mutability::Mut) if capture != CaptureKind::Value => {
+ +                capture = CaptureKind::Ref(Mutability::Mut);
+ +            },
+ +            _ => (),
+ +        });
+ +        capture
+ +    }
+ +
+ +    debug_assert!(matches!(
+ +        e.kind,
+ +        ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(_), .. }))
+ +    ));
+ +
+ +    let mut child_id = e.hir_id;
+ +    let mut capture = CaptureKind::Value;
+ +    let mut capture_expr_ty = e;
+ +
+ +    for (parent_id, parent) in cx.tcx.hir().parent_iter(e.hir_id) {
+ +        if let [
+ +            Adjustment {
+ +                kind: Adjust::Deref(_) | Adjust::Borrow(AutoBorrow::Ref(..)),
+ +                target,
+ +            },
+ +            ref adjust @ ..,
+ +        ] = *cx
+ +            .typeck_results()
+ +            .adjustments()
+ +            .get(child_id)
+ +            .map_or(&[][..], |x| &**x)
+ +        {
+ +            if let rustc_ty::RawPtr(TypeAndMut { mutbl: mutability, .. }) | rustc_ty::Ref(_, _, mutability) =
+ +                *adjust.last().map_or(target, |a| a.target).kind()
+ +            {
+ +                return CaptureKind::Ref(mutability);
+ +            }
+ +        }
+ +
+ +        match parent {
+ +            Node::Expr(e) => match e.kind {
+ +                ExprKind::AddrOf(_, mutability, _) => return CaptureKind::Ref(mutability),
+ +                ExprKind::Index(..) | ExprKind::Unary(UnOp::Deref, _) => capture = CaptureKind::Ref(Mutability::Not),
+ +                ExprKind::Assign(lhs, ..) | ExprKind::Assign(_, lhs, _) if lhs.hir_id == child_id => {
+ +                    return CaptureKind::Ref(Mutability::Mut);
+ +                },
+ +                ExprKind::Field(..) => {
+ +                    if capture == CaptureKind::Value {
+ +                        capture_expr_ty = e;
+ +                    }
+ +                },
+ +                ExprKind::Let(let_expr) => {
+ +                    let mutability = match pat_capture_kind(cx, let_expr.pat) {
+ +                        CaptureKind::Value => Mutability::Not,
+ +                        CaptureKind::Ref(m) => m,
+ +                    };
+ +                    return CaptureKind::Ref(mutability);
+ +                },
+ +                ExprKind::Match(_, arms, _) => {
+ +                    let mut mutability = Mutability::Not;
+ +                    for capture in arms.iter().map(|arm| pat_capture_kind(cx, arm.pat)) {
+ +                        match capture {
+ +                            CaptureKind::Value => break,
+ +                            CaptureKind::Ref(Mutability::Mut) => mutability = Mutability::Mut,
+ +                            CaptureKind::Ref(Mutability::Not) => (),
+ +                        }
+ +                    }
+ +                    return CaptureKind::Ref(mutability);
+ +                },
+ +                _ => break,
+ +            },
+ +            Node::Local(l) => match pat_capture_kind(cx, l.pat) {
+ +                CaptureKind::Value => break,
+ +                capture @ CaptureKind::Ref(_) => return capture,
+ +            },
+ +            _ => break,
+ +        }
+ +
+ +        child_id = parent_id;
+ +    }
+ +
+ +    if capture == CaptureKind::Value && is_copy(cx, cx.typeck_results().expr_ty(capture_expr_ty)) {
+ +        // Copy types are never automatically captured by value.
+ +        CaptureKind::Ref(Mutability::Not)
+ +    } else {
+ +        capture
+ +    }
+ +}
+ +
+ +/// Checks if the expression can be moved into a closure as is. This will return a list of captures
+ +/// if so, otherwise, `None`.
+ +pub fn can_move_expr_to_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<HirIdMap<CaptureKind>> {
+ +    struct V<'cx, 'tcx> {
+ +        cx: &'cx LateContext<'tcx>,
+ +        // Stack of potential break targets contained in the expression.
+ +        loops: Vec<HirId>,
+ +        /// Local variables created in the expression. These don't need to be captured.
+ +        locals: HirIdSet,
+ +        /// Whether this expression can be turned into a closure.
+ +        allow_closure: bool,
+ +        /// Locals which need to be captured, and whether they need to be by value, reference, or
+ +        /// mutable reference.
+ +        captures: HirIdMap<CaptureKind>,
+ +    }
+ +    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
+ +        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
+ +            if !self.allow_closure {
+ +                return;
+ +            }
+ +
+ +            match e.kind {
+ +                ExprKind::Path(QPath::Resolved(None, &Path { res: Res::Local(l), .. })) => {
+ +                    if !self.locals.contains(&l) {
+ +                        let cap = capture_local_usage(self.cx, e);
+ +                        self.captures.entry(l).and_modify(|e| *e |= cap).or_insert(cap);
+ +                    }
+ +                },
+ +                ExprKind::Closure(..) => {
+ +                    let closure_id = self.cx.tcx.hir().local_def_id(e.hir_id).to_def_id();
+ +                    for capture in self.cx.typeck_results().closure_min_captures_flattened(closure_id) {
+ +                        let local_id = match capture.place.base {
+ +                            PlaceBase::Local(id) => id,
+ +                            PlaceBase::Upvar(var) => var.var_path.hir_id,
+ +                            _ => continue,
+ +                        };
+ +                        if !self.locals.contains(&local_id) {
+ +                            let capture = match capture.info.capture_kind {
+ +                                UpvarCapture::ByValue => CaptureKind::Value,
+ +                                UpvarCapture::ByRef(kind) => match kind {
+ +                                    BorrowKind::ImmBorrow => CaptureKind::Ref(Mutability::Not),
+ +                                    BorrowKind::UniqueImmBorrow | BorrowKind::MutBorrow => {
+ +                                        CaptureKind::Ref(Mutability::Mut)
+ +                                    },
+ +                                },
+ +                            };
+ +                            self.captures
+ +                                .entry(local_id)
+ +                                .and_modify(|e| *e |= capture)
+ +                                .or_insert(capture);
+ +                        }
+ +                    }
+ +                },
+ +                ExprKind::Loop(b, ..) => {
+ +                    self.loops.push(e.hir_id);
+ +                    self.visit_block(b);
+ +                    self.loops.pop();
+ +                },
+ +                _ => {
+ +                    self.allow_closure &= can_move_expr_to_closure_no_visit(self.cx, e, &self.loops, &self.locals);
+ +                    walk_expr(self, e);
+ +                },
+ +            }
+ +        }
+ +
+ +        fn visit_pat(&mut self, p: &'tcx Pat<'tcx>) {
+ +            p.each_binding_or_first(&mut |_, id, _, _| {
+ +                self.locals.insert(id);
+ +            });
+ +        }
+ +    }
+ +
+ +    let mut v = V {
+ +        cx,
+ +        allow_closure: true,
+ +        loops: Vec::new(),
+ +        locals: HirIdSet::default(),
+ +        captures: HirIdMap::default(),
+ +    };
+ +    v.visit_expr(expr);
+ +    v.allow_closure.then(|| v.captures)
+ +}
+ +
+ +/// Returns the method names and argument list of nested method call expressions that make up
+ +/// `expr`. method/span lists are sorted with the most recent call first.
+ +pub fn method_calls<'tcx>(
+ +    expr: &'tcx Expr<'tcx>,
+ +    max_depth: usize,
+ +) -> (Vec<Symbol>, Vec<&'tcx [Expr<'tcx>]>, Vec<Span>) {
+ +    let mut method_names = Vec::with_capacity(max_depth);
+ +    let mut arg_lists = Vec::with_capacity(max_depth);
+ +    let mut spans = Vec::with_capacity(max_depth);
+ +
+ +    let mut current = expr;
+ +    for _ in 0..max_depth {
+ +        if let ExprKind::MethodCall(path, args, _) = &current.kind {
+ +            if args.iter().any(|e| e.span.from_expansion()) {
+ +                break;
+ +            }
+ +            method_names.push(path.ident.name);
+ +            arg_lists.push(&**args);
+ +            spans.push(path.ident.span);
+ +            current = &args[0];
+ +        } else {
+ +            break;
+ +        }
+ +    }
+ +
+ +    (method_names, arg_lists, spans)
+ +}
+ +
+ +/// Matches an `Expr` against a chain of methods, and return the matched `Expr`s.
+ +///
+ +/// For example, if `expr` represents the `.baz()` in `foo.bar().baz()`,
+ +/// `method_chain_args(expr, &["bar", "baz"])` will return a `Vec`
+ +/// containing the `Expr`s for
+ +/// `.bar()` and `.baz()`
+ +pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec<&'a [Expr<'a>]>> {
+ +    let mut current = expr;
+ +    let mut matched = Vec::with_capacity(methods.len());
+ +    for method_name in methods.iter().rev() {
+ +        // method chains are stored last -> first
+ +        if let ExprKind::MethodCall(path, args, _) = current.kind {
+ +            if path.ident.name.as_str() == *method_name {
+ +                if args.iter().any(|e| e.span.from_expansion()) {
+ +                    return None;
+ +                }
+ +                matched.push(args); // build up `matched` backwards
+ +                current = &args[0]; // go to parent expression
+ +            } else {
+ +                return None;
+ +            }
+ +        } else {
+ +            return None;
+ +        }
+ +    }
+ +    // Reverse `matched` so that it is in the same order as `methods`.
+ +    matched.reverse();
+ +    Some(matched)
+ +}
+ +
+ +/// Returns `true` if the provided `def_id` is an entrypoint to a program.
+ +pub fn is_entrypoint_fn(cx: &LateContext<'_>, def_id: DefId) -> bool {
+ +    cx.tcx
+ +        .entry_fn(())
+ +        .map_or(false, |(entry_fn_def_id, _)| def_id == entry_fn_def_id)
+ +}
+ +
+ +/// Returns `true` if the expression is in the program's `#[panic_handler]`.
+ +pub fn is_in_panic_handler(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+ +    let parent = cx.tcx.hir().get_parent_item(e.hir_id);
+ +    Some(parent.to_def_id()) == cx.tcx.lang_items().panic_impl()
+ +}
+ +
+ +/// Gets the name of the item the expression is in, if available.
+ +pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
+ +    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id);
+ +    match cx.tcx.hir().find_by_def_id(parent_id) {
+ +        Some(
+ +            Node::Item(Item { ident, .. })
+ +            | Node::TraitItem(TraitItem { ident, .. })
+ +            | Node::ImplItem(ImplItem { ident, .. }),
+ +        ) => Some(ident.name),
+ +        _ => None,
+ +    }
+ +}
+ +
+ +pub struct ContainsName {
+ +    pub name: Symbol,
+ +    pub result: bool,
+ +}
+ +
+ +impl<'tcx> Visitor<'tcx> for ContainsName {
+ +    fn visit_name(&mut self, _: Span, name: Symbol) {
+ +        if self.name == name {
+ +            self.result = true;
+ +        }
+ +    }
+ +}
+ +
+ +/// Checks if an `Expr` contains a certain name.
+ +pub fn contains_name(name: Symbol, expr: &Expr<'_>) -> bool {
+ +    let mut cn = ContainsName { name, result: false };
+ +    cn.visit_expr(expr);
+ +    cn.result
+ +}
+ +
+ +/// Returns `true` if `expr` contains a return expression
+ +pub fn contains_return(expr: &hir::Expr<'_>) -> bool {
+ +    let mut found = false;
+ +    expr_visitor_no_bodies(|expr| {
+ +        if !found {
+ +            if let hir::ExprKind::Ret(..) = &expr.kind {
+ +                found = true;
+ +            }
+ +        }
+ +        !found
+ +    })
+ +    .visit_expr(expr);
+ +    found
+ +}
+ +
+ +/// Extends the span to the beginning of the spans line, incl. whitespaces.
+ +///
+ +/// ```rust
+ +///        let x = ();
+ +/// //             ^^
+ +/// // will be converted to
+ +///        let x = ();
+ +/// // ^^^^^^^^^^^^^^
+ +/// ```
+ +fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
+ +    let span = original_sp(span, DUMMY_SP);
+ +    let source_map_and_line = cx.sess().source_map().lookup_line(span.lo()).unwrap();
+ +    let line_no = source_map_and_line.line;
+ +    let line_start = source_map_and_line.sf.lines[line_no];
+ +    span.with_lo(line_start)
+ +}
+ +
+ +/// Gets the parent node, if any.
+ +pub fn get_parent_node(tcx: TyCtxt<'_>, id: HirId) -> Option<Node<'_>> {
+ +    tcx.hir().parent_iter(id).next().map(|(_, node)| node)
+ +}
+ +
+ +/// Gets the parent expression, if any –- this is useful to constrain a lint.
+ +pub fn get_parent_expr<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+ +    get_parent_expr_for_hir(cx, e.hir_id)
+ +}
+ +
+ +/// This retrieves the parent for the given `HirId` if it's an expression. This is useful for
+ +/// constraint lints
+ +pub fn get_parent_expr_for_hir<'tcx>(cx: &LateContext<'tcx>, hir_id: hir::HirId) -> Option<&'tcx Expr<'tcx>> {
+ +    match get_parent_node(cx.tcx, hir_id) {
+ +        Some(Node::Expr(parent)) => Some(parent),
+ +        _ => None,
+ +    }
+ +}
+ +
+ +pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Block<'tcx>> {
+ +    let map = &cx.tcx.hir();
+ +    let enclosing_node = map
+ +        .get_enclosing_scope(hir_id)
+ +        .and_then(|enclosing_id| map.find(enclosing_id));
+ +    enclosing_node.and_then(|node| match node {
+ +        Node::Block(block) => Some(block),
+ +        Node::Item(&Item {
+ +            kind: ItemKind::Fn(_, _, eid),
+ +            ..
+ +        })
+ +        | Node::ImplItem(&ImplItem {
+ +            kind: ImplItemKind::Fn(_, eid),
+ +            ..
+ +        }) => match cx.tcx.hir().body(eid).value.kind {
+ +            ExprKind::Block(block, _) => Some(block),
+ +            _ => None,
+ +        },
+ +        _ => None,
+ +    })
+ +}
+ +
+ +/// Gets the loop or closure enclosing the given expression, if any.
+ +pub fn get_enclosing_loop_or_closure<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+ +    for (_, node) in tcx.hir().parent_iter(expr.hir_id) {
+ +        match node {
+ +            Node::Expr(
+ +                e @ Expr {
+ +                    kind: ExprKind::Loop(..) | ExprKind::Closure(..),
+ +                    ..
+ +                },
+ +            ) => return Some(e),
+ +            Node::Expr(_) | Node::Stmt(_) | Node::Block(_) | Node::Local(_) | Node::Arm(_) => (),
+ +            _ => break,
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +/// Gets the parent node if it's an impl block.
+ +pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
+ +    match tcx.hir().parent_iter(id).next() {
+ +        Some((
+ +            _,
+ +            Node::Item(Item {
+ +                kind: ItemKind::Impl(imp),
+ +                ..
+ +            }),
+ +        )) => Some(imp),
+ +        _ => None,
+ +    }
+ +}
+ +
+ +/// Removes blocks around an expression, only if the block contains just one expression
+ +/// and no statements. Unsafe blocks are not removed.
+ +///
+ +/// Examples:
+ +///  * `{}`               -> `{}`
+ +///  * `{ x }`            -> `x`
+ +///  * `{{ x }}`          -> `x`
+ +///  * `{ x; }`           -> `{ x; }`
+ +///  * `{ x; y }`         -> `{ x; y }`
+ +///  * `{ unsafe { x } }` -> `unsafe { x }`
+ +pub fn peel_blocks<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
+ +    while let ExprKind::Block(
+ +        Block {
+ +            stmts: [],
+ +            expr: Some(inner),
+ +            rules: BlockCheckMode::DefaultBlock,
+ +            ..
+ +        },
+ +        _,
+ +    ) = expr.kind
+ +    {
+ +        expr = inner;
+ +    }
+ +    expr
+ +}
+ +
+ +/// Removes blocks around an expression, only if the block contains just one expression
+ +/// or just one expression statement with a semicolon. Unsafe blocks are not removed.
+ +///
+ +/// Examples:
+ +///  * `{}`               -> `{}`
+ +///  * `{ x }`            -> `x`
+ +///  * `{ x; }`           -> `x`
+ +///  * `{{ x; }}`         -> `x`
+ +///  * `{ x; y }`         -> `{ x; y }`
+ +///  * `{ unsafe { x } }` -> `unsafe { x }`
+ +pub fn peel_blocks_with_stmt<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
+ +    while let ExprKind::Block(
+ +        Block {
+ +            stmts: [],
+ +            expr: Some(inner),
+ +            rules: BlockCheckMode::DefaultBlock,
+ +            ..
+ +        }
+ +        | Block {
+ +            stmts:
+ +                [
+ +                    Stmt {
+ +                        kind: StmtKind::Expr(inner) | StmtKind::Semi(inner),
+ +                        ..
+ +                    },
+ +                ],
+ +            expr: None,
+ +            rules: BlockCheckMode::DefaultBlock,
+ +            ..
+ +        },
+ +        _,
+ +    ) = expr.kind
+ +    {
+ +        expr = inner;
+ +    }
+ +    expr
+ +}
+ +
+ +/// Checks if the given expression is the else clause of either an `if` or `if let` expression.
+ +pub fn is_else_clause(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+ +    let mut iter = tcx.hir().parent_iter(expr.hir_id);
+ +    match iter.next() {
+ +        Some((
+ +            _,
+ +            Node::Expr(Expr {
+ +                kind: ExprKind::If(_, _, Some(else_expr)),
+ +                ..
+ +            }),
+ +        )) => else_expr.hir_id == expr.hir_id,
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Checks whether the given expression is a constant integer of the given value.
+ +/// unlike `is_integer_literal`, this version does const folding
+ +pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool {
+ +    if is_integer_literal(e, value) {
+ +        return true;
+ +    }
+ +    let enclosing_body = cx.tcx.hir().local_def_id(cx.tcx.hir().enclosing_body_owner(e.hir_id));
+ +    if let Some((Constant::Int(v), _)) = constant(cx, cx.tcx.typeck(enclosing_body), e) {
+ +        return value == v;
+ +    }
+ +    false
+ +}
+ +
+ +/// Checks whether the given expression is a constant literal of the given value.
+ +pub fn is_integer_literal(expr: &Expr<'_>, value: u128) -> bool {
+ +    // FIXME: use constant folding
+ +    if let ExprKind::Lit(ref spanned) = expr.kind {
+ +        if let LitKind::Int(v, _) = spanned.node {
+ +            return v == value;
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +/// Returns `true` if the given `Expr` has been coerced before.
+ +///
+ +/// Examples of coercions can be found in the Nomicon at
+ +/// <https://doc.rust-lang.org/nomicon/coercions.html>.
+ +///
+ +/// See `rustc_middle::ty::adjustment::Adjustment` and `rustc_typeck::check::coercion` for more
+ +/// information on adjustments and coercions.
+ +pub fn is_adjusted(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
+ +    cx.typeck_results().adjustments().get(e.hir_id).is_some()
+ +}
+ +
+ +/// Returns the pre-expansion span if this comes from an expansion of the
+ +/// macro `name`.
+ +/// See also [`is_direct_expn_of`].
+ +#[must_use]
+ +pub fn is_expn_of(mut span: Span, name: &str) -> Option<Span> {
+ +    loop {
+ +        if span.from_expansion() {
+ +            let data = span.ctxt().outer_expn_data();
+ +            let new_span = data.call_site;
+ +
+ +            if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
+ +                if mac_name.as_str() == name {
+ +                    return Some(new_span);
+ +                }
+ +            }
+ +
+ +            span = new_span;
+ +        } else {
+ +            return None;
+ +        }
+ +    }
+ +}
+ +
+ +/// Returns the pre-expansion span if the span directly comes from an expansion
+ +/// of the macro `name`.
+ +/// The difference with [`is_expn_of`] is that in
+ +/// ```rust
+ +/// # macro_rules! foo { ($name:tt!$args:tt) => { $name!$args } }
+ +/// # macro_rules! bar { ($e:expr) => { $e } }
+ +/// foo!(bar!(42));
+ +/// ```
+ +/// `42` is considered expanded from `foo!` and `bar!` by `is_expn_of` but only
+ +/// from `bar!` by `is_direct_expn_of`.
+ +#[must_use]
+ +pub fn is_direct_expn_of(span: Span, name: &str) -> Option<Span> {
+ +    if span.from_expansion() {
+ +        let data = span.ctxt().outer_expn_data();
+ +        let new_span = data.call_site;
+ +
+ +        if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
+ +            if mac_name.as_str() == name {
+ +                return Some(new_span);
+ +            }
+ +        }
+ +    }
+ +
+ +    None
+ +}
+ +
+ +/// Convenience function to get the return type of a function.
+ +pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId) -> Ty<'tcx> {
+ +    let fn_def_id = cx.tcx.hir().local_def_id(fn_item);
+ +    let ret_ty = cx.tcx.fn_sig(fn_def_id).output();
+ +    cx.tcx.erase_late_bound_regions(ret_ty)
+ +}
+ +
+ +/// Convenience function to get the nth argument type of a function.
+ +pub fn nth_arg<'tcx>(cx: &LateContext<'tcx>, fn_item: hir::HirId, nth: usize) -> Ty<'tcx> {
+ +    let fn_def_id = cx.tcx.hir().local_def_id(fn_item);
+ +    let arg = cx.tcx.fn_sig(fn_def_id).input(nth);
+ +    cx.tcx.erase_late_bound_regions(arg)
+ +}
+ +
+ +/// Checks if an expression is constructing a tuple-like enum variant or struct
+ +pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    if let ExprKind::Call(fun, _) = expr.kind {
+ +        if let ExprKind::Path(ref qp) = fun.kind {
+ +            let res = cx.qpath_res(qp, fun.hir_id);
+ +            return match res {
+ +                def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
+ +                def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
+ +                _ => false,
+ +            };
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +/// Returns `true` if a pattern is refutable.
+ +// TODO: should be implemented using rustc/mir_build/thir machinery
+ +pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
+ +    fn is_enum_variant(cx: &LateContext<'_>, qpath: &QPath<'_>, id: HirId) -> bool {
+ +        matches!(
+ +            cx.qpath_res(qpath, id),
+ +            def::Res::Def(DefKind::Variant, ..) | Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), _)
+ +        )
+ +    }
+ +
+ +    fn are_refutable<'a, I: IntoIterator<Item = &'a Pat<'a>>>(cx: &LateContext<'_>, i: I) -> bool {
+ +        i.into_iter().any(|pat| is_refutable(cx, pat))
+ +    }
+ +
+ +    match pat.kind {
+ +        PatKind::Wild => false,
+ +        PatKind::Binding(_, _, _, pat) => pat.map_or(false, |pat| is_refutable(cx, pat)),
+ +        PatKind::Box(pat) | PatKind::Ref(pat, _) => is_refutable(cx, pat),
+ +        PatKind::Lit(..) | PatKind::Range(..) => true,
+ +        PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.hir_id),
+ +        PatKind::Or(pats) => {
+ +            // TODO: should be the honest check, that pats is exhaustive set
+ +            are_refutable(cx, pats)
+ +        },
+ +        PatKind::Tuple(pats, _) => are_refutable(cx, pats),
+ +        PatKind::Struct(ref qpath, fields, _) => {
+ +            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| &*field.pat))
+ +        },
+ +        PatKind::TupleStruct(ref qpath, pats, _) => is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats),
+ +        PatKind::Slice(head, middle, tail) => {
+ +            match &cx.typeck_results().node_type(pat.hir_id).kind() {
+ +                rustc_ty::Slice(..) => {
+ +                    // [..] is the only irrefutable slice pattern.
+ +                    !head.is_empty() || middle.is_none() || !tail.is_empty()
+ +                },
+ +                rustc_ty::Array(..) => are_refutable(cx, head.iter().chain(middle).chain(tail.iter())),
+ +                _ => {
+ +                    // unreachable!()
+ +                    true
+ +                },
+ +            }
+ +        },
+ +    }
+ +}
+ +
+ +/// If the pattern is an `or` pattern, call the function once for each sub pattern. Otherwise, call
+ +/// the function once on the given pattern.
+ +pub fn recurse_or_patterns<'tcx, F: FnMut(&'tcx Pat<'tcx>)>(pat: &'tcx Pat<'tcx>, mut f: F) {
+ +    if let PatKind::Or(pats) = pat.kind {
+ +        pats.iter().for_each(f);
+ +    } else {
+ +        f(pat);
+ +    }
+ +}
+ +
+ +/// Checks for the `#[automatically_derived]` attribute all `#[derive]`d
+ +/// implementations have.
+ +pub fn is_automatically_derived(attrs: &[ast::Attribute]) -> bool {
+ +    has_attr(attrs, sym::automatically_derived)
+ +}
+ +
+ +pub fn is_self(slf: &Param<'_>) -> bool {
+ +    if let PatKind::Binding(.., name, _) = slf.pat.kind {
+ +        name.name == kw::SelfLower
+ +    } else {
+ +        false
+ +    }
+ +}
+ +
+ +pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
+ +    if let TyKind::Path(QPath::Resolved(None, path)) = slf.kind {
+ +        if let Res::SelfTy(..) = path.res {
+ +            return true;
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl Iterator<Item = &'tcx Param<'tcx>> {
+ +    (0..decl.inputs.len()).map(move |i| &body.params[i])
+ +}
+ +
+ +/// Checks if a given expression is a match expression expanded from the `?`
+ +/// operator or the `try` macro.
+ +pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
+ +    fn is_ok(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+ +        if_chain! {
+ +            if let PatKind::TupleStruct(ref path, pat, None) = arm.pat.kind;
+ +            if is_lang_ctor(cx, path, ResultOk);
+ +            if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
+ +            if path_to_local_id(arm.body, hir_id);
+ +            then {
+ +                return true;
+ +            }
+ +        }
+ +        false
+ +    }
+ +
+ +    fn is_err(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
+ +        if let PatKind::TupleStruct(ref path, _, _) = arm.pat.kind {
+ +            is_lang_ctor(cx, path, ResultErr)
+ +        } else {
+ +            false
+ +        }
+ +    }
+ +
+ +    if let ExprKind::Match(_, arms, ref source) = expr.kind {
+ +        // desugared from a `?` operator
+ +        if *source == MatchSource::TryDesugar {
+ +            return Some(expr);
+ +        }
+ +
+ +        if_chain! {
+ +            if arms.len() == 2;
+ +            if arms[0].guard.is_none();
+ +            if arms[1].guard.is_none();
-             return Some(args)
++            if (is_ok(cx, &arms[0]) && is_err(cx, &arms[1])) || (is_ok(cx, &arms[1]) && is_err(cx, &arms[0]));
+ +            then {
+ +                return Some(expr);
+ +            }
+ +        }
+ +    }
+ +
+ +    None
+ +}
+ +
+ +/// Returns `true` if the lint is allowed in the current context
+ +///
+ +/// Useful for skipping long running code when it's unnecessary
+ +pub fn is_lint_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool {
+ +    cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
+ +}
+ +
+ +pub fn strip_pat_refs<'hir>(mut pat: &'hir Pat<'hir>) -> &'hir Pat<'hir> {
+ +    while let PatKind::Ref(subpat, _) = pat.kind {
+ +        pat = subpat;
+ +    }
+ +    pat
+ +}
+ +
+ +pub fn int_bits(tcx: TyCtxt<'_>, ity: rustc_ty::IntTy) -> u64 {
+ +    Integer::from_int_ty(&tcx, ity).size().bits()
+ +}
+ +
+ +#[allow(clippy::cast_possible_wrap)]
+ +/// Turn a constant int byte representation into an i128
+ +pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::IntTy) -> i128 {
+ +    let amt = 128 - int_bits(tcx, ity);
+ +    ((u as i128) << amt) >> amt
+ +}
+ +
+ +#[allow(clippy::cast_sign_loss)]
+ +/// clip unused bytes
+ +pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: rustc_ty::IntTy) -> u128 {
+ +    let amt = 128 - int_bits(tcx, ity);
+ +    ((u as u128) << amt) >> amt
+ +}
+ +
+ +/// clip unused bytes
+ +pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::UintTy) -> u128 {
+ +    let bits = Integer::from_uint_ty(&tcx, ity).size().bits();
+ +    let amt = 128 - bits;
+ +    (u << amt) >> amt
+ +}
+ +
+ +pub fn has_attr(attrs: &[ast::Attribute], symbol: Symbol) -> bool {
+ +    attrs.iter().any(|attr| attr.has_name(symbol))
+ +}
+ +
+ +pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
+ +    let map = &tcx.hir();
+ +    let mut prev_enclosing_node = None;
+ +    let mut enclosing_node = node;
+ +    while Some(enclosing_node) != prev_enclosing_node {
+ +        if has_attr(map.attrs(enclosing_node), symbol) {
+ +            return true;
+ +        }
+ +        prev_enclosing_node = Some(enclosing_node);
+ +        enclosing_node = map.local_def_id_to_hir_id(map.get_parent_item(enclosing_node));
+ +    }
+ +
+ +    false
+ +}
+ +
+ +pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_>, node: HirId) -> bool {
+ +    any_parent_has_attr(tcx, node, sym::automatically_derived)
+ +}
+ +
+ +/// Matches a function call with the given path and returns the arguments.
+ +///
+ +/// Usage:
+ +///
+ +/// ```rust,ignore
+ +/// if let Some(args) = match_function_call(cx, cmp_max_call, &paths::CMP_MAX);
+ +/// ```
+ +pub fn match_function_call<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    expr: &'tcx Expr<'_>,
+ +    path: &[&str],
+ +) -> Option<&'tcx [Expr<'tcx>]> {
+ +    if_chain! {
+ +        if let ExprKind::Call(fun, args) = expr.kind;
+ +        if let ExprKind::Path(ref qpath) = fun.kind;
+ +        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
+ +        if match_def_path(cx, fun_def_id, path);
+ +        then {
- /// Please use `match_any_diagnostic_items` if the targets are all diagnostic items.
++            return Some(args);
+ +        }
+ +    };
+ +    None
+ +}
+ +
+ +/// Checks if the given `DefId` matches any of the paths. Returns the index of matching path, if
+ +/// any.
+ +///
- /// Checks if the given `DefId` matches any of provided diagnostic items. Returns the index of
- /// matching path, if any.
- pub fn match_any_diagnostic_items(cx: &LateContext<'_>, def_id: DefId, diag_items: &[Symbol]) -> Option<usize> {
-     diag_items
-         .iter()
-         .position(|item| cx.tcx.is_diagnostic_item(*item, def_id))
- }
- 
++/// Please use `tcx.get_diagnostic_name` if the targets are all diagnostic items.
+ +pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]]) -> Option<usize> {
+ +    let search_path = cx.get_def_path(did);
+ +    paths
+ +        .iter()
+ +        .position(|p| p.iter().map(|x| Symbol::intern(x)).eq(search_path.iter().copied()))
+ +}
+ +
-         ExprKind::Path(ref path) => is_qpath_def_path(cx, path, expr.hir_id, &paths::CONVERT_IDENTITY),
-         _ => false,
+ +/// Checks if the given `DefId` matches the path.
+ +pub fn match_def_path<'tcx>(cx: &LateContext<'tcx>, did: DefId, syms: &[&str]) -> bool {
+ +    // We should probably move to Symbols in Clippy as well rather than interning every time.
+ +    let path = cx.get_def_path(did);
+ +    syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().copied())
+ +}
+ +
+ +/// Checks if the given `DefId` matches the `libc` item.
+ +pub fn match_libc_symbol(cx: &LateContext<'_>, did: DefId, name: &str) -> bool {
+ +    let path = cx.get_def_path(did);
+ +    // libc is meant to be used as a flat list of names, but they're all actually defined in different
+ +    // modules based on the target platform. Ignore everything but crate name and the item name.
+ +    path.first().map_or(false, |s| s.as_str() == "libc") && path.last().map_or(false, |s| s.as_str() == name)
+ +}
+ +
+ +/// Returns the list of condition expressions and the list of blocks in a
+ +/// sequence of `if/else`.
+ +/// E.g., this returns `([a, b], [c, d, e])` for the expression
+ +/// `if a { c } else if b { d } else { e }`.
+ +pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>, Vec<&'tcx Block<'tcx>>) {
+ +    let mut conds = Vec::new();
+ +    let mut blocks: Vec<&Block<'_>> = Vec::new();
+ +
+ +    while let Some(higher::IfOrIfLet { cond, then, r#else }) = higher::IfOrIfLet::hir(expr) {
+ +        conds.push(&*cond);
+ +        if let ExprKind::Block(block, _) = then.kind {
+ +            blocks.push(block);
+ +        } else {
+ +            panic!("ExprKind::If node is not an ExprKind::Block");
+ +        }
+ +
+ +        if let Some(else_expr) = r#else {
+ +            expr = else_expr;
+ +        } else {
+ +            break;
+ +        }
+ +    }
+ +
+ +    // final `else {..}`
+ +    if !blocks.is_empty() {
+ +        if let ExprKind::Block(block, _) = expr.kind {
+ +            blocks.push(block);
+ +        }
+ +    }
+ +
+ +    (conds, blocks)
+ +}
+ +
+ +/// Checks if the given function kind is an async function.
+ +pub fn is_async_fn(kind: FnKind<'_>) -> bool {
+ +    matches!(kind, FnKind::ItemFn(_, _, header, _) if header.asyncness == IsAsync::Async)
+ +}
+ +
+ +/// Peels away all the compiler generated code surrounding the body of an async function,
+ +pub fn get_async_fn_body<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'tcx Expr<'tcx>> {
+ +    if let ExprKind::Call(
+ +        _,
+ +        &[
+ +            Expr {
+ +                kind: ExprKind::Closure(_, _, body, _, _),
+ +                ..
+ +            },
+ +        ],
+ +    ) = body.value.kind
+ +    {
+ +        if let ExprKind::Block(
+ +            Block {
+ +                stmts: [],
+ +                expr:
+ +                    Some(Expr {
+ +                        kind: ExprKind::DropTemps(expr),
+ +                        ..
+ +                    }),
+ +                ..
+ +            },
+ +            _,
+ +        ) = tcx.hir().body(body).value.kind
+ +        {
+ +            return Some(expr);
+ +        }
+ +    };
+ +    None
+ +}
+ +
+ +// Finds the `#[must_use]` attribute, if any
+ +pub fn must_use_attr(attrs: &[Attribute]) -> Option<&Attribute> {
+ +    attrs.iter().find(|a| a.has_name(sym::must_use))
+ +}
+ +
+ +// check if expr is calling method or function with #[must_use] attribute
+ +pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    let did = match expr.kind {
+ +        ExprKind::Call(path, _) => if_chain! {
+ +            if let ExprKind::Path(ref qpath) = path.kind;
+ +            if let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id);
+ +            then {
+ +                Some(did)
+ +            } else {
+ +                None
+ +            }
+ +        },
+ +        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
+ +        _ => None,
+ +    };
+ +
+ +    did.map_or(false, |did| must_use_attr(cx.tcx.get_attrs(did)).is_some())
+ +}
+ +
+ +/// Checks if an expression represents the identity function
+ +/// Only examines closures and `std::convert::identity`
+ +pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ +    /// Checks if a function's body represents the identity function. Looks for bodies of the form:
+ +    /// * `|x| x`
+ +    /// * `|x| return x`
+ +    /// * `|x| { return x }`
+ +    /// * `|x| { return x; }`
+ +    fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
+ +        let id = if_chain! {
+ +            if let [param] = func.params;
+ +            if let PatKind::Binding(_, id, _, _) = param.pat.kind;
+ +            then {
+ +                id
+ +            } else {
+ +                return false;
+ +            }
+ +        };
+ +
+ +        let mut expr = &func.value;
+ +        loop {
+ +            match expr.kind {
+ +                #[rustfmt::skip]
+ +                ExprKind::Block(&Block { stmts: [], expr: Some(e), .. }, _, )
+ +                | ExprKind::Ret(Some(e)) => expr = e,
+ +                #[rustfmt::skip]
+ +                ExprKind::Block(&Block { stmts: [stmt], expr: None, .. }, _) => {
+ +                    if_chain! {
+ +                        if let StmtKind::Semi(e) | StmtKind::Expr(e) = stmt.kind;
+ +                        if let ExprKind::Ret(Some(ret_val)) = e.kind;
+ +                        then {
+ +                            expr = ret_val;
+ +                        } else {
+ +                            return false;
+ +                        }
+ +                    }
+ +                },
+ +                _ => return path_to_local_id(expr, id) && cx.typeck_results().expr_adjustments(expr).is_empty(),
+ +            }
+ +        }
+ +    }
+ +
+ +    match expr.kind {
+ +        ExprKind::Closure(_, _, body_id, _, _) => is_body_identity_function(cx, cx.tcx.hir().body(body_id)),
- /// Note: If you use this function, please add a `#[test]` case in `tests/ui_test`.
++        _ => path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, &paths::CONVERT_IDENTITY)),
+ +    }
+ +}
+ +
+ +/// Gets the node where an expression is either used, or it's type is unified with another branch.
+ +/// Returns both the node and the `HirId` of the closest child node.
+ +pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<(Node<'tcx>, HirId)> {
+ +    let mut child_id = expr.hir_id;
+ +    let mut iter = tcx.hir().parent_iter(child_id);
+ +    loop {
+ +        match iter.next() {
+ +            None => break None,
+ +            Some((id, Node::Block(_))) => child_id = id,
+ +            Some((id, Node::Arm(arm))) if arm.body.hir_id == child_id => child_id = id,
+ +            Some((_, Node::Expr(expr))) => match expr.kind {
+ +                ExprKind::Match(_, [arm], _) if arm.hir_id == child_id => child_id = expr.hir_id,
+ +                ExprKind::Block(..) | ExprKind::DropTemps(_) => child_id = expr.hir_id,
+ +                ExprKind::If(_, then_expr, None) if then_expr.hir_id == child_id => break None,
+ +                _ => break Some((Node::Expr(expr), child_id)),
+ +            },
+ +            Some((_, node)) => break Some((node, child_id)),
+ +        }
+ +    }
+ +}
+ +
+ +/// Checks if the result of an expression is used, or it's type is unified with another branch.
+ +pub fn is_expr_used_or_unified(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+ +    !matches!(
+ +        get_expr_use_or_unification_node(tcx, expr),
+ +        None | Some((
+ +            Node::Stmt(Stmt {
+ +                kind: StmtKind::Expr(_)
+ +                    | StmtKind::Semi(_)
+ +                    | StmtKind::Local(Local {
+ +                        pat: Pat {
+ +                            kind: PatKind::Wild,
+ +                            ..
+ +                        },
+ +                        ..
+ +                    }),
+ +                ..
+ +            }),
+ +            _
+ +        ))
+ +    )
+ +}
+ +
+ +/// Checks if the expression is the final expression returned from a block.
+ +pub fn is_expr_final_block_expr(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
+ +    matches!(get_parent_node(tcx, expr.hir_id), Some(Node::Block(..)))
+ +}
+ +
+ +pub fn std_or_core(cx: &LateContext<'_>) -> Option<&'static str> {
+ +    if !is_no_std_crate(cx) {
+ +        Some("std")
+ +    } else if !is_no_core_crate(cx) {
+ +        Some("core")
+ +    } else {
+ +        None
+ +    }
+ +}
+ +
+ +pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
+ +    cx.tcx.hir().attrs(hir::CRATE_HIR_ID).iter().any(|attr| {
+ +        if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
+ +            attr.path == sym::no_std
+ +        } else {
+ +            false
+ +        }
+ +    })
+ +}
+ +
+ +pub fn is_no_core_crate(cx: &LateContext<'_>) -> bool {
+ +    cx.tcx.hir().attrs(hir::CRATE_HIR_ID).iter().any(|attr| {
+ +        if let ast::AttrKind::Normal(ref attr, _) = attr.kind {
+ +            attr.path == sym::no_core
+ +        } else {
+ +            false
+ +        }
+ +    })
+ +}
+ +
+ +/// Check if parent of a hir node is a trait implementation block.
+ +/// For example, `f` in
+ +/// ```rust
+ +/// # struct S;
+ +/// # trait Trait { fn f(); }
+ +/// impl Trait for S {
+ +///     fn f() {}
+ +/// }
+ +/// ```
+ +pub fn is_trait_impl_item(cx: &LateContext<'_>, hir_id: HirId) -> bool {
+ +    if let Some(Node::Item(item)) = cx.tcx.hir().find(cx.tcx.hir().get_parent_node(hir_id)) {
+ +        matches!(item.kind, ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }))
+ +    } else {
+ +        false
+ +    }
+ +}
+ +
+ +/// Check if it's even possible to satisfy the `where` clause for the item.
+ +///
+ +/// `trivial_bounds` feature allows functions with unsatisfiable bounds, for example:
+ +///
+ +/// ```ignore
+ +/// fn foo() where i32: Iterator {
+ +///     for _ in 2i32 {}
+ +/// }
+ +/// ```
+ +pub fn fn_has_unsatisfiable_preds(cx: &LateContext<'_>, did: DefId) -> bool {
+ +    use rustc_trait_selection::traits;
+ +    let predicates = cx
+ +        .tcx
+ +        .predicates_of(did)
+ +        .predicates
+ +        .iter()
+ +        .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None });
+ +    traits::impossible_predicates(
+ +        cx.tcx,
+ +        traits::elaborate_predicates(cx.tcx, predicates)
+ +            .map(|o| o.predicate)
+ +            .collect::<Vec<_>>(),
+ +    )
+ +}
+ +
+ +/// Returns the `DefId` of the callee if the given expression is a function or method call.
+ +pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
+ +    match &expr.kind {
+ +        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
+ +        ExprKind::Call(
+ +            Expr {
+ +                kind: ExprKind::Path(qpath),
+ +                hir_id: path_hir_id,
+ +                ..
+ +            },
+ +            ..,
+ +        ) => cx.typeck_results().qpath_res(qpath, *path_hir_id).opt_def_id(),
+ +        _ => None,
+ +    }
+ +}
+ +
+ +/// Returns Option<String> where String is a textual representation of the type encapsulated in the
+ +/// slice iff the given expression is a slice of primitives (as defined in the
+ +/// `is_recursively_primitive_type` function) and None otherwise.
+ +pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
+ +    let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
+ +    let expr_kind = expr_type.kind();
+ +    let is_primitive = match expr_kind {
+ +        rustc_ty::Slice(element_type) => is_recursively_primitive_type(element_type),
+ +        rustc_ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), &rustc_ty::Slice(_)) => {
+ +            if let rustc_ty::Slice(element_type) = inner_ty.kind() {
+ +                is_recursively_primitive_type(element_type)
+ +            } else {
+ +                unreachable!()
+ +            }
+ +        },
+ +        _ => false,
+ +    };
+ +
+ +    if is_primitive {
+ +        // if we have wrappers like Array, Slice or Tuple, print these
+ +        // and get the type enclosed in the slice ref
+ +        match expr_type.peel_refs().walk().nth(1).unwrap().expect_ty().kind() {
+ +            rustc_ty::Slice(..) => return Some("slice".into()),
+ +            rustc_ty::Array(..) => return Some("array".into()),
+ +            rustc_ty::Tuple(..) => return Some("tuple".into()),
+ +            _ => {
+ +                // is_recursively_primitive_type() should have taken care
+ +                // of the rest and we can rely on the type that is found
+ +                let refs_peeled = expr_type.peel_refs();
+ +                return Some(refs_peeled.walk().last().unwrap().to_string());
+ +            },
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +/// returns list of all pairs (a, b) from `exprs` such that `eq(a, b)`
+ +/// `hash` must be comformed with `eq`
+ +pub fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
+ +where
+ +    Hash: Fn(&T) -> u64,
+ +    Eq: Fn(&T, &T) -> bool,
+ +{
+ +    match exprs {
+ +        [a, b] if eq(a, b) => return vec![(a, b)],
+ +        _ if exprs.len() <= 2 => return vec![],
+ +        _ => {},
+ +    }
+ +
+ +    let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
+ +
+ +    let mut map: UnhashMap<u64, Vec<&_>> =
+ +        UnhashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
+ +
+ +    for expr in exprs {
+ +        match map.entry(hash(expr)) {
+ +            Entry::Occupied(mut o) => {
+ +                for o in o.get() {
+ +                    if eq(o, expr) {
+ +                        match_expr_list.push((o, expr));
+ +                    }
+ +                }
+ +                o.get_mut().push(expr);
+ +            },
+ +            Entry::Vacant(v) => {
+ +                v.insert(vec![expr]);
+ +            },
+ +        }
+ +    }
+ +
+ +    match_expr_list
+ +}
+ +
+ +/// Peels off all references on the pattern. Returns the underlying pattern and the number of
+ +/// references removed.
+ +pub fn peel_hir_pat_refs<'a>(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
+ +    fn peel<'a>(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
+ +        if let PatKind::Ref(pat, _) = pat.kind {
+ +            peel(pat, count + 1)
+ +        } else {
+ +            (pat, count)
+ +        }
+ +    }
+ +    peel(pat, 0)
+ +}
+ +
+ +/// Peels of expressions while the given closure returns `Some`.
+ +pub fn peel_hir_expr_while<'tcx>(
+ +    mut expr: &'tcx Expr<'tcx>,
+ +    mut f: impl FnMut(&'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>>,
+ +) -> &'tcx Expr<'tcx> {
+ +    while let Some(e) = f(expr) {
+ +        expr = e;
+ +    }
+ +    expr
+ +}
+ +
+ +/// Peels off up to the given number of references on the expression. Returns the underlying
+ +/// expression and the number of references removed.
+ +pub fn peel_n_hir_expr_refs<'a>(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
+ +    let mut remaining = count;
+ +    let e = peel_hir_expr_while(expr, |e| match e.kind {
+ +        ExprKind::AddrOf(ast::BorrowKind::Ref, _, e) if remaining != 0 => {
+ +            remaining -= 1;
+ +            Some(e)
+ +        },
+ +        _ => None,
+ +    });
+ +    (e, count - remaining)
+ +}
+ +
+ +/// Peels off all references on the expression. Returns the underlying expression and the number of
+ +/// references removed.
+ +pub fn peel_hir_expr_refs<'a>(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
+ +    let mut count = 0;
+ +    let e = peel_hir_expr_while(expr, |e| match e.kind {
+ +        ExprKind::AddrOf(ast::BorrowKind::Ref, _, e) => {
+ +            count += 1;
+ +            Some(e)
+ +        },
+ +        _ => None,
+ +    });
+ +    (e, count)
+ +}
+ +
+ +/// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
+ +/// dereferenced. An overloaded deref such as `Vec` to slice would not be removed.
+ +pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
+ +    loop {
+ +        match expr.kind {
+ +            ExprKind::AddrOf(_, _, e) => expr = e,
+ +            ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
+ +            _ => break,
+ +        }
+ +    }
+ +    expr
+ +}
+ +
+ +#[macro_export]
+ +macro_rules! unwrap_cargo_metadata {
+ +    ($cx: ident, $lint: ident, $deps: expr) => {{
+ +        let mut command = cargo_metadata::MetadataCommand::new();
+ +        if !$deps {
+ +            command.no_deps();
+ +        }
+ +
+ +        match command.exec() {
+ +            Ok(metadata) => metadata,
+ +            Err(err) => {
+ +                span_lint($cx, $lint, DUMMY_SP, &format!("could not read cargo metadata: {}", err));
+ +                return;
+ +            },
+ +        }
+ +    }};
+ +}
+ +
+ +pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
+ +    if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
+ +        if let Res::Def(_, def_id) = path.res {
+ +            return cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr);
+ +        }
+ +    }
+ +    false
+ +}
+ +
+ +struct TestItemNamesVisitor<'tcx> {
+ +    tcx: TyCtxt<'tcx>,
+ +    names: Vec<Symbol>,
+ +}
+ +
+ +impl<'hir> ItemLikeVisitor<'hir> for TestItemNamesVisitor<'hir> {
+ +    fn visit_item(&mut self, item: &Item<'_>) {
+ +        if let ItemKind::Const(ty, _body) = item.kind {
+ +            if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
+ +                // We could also check for the type name `test::TestDescAndFn`
+ +                if let Res::Def(DefKind::Struct, _) = path.res {
+ +                    let has_test_marker = self
+ +                        .tcx
+ +                        .hir()
+ +                        .attrs(item.hir_id())
+ +                        .iter()
+ +                        .any(|a| a.has_name(sym::rustc_test_marker));
+ +                    if has_test_marker {
+ +                        self.names.push(item.ident.name);
+ +                    }
+ +                }
+ +            }
+ +        }
+ +    }
+ +    fn visit_trait_item(&mut self, _: &TraitItem<'_>) {}
+ +    fn visit_impl_item(&mut self, _: &ImplItem<'_>) {}
+ +    fn visit_foreign_item(&mut self, _: &ForeignItem<'_>) {}
+ +}
+ +
+ +static TEST_ITEM_NAMES_CACHE: SyncOnceCell<Mutex<FxHashMap<LocalDefId, Vec<Symbol>>>> = SyncOnceCell::new();
+ +
+ +fn with_test_item_names<'tcx>(tcx: TyCtxt<'tcx>, module: LocalDefId, f: impl Fn(&[Symbol]) -> bool) -> bool {
+ +    let cache = TEST_ITEM_NAMES_CACHE.get_or_init(|| Mutex::new(FxHashMap::default()));
+ +    let mut map: MutexGuard<'_, FxHashMap<LocalDefId, Vec<Symbol>>> = cache.lock().unwrap();
+ +    match map.entry(module) {
+ +        Entry::Occupied(entry) => f(entry.get()),
+ +        Entry::Vacant(entry) => {
+ +            let mut visitor = TestItemNamesVisitor { tcx, names: Vec::new() };
+ +            tcx.hir().visit_item_likes_in_module(module, &mut visitor);
+ +            visitor.names.sort_unstable();
+ +            f(&*entry.insert(visitor.names))
+ +        },
+ +    }
+ +}
+ +
+ +/// Checks if the function containing the given `HirId` is a `#[test]` function
+ +///
- /// Note: If you use this function, please add a `#[test]` case in `tests/ui_test`.
++/// Note: Add `// compile-flags: --test` to UI tests with a `#[test]` function
+ +pub fn is_in_test_function(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
+ +    with_test_item_names(tcx, tcx.parent_module(id), |names| {
+ +        tcx.hir()
+ +            .parent_iter(id)
+ +            // Since you can nest functions we need to collect all until we leave
+ +            // function scope
+ +            .any(|(_id, node)| {
+ +                if let Node::Item(item) = node {
+ +                    if let ItemKind::Fn(_, _, _) = item.kind {
+ +                        // Note that we have sorted the item names in the visitor,
+ +                        // so the binary_search gets the same as `contains`, but faster.
+ +                        return names.binary_search(&item.ident.name).is_ok();
+ +                    }
+ +                }
+ +                false
+ +            })
+ +    })
+ +}
+ +
+ +/// Checks whether item either has `test` attribute applied, or
+ +/// is a module with `test` in its name.
+ +///
++/// Note: Add `// compile-flags: --test` to UI tests with a `#[test]` function
+ +pub fn is_test_module_or_function(tcx: TyCtxt<'_>, item: &Item<'_>) -> bool {
+ +    is_in_test_function(tcx, item.hir_id())
+ +        || matches!(item.kind, ItemKind::Mod(..))
+ +            && item.ident.name.as_str().split('_').any(|a| a == "test" || a == "tests")
+ +}
+ +
+ +macro_rules! op_utils {
+ +    ($($name:ident $assign:ident)*) => {
+ +        /// Binary operation traits like `LangItem::Add`
+ +        pub static BINOP_TRAITS: &[LangItem] = &[$(LangItem::$name,)*];
+ +
+ +        /// Operator-Assign traits like `LangItem::AddAssign`
+ +        pub static OP_ASSIGN_TRAITS: &[LangItem] = &[$(LangItem::$assign,)*];
+ +
+ +        /// Converts `BinOpKind::Add` to `(LangItem::Add, LangItem::AddAssign)`, for example
+ +        pub fn binop_traits(kind: hir::BinOpKind) -> Option<(LangItem, LangItem)> {
+ +            match kind {
+ +                $(hir::BinOpKind::$name => Some((LangItem::$name, LangItem::$assign)),)*
+ +                _ => None,
+ +            }
+ +        }
+ +    };
+ +}
+ +
+ +op_utils! {
+ +    Add    AddAssign
+ +    Sub    SubAssign
+ +    Mul    MulAssign
+ +    Div    DivAssign
+ +    Rem    RemAssign
+ +    BitXor BitXorAssign
+ +    BitAnd BitAndAssign
+ +    BitOr  BitOrAssign
+ +    Shl    ShlAssign
+ +    Shr    ShrAssign
+ +}
diff --cc src/tools/clippy/clippy_utils/src/macros.rs

index a75f6b86a9bae4de295769ec1a72c5bfcd4db38c,0000000000000000000000000000000000000000..5a76ac23332d31d5fd08c8826cd8f9c78ec876ff

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_utils/src/macros.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_utils/src/macros.rs
@@@ -1,549 -1,0 +1,556 @@@
- use rustc_span::hygiene::{MacroKind, SyntaxContext};
+ +#![allow(clippy::similar_names)] // `expr` and `expn`
+ +
+ +use crate::visitors::expr_visitor_no_bodies;
+ +
+ +use arrayvec::ArrayVec;
+ +use if_chain::if_chain;
+ +use rustc_ast::ast::LitKind;
+ +use rustc_hir::intravisit::Visitor;
+ +use rustc_hir::{self as hir, Expr, ExprKind, HirId, Node, QPath};
+ +use rustc_lint::LateContext;
+ +use rustc_span::def_id::DefId;
-                         Some(FormatArgsArg { value: self.value_args[j], format_trait, spec: Some(spec) })
++use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
+ +use rustc_span::{sym, ExpnData, ExpnId, ExpnKind, Span, Symbol};
+ +use std::ops::ControlFlow;
+ +
+ +/// A macro call, like `vec![1, 2, 3]`.
+ +///
+ +/// Use `tcx.item_name(macro_call.def_id)` to get the macro name.
+ +/// Even better is to check if it is a diagnostic item.
+ +///
+ +/// This structure is similar to `ExpnData` but it precludes desugaring expansions.
+ +#[derive(Debug)]
+ +pub struct MacroCall {
+ +    /// Macro `DefId`
+ +    pub def_id: DefId,
+ +    /// Kind of macro
+ +    pub kind: MacroKind,
+ +    /// The expansion produced by the macro call
+ +    pub expn: ExpnId,
+ +    /// Span of the macro call site
+ +    pub span: Span,
+ +}
+ +
+ +impl MacroCall {
+ +    pub fn is_local(&self) -> bool {
+ +        span_is_local(self.span)
+ +    }
+ +}
+ +
+ +/// Returns an iterator of expansions that created the given span
+ +pub fn expn_backtrace(mut span: Span) -> impl Iterator<Item = (ExpnId, ExpnData)> {
+ +    std::iter::from_fn(move || {
+ +        let ctxt = span.ctxt();
+ +        if ctxt == SyntaxContext::root() {
+ +            return None;
+ +        }
+ +        let expn = ctxt.outer_expn();
+ +        let data = expn.expn_data();
+ +        span = data.call_site;
+ +        Some((expn, data))
+ +    })
+ +}
+ +
+ +/// Checks whether the span is from the root expansion or a locally defined macro
+ +pub fn span_is_local(span: Span) -> bool {
+ +    !span.from_expansion() || expn_is_local(span.ctxt().outer_expn())
+ +}
+ +
+ +/// Checks whether the expansion is the root expansion or a locally defined macro
+ +pub fn expn_is_local(expn: ExpnId) -> bool {
+ +    if expn == ExpnId::root() {
+ +        return true;
+ +    }
+ +    let data = expn.expn_data();
+ +    let backtrace = expn_backtrace(data.call_site);
+ +    std::iter::once((expn, data))
+ +        .chain(backtrace)
+ +        .find_map(|(_, data)| data.macro_def_id)
+ +        .map_or(true, DefId::is_local)
+ +}
+ +
+ +/// Returns an iterator of macro expansions that created the given span.
+ +/// Note that desugaring expansions are skipped.
+ +pub fn macro_backtrace(span: Span) -> impl Iterator<Item = MacroCall> {
+ +    expn_backtrace(span).filter_map(|(expn, data)| match data {
+ +        ExpnData {
+ +            kind: ExpnKind::Macro(kind, _),
+ +            macro_def_id: Some(def_id),
+ +            call_site: span,
+ +            ..
+ +        } => Some(MacroCall {
+ +            def_id,
+ +            kind,
+ +            expn,
+ +            span,
+ +        }),
+ +        _ => None,
+ +    })
+ +}
+ +
+ +/// If the macro backtrace of `span` has a macro call at the root expansion
+ +/// (i.e. not a nested macro call), returns `Some` with the `MacroCall`
+ +pub fn root_macro_call(span: Span) -> Option<MacroCall> {
+ +    macro_backtrace(span).last()
+ +}
+ +
+ +/// Like [`root_macro_call`], but only returns `Some` if `node` is the "first node"
+ +/// produced by the macro call, as in [`first_node_in_macro`].
+ +pub fn root_macro_call_first_node(cx: &LateContext<'_>, node: &impl HirNode) -> Option<MacroCall> {
+ +    if first_node_in_macro(cx, node) != Some(ExpnId::root()) {
+ +        return None;
+ +    }
+ +    root_macro_call(node.span())
+ +}
+ +
+ +/// Like [`macro_backtrace`], but only returns macro calls where `node` is the "first node" of the
+ +/// macro call, as in [`first_node_in_macro`].
+ +pub fn first_node_macro_backtrace(cx: &LateContext<'_>, node: &impl HirNode) -> impl Iterator<Item = MacroCall> {
+ +    let span = node.span();
+ +    first_node_in_macro(cx, node)
+ +        .into_iter()
+ +        .flat_map(move |expn| macro_backtrace(span).take_while(move |macro_call| macro_call.expn != expn))
+ +}
+ +
+ +/// If `node` is the "first node" in a macro expansion, returns `Some` with the `ExpnId` of the
+ +/// macro call site (i.e. the parent of the macro expansion). This generally means that `node`
+ +/// is the outermost node of an entire macro expansion, but there are some caveats noted below.
+ +/// This is useful for finding macro calls while visiting the HIR without processing the macro call
+ +/// at every node within its expansion.
+ +///
+ +/// If you already have immediate access to the parent node, it is simpler to
+ +/// just check the context of that span directly (e.g. `parent.span.from_expansion()`).
+ +///
+ +/// If a macro call is in statement position, it expands to one or more statements.
+ +/// In that case, each statement *and* their immediate descendants will all yield `Some`
+ +/// with the `ExpnId` of the containing block.
+ +///
+ +/// A node may be the "first node" of multiple macro calls in a macro backtrace.
+ +/// The expansion of the outermost macro call site is returned in such cases.
+ +pub fn first_node_in_macro(cx: &LateContext<'_>, node: &impl HirNode) -> Option<ExpnId> {
+ +    // get the macro expansion or return `None` if not found
+ +    // `macro_backtrace` importantly ignores desugaring expansions
+ +    let expn = macro_backtrace(node.span()).next()?.expn;
+ +
+ +    // get the parent node, possibly skipping over a statement
+ +    // if the parent is not found, it is sensible to return `Some(root)`
+ +    let hir = cx.tcx.hir();
+ +    let mut parent_iter = hir.parent_iter(node.hir_id());
+ +    let (parent_id, _) = match parent_iter.next() {
+ +        None => return Some(ExpnId::root()),
+ +        Some((_, Node::Stmt(_))) => match parent_iter.next() {
+ +            None => return Some(ExpnId::root()),
+ +            Some(next) => next,
+ +        },
+ +        Some(next) => next,
+ +    };
+ +
+ +    // get the macro expansion of the parent node
+ +    let parent_span = hir.span(parent_id);
+ +    let Some(parent_macro_call) = macro_backtrace(parent_span).next() else {
+ +        // the parent node is not in a macro
+ +        return Some(ExpnId::root());
+ +    };
+ +
+ +    if parent_macro_call.expn.is_descendant_of(expn) {
+ +        // `node` is input to a macro call
+ +        return None;
+ +    }
+ +
+ +    Some(parent_macro_call.expn)
+ +}
+ +
+ +/* Specific Macro Utils */
+ +
+ +/// Is `def_id` of `std::panic`, `core::panic` or any inner implementation macros
+ +pub fn is_panic(cx: &LateContext<'_>, def_id: DefId) -> bool {
+ +    let Some(name) = cx.tcx.get_diagnostic_name(def_id) else { return false };
+ +    matches!(
+ +        name.as_str(),
+ +        "core_panic_macro"
+ +            | "std_panic_macro"
+ +            | "core_panic_2015_macro"
+ +            | "std_panic_2015_macro"
+ +            | "core_panic_2021_macro"
+ +    )
+ +}
+ +
+ +pub enum PanicExpn<'a> {
+ +    /// No arguments - `panic!()`
+ +    Empty,
+ +    /// A string literal or any `&str` - `panic!("message")` or `panic!(message)`
+ +    Str(&'a Expr<'a>),
+ +    /// A single argument that implements `Display` - `panic!("{}", object)`
+ +    Display(&'a Expr<'a>),
+ +    /// Anything else - `panic!("error {}: {}", a, b)`
+ +    Format(FormatArgsExpn<'a>),
+ +}
+ +
+ +impl<'a> PanicExpn<'a> {
+ +    pub fn parse(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<Self> {
+ +        if !macro_backtrace(expr.span).any(|macro_call| is_panic(cx, macro_call.def_id)) {
+ +            return None;
+ +        }
+ +        let ExprKind::Call(callee, [arg]) = &expr.kind else { return None };
+ +        let ExprKind::Path(QPath::Resolved(_, path)) = &callee.kind else { return None };
+ +        let result = match path.segments.last().unwrap().ident.as_str() {
+ +            "panic" if arg.span.ctxt() == expr.span.ctxt() => Self::Empty,
+ +            "panic" | "panic_str" => Self::Str(arg),
+ +            "panic_display" => {
+ +                let ExprKind::AddrOf(_, _, e) = &arg.kind else { return None };
+ +                Self::Display(e)
+ +            },
+ +            "panic_fmt" => Self::Format(FormatArgsExpn::parse(cx, arg)?),
+ +            _ => return None,
+ +        };
+ +        Some(result)
+ +    }
+ +}
+ +
+ +/// Finds the arguments of an `assert!` or `debug_assert!` macro call within the macro expansion
+ +pub fn find_assert_args<'a>(
+ +    cx: &LateContext<'_>,
+ +    expr: &'a Expr<'a>,
+ +    expn: ExpnId,
+ +) -> Option<(&'a Expr<'a>, PanicExpn<'a>)> {
+ +    find_assert_args_inner(cx, expr, expn).map(|([e], p)| (e, p))
+ +}
+ +
+ +/// Finds the arguments of an `assert_eq!` or `debug_assert_eq!` macro call within the macro
+ +/// expansion
+ +pub fn find_assert_eq_args<'a>(
+ +    cx: &LateContext<'_>,
+ +    expr: &'a Expr<'a>,
+ +    expn: ExpnId,
+ +) -> Option<(&'a Expr<'a>, &'a Expr<'a>, PanicExpn<'a>)> {
+ +    find_assert_args_inner(cx, expr, expn).map(|([a, b], p)| (a, b, p))
+ +}
+ +
+ +fn find_assert_args_inner<'a, const N: usize>(
+ +    cx: &LateContext<'_>,
+ +    expr: &'a Expr<'a>,
+ +    expn: ExpnId,
+ +) -> Option<([&'a Expr<'a>; N], PanicExpn<'a>)> {
+ +    let macro_id = expn.expn_data().macro_def_id?;
+ +    let (expr, expn) = match cx.tcx.item_name(macro_id).as_str().strip_prefix("debug_") {
+ +        None => (expr, expn),
+ +        Some(inner_name) => find_assert_within_debug_assert(cx, expr, expn, Symbol::intern(inner_name))?,
+ +    };
+ +    let mut args = ArrayVec::new();
+ +    let mut panic_expn = None;
+ +    expr_visitor_no_bodies(|e| {
+ +        if args.is_full() {
+ +            if panic_expn.is_none() && e.span.ctxt() != expr.span.ctxt() {
+ +                panic_expn = PanicExpn::parse(cx, e);
+ +            }
+ +            panic_expn.is_none()
+ +        } else if is_assert_arg(cx, e, expn) {
+ +            args.push(e);
+ +            false
+ +        } else {
+ +            true
+ +        }
+ +    })
+ +    .visit_expr(expr);
+ +    let args = args.into_inner().ok()?;
+ +    // if no `panic!(..)` is found, use `PanicExpn::Empty`
+ +    // to indicate that the default assertion message is used
+ +    let panic_expn = panic_expn.unwrap_or(PanicExpn::Empty);
+ +    Some((args, panic_expn))
+ +}
+ +
+ +fn find_assert_within_debug_assert<'a>(
+ +    cx: &LateContext<'_>,
+ +    expr: &'a Expr<'a>,
+ +    expn: ExpnId,
+ +    assert_name: Symbol,
+ +) -> Option<(&'a Expr<'a>, ExpnId)> {
+ +    let mut found = None;
+ +    expr_visitor_no_bodies(|e| {
+ +        if found.is_some() || !e.span.from_expansion() {
+ +            return false;
+ +        }
+ +        let e_expn = e.span.ctxt().outer_expn();
+ +        if e_expn == expn {
+ +            return true;
+ +        }
+ +        if e_expn.expn_data().macro_def_id.map(|id| cx.tcx.item_name(id)) == Some(assert_name) {
+ +            found = Some((e, e_expn));
+ +        }
+ +        false
+ +    })
+ +    .visit_expr(expr);
+ +    found
+ +}
+ +
+ +fn is_assert_arg(cx: &LateContext<'_>, expr: &Expr<'_>, assert_expn: ExpnId) -> bool {
+ +    if !expr.span.from_expansion() {
+ +        return true;
+ +    }
+ +    let result = macro_backtrace(expr.span).try_for_each(|macro_call| {
+ +        if macro_call.expn == assert_expn {
+ +            ControlFlow::Break(false)
+ +        } else {
+ +            match cx.tcx.item_name(macro_call.def_id) {
+ +                // `cfg!(debug_assertions)` in `debug_assert!`
+ +                sym::cfg => ControlFlow::CONTINUE,
+ +                // assert!(other_macro!(..))
+ +                _ => ControlFlow::Break(true),
+ +            }
+ +        }
+ +    });
+ +    match result {
+ +        ControlFlow::Break(is_assert_arg) => is_assert_arg,
+ +        ControlFlow::Continue(()) => true,
+ +    }
+ +}
+ +
+ +/// A parsed `format_args!` expansion
++#[derive(Debug)]
+ +pub struct FormatArgsExpn<'tcx> {
+ +    /// Span of the first argument, the format string
+ +    pub format_string_span: Span,
+ +    /// The format string split by formatted args like `{..}`
+ +    pub format_string_parts: Vec<Symbol>,
+ +    /// Values passed after the format string
+ +    pub value_args: Vec<&'tcx Expr<'tcx>>,
+ +    /// Each element is a `value_args` index and a formatting trait (e.g. `sym::Debug`)
+ +    pub formatters: Vec<(usize, Symbol)>,
+ +    /// List of `fmt::v1::Argument { .. }` expressions. If this is empty,
+ +    /// then `formatters` represents the format args (`{..}`).
+ +    /// If this is non-empty, it represents the format args, and the `position`
+ +    /// parameters within the struct expressions are indexes of `formatters`.
+ +    pub specs: Vec<&'tcx Expr<'tcx>>,
+ +}
+ +
+ +impl<'tcx> FormatArgsExpn<'tcx> {
+ +    /// Parses an expanded `format_args!` or `format_args_nl!` invocation
+ +    pub fn parse(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<Self> {
+ +        macro_backtrace(expr.span).find(|macro_call| {
+ +            matches!(
+ +                cx.tcx.item_name(macro_call.def_id),
+ +                sym::const_format_args | sym::format_args | sym::format_args_nl
+ +            )
+ +        })?;
+ +        let mut format_string_span: Option<Span> = None;
+ +        let mut format_string_parts: Vec<Symbol> = Vec::new();
+ +        let mut value_args: Vec<&Expr<'_>> = Vec::new();
+ +        let mut formatters: Vec<(usize, Symbol)> = Vec::new();
+ +        let mut specs: Vec<&Expr<'_>> = Vec::new();
+ +        expr_visitor_no_bodies(|e| {
+ +            // if we're still inside of the macro definition...
+ +            if e.span.ctxt() == expr.span.ctxt() {
+ +                // ArgumnetV1::new_<format_trait>(<value>)
+ +                if_chain! {
+ +                    if let ExprKind::Call(callee, [val]) = e.kind;
+ +                    if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = callee.kind;
+ +                    if let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind;
+ +                    if path.segments.last().unwrap().ident.name == sym::ArgumentV1;
+ +                    if seg.ident.name.as_str().starts_with("new_");
+ +                    then {
+ +                        let val_idx = if_chain! {
+ +                            if val.span.ctxt() == expr.span.ctxt();
+ +                            if let ExprKind::Field(_, field) = val.kind;
+ +                            if let Ok(idx) = field.name.as_str().parse();
+ +                            then {
+ +                                // tuple index
+ +                                idx
+ +                            } else {
+ +                                // assume the value expression is passed directly
+ +                                formatters.len()
+ +                            }
+ +                        };
+ +                        let fmt_trait = match seg.ident.name.as_str() {
+ +                            "new_display" => "Display",
+ +                            "new_debug" => "Debug",
+ +                            "new_lower_exp" => "LowerExp",
+ +                            "new_upper_exp" => "UpperExp",
+ +                            "new_octal" => "Octal",
+ +                            "new_pointer" => "Pointer",
+ +                            "new_binary" => "Binary",
+ +                            "new_lower_hex" => "LowerHex",
+ +                            "new_upper_hex" => "UpperHex",
+ +                            _ => unreachable!(),
+ +                        };
+ +                        formatters.push((val_idx, Symbol::intern(fmt_trait)));
+ +                    }
+ +                }
+ +                if let ExprKind::Struct(QPath::Resolved(_, path), ..) = e.kind {
+ +                    if path.segments.last().unwrap().ident.name == sym::Argument {
+ +                        specs.push(e);
+ +                    }
+ +                }
+ +                // walk through the macro expansion
+ +                return true;
+ +            }
+ +            // assume that the first expr with a differing context represents
+ +            // (and has the span of) the format string
+ +            if format_string_span.is_none() {
+ +                format_string_span = Some(e.span);
+ +                let span = e.span;
+ +                // walk the expr and collect string literals which are format string parts
+ +                expr_visitor_no_bodies(|e| {
+ +                    if e.span.ctxt() != span.ctxt() {
+ +                        // defensive check, probably doesn't happen
+ +                        return false;
+ +                    }
+ +                    if let ExprKind::Lit(lit) = &e.kind {
+ +                        if let LitKind::Str(symbol, _s) = lit.node {
+ +                            format_string_parts.push(symbol);
+ +                        }
+ +                    }
+ +                    true
+ +                })
+ +                .visit_expr(e);
+ +            } else {
+ +                // assume that any further exprs with a differing context are value args
+ +                value_args.push(e);
+ +            }
+ +            // don't walk anything not from the macro expansion (e.a. inputs)
+ +            false
+ +        })
+ +        .visit_expr(expr);
+ +        Some(FormatArgsExpn {
+ +            format_string_span: format_string_span?,
+ +            format_string_parts,
+ +            value_args,
+ +            formatters,
+ +            specs,
+ +        })
+ +    }
+ +
+ +    /// Finds a nested call to `format_args!` within a `format!`-like macro call
+ +    pub fn find_nested(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, expn_id: ExpnId) -> Option<Self> {
+ +        let mut format_args = None;
+ +        expr_visitor_no_bodies(|e| {
+ +            if format_args.is_some() {
+ +                return false;
+ +            }
+ +            let e_ctxt = e.span.ctxt();
+ +            if e_ctxt == expr.span.ctxt() {
+ +                return true;
+ +            }
+ +            if e_ctxt.outer_expn().is_descendant_of(expn_id) {
+ +                format_args = FormatArgsExpn::parse(cx, e);
+ +            }
+ +            false
+ +        })
+ +        .visit_expr(expr);
+ +        format_args
+ +    }
+ +
+ +    /// Returns a vector of `FormatArgsArg`.
+ +    pub fn args(&self) -> Option<Vec<FormatArgsArg<'tcx>>> {
+ +        if self.specs.is_empty() {
+ +            let args = std::iter::zip(&self.value_args, &self.formatters)
+ +                .map(|(value, &(_, format_trait))| FormatArgsArg {
+ +                    value,
+ +                    format_trait,
+ +                    spec: None,
+ +                })
+ +                .collect();
+ +            return Some(args);
+ +        }
+ +        self.specs
+ +            .iter()
+ +            .map(|spec| {
+ +                if_chain! {
+ +                    // struct `core::fmt::rt::v1::Argument`
+ +                    if let ExprKind::Struct(_, fields, _) = spec.kind;
+ +                    if let Some(position_field) = fields.iter().find(|f| f.ident.name == sym::position);
+ +                    if let ExprKind::Lit(lit) = &position_field.expr.kind;
+ +                    if let LitKind::Int(position, _) = lit.node;
+ +                    if let Ok(i) = usize::try_from(position);
+ +                    if let Some(&(j, format_trait)) = self.formatters.get(i);
+ +                    then {
-     /// Span of all inputs
++                        Some(FormatArgsArg {
++                            value: self.value_args[j],
++                            format_trait,
++                            spec: Some(spec),
++                        })
+ +                    } else {
+ +                        None
+ +                    }
+ +                }
+ +            })
+ +            .collect()
+ +    }
+ +
-             [.., last] => self.format_string_span.to(last.span),
++    /// Source callsite span of all inputs
+ +    pub fn inputs_span(&self) -> Span {
+ +        match *self.value_args {
+ +            [] => self.format_string_span,
++            [.., last] => self
++                .format_string_span
++                .to(hygiene::walk_chain(last.span, self.format_string_span.ctxt())),
+ +        }
+ +    }
+ +}
+ +
+ +/// Type representing a `FormatArgsExpn`'s format arguments
+ +pub struct FormatArgsArg<'tcx> {
+ +    /// An element of `value_args` according to `position`
+ +    pub value: &'tcx Expr<'tcx>,
+ +    /// An element of `args` according to `position`
+ +    pub format_trait: Symbol,
+ +    /// An element of `specs`
+ +    pub spec: Option<&'tcx Expr<'tcx>>,
+ +}
+ +
+ +impl<'tcx> FormatArgsArg<'tcx> {
+ +    /// Returns true if any formatting parameters are used that would have an effect on strings,
+ +    /// like `{:+2}` instead of just `{}`.
+ +    pub fn has_string_formatting(&self) -> bool {
+ +        self.spec.map_or(false, |spec| {
+ +            // `!` because these conditions check that `self` is unformatted.
+ +            !if_chain! {
+ +                // struct `core::fmt::rt::v1::Argument`
+ +                if let ExprKind::Struct(_, fields, _) = spec.kind;
+ +                if let Some(format_field) = fields.iter().find(|f| f.ident.name == sym::format);
+ +                // struct `core::fmt::rt::v1::FormatSpec`
+ +                if let ExprKind::Struct(_, subfields, _) = format_field.expr.kind;
+ +                if subfields.iter().all(|field| match field.ident.name {
+ +                    sym::precision | sym::width => match field.expr.kind {
+ +                        ExprKind::Path(QPath::Resolved(_, path)) => {
+ +                            path.segments.last().unwrap().ident.name == sym::Implied
+ +                        }
+ +                        _ => false,
+ +                    }
+ +                    _ => true,
+ +                });
+ +                then { true } else { false }
+ +            }
+ +        })
+ +    }
+ +}
+ +
+ +/// A node with a `HirId` and a `Span`
+ +pub trait HirNode {
+ +    fn hir_id(&self) -> HirId;
+ +    fn span(&self) -> Span;
+ +}
+ +
+ +macro_rules! impl_hir_node {
+ +    ($($t:ident),*) => {
+ +        $(impl HirNode for hir::$t<'_> {
+ +            fn hir_id(&self) -> HirId {
+ +                self.hir_id
+ +            }
+ +            fn span(&self) -> Span {
+ +                self.span
+ +            }
+ +        })*
+ +    };
+ +}
+ +
+ +impl_hir_node!(Expr, Pat);
+ +
+ +impl HirNode for hir::Item<'_> {
+ +    fn hir_id(&self) -> HirId {
+ +        self.hir_id()
+ +    }
+ +
+ +    fn span(&self) -> Span {
+ +        self.span
+ +    }
+ +}
diff --cc src/tools/clippy/clippy_utils/src/ty.rs

index 819ff917b63364ac837ebf05477bd69707889ffb,0000000000000000000000000000000000000000..958e6d1ec4615b2eeeaa8acfcf61ea17ac58ceb1

mode 100644,000000..100644
--- 1/src/tools/clippy/clippy_utils/src/ty.rs
--- /dev/null
+++ b/src/tools/clippy/clippy_utils/src/ty.rs
@@@ -1,517 -1,0 +1,517 @@@
- use crate::{expr_path_res, match_def_path, must_use_attr};
+ +//! Util methods for [`rustc_middle::ty`]
+ +
+ +#![allow(clippy::module_name_repetitions)]
+ +
+ +use rustc_ast::ast::Mutability;
+ +use rustc_data_structures::fx::FxHashMap;
+ +use rustc_hir as hir;
+ +use rustc_hir::def::{CtorKind, DefKind, Res};
+ +use rustc_hir::def_id::DefId;
+ +use rustc_hir::{Expr, TyKind, Unsafety};
+ +use rustc_infer::infer::TyCtxtInferExt;
+ +use rustc_lint::LateContext;
+ +use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst};
+ +use rustc_middle::ty::{
+ +    self, AdtDef, Binder, FnSig, IntTy, Predicate, PredicateKind, Ty, TyCtxt, TypeFoldable, UintTy,
+ +};
+ +use rustc_span::symbol::Ident;
+ +use rustc_span::{sym, Span, Symbol, DUMMY_SP};
+ +use rustc_trait_selection::infer::InferCtxtExt;
+ +use rustc_trait_selection::traits::query::normalize::AtExt;
+ +use std::iter;
+ +
-     if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = expr_path_res(cx, expr) {
++use crate::{match_def_path, must_use_attr, path_res};
+ +
+ +// Checks if the given type implements copy.
+ +pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+ +    ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
+ +}
+ +
+ +/// Checks whether a type can be partially moved.
+ +pub fn can_partially_move_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+ +    if has_drop(cx, ty) || is_copy(cx, ty) {
+ +        return false;
+ +    }
+ +    match ty.kind() {
+ +        ty::Param(_) => false,
+ +        ty::Adt(def, subs) => def.all_fields().any(|f| !is_copy(cx, f.ty(cx.tcx, subs))),
+ +        _ => true,
+ +    }
+ +}
+ +
+ +/// Walks into `ty` and returns `true` if any inner type is the same as `other_ty`
+ +pub fn contains_ty(ty: Ty<'_>, other_ty: Ty<'_>) -> bool {
+ +    ty.walk().any(|inner| match inner.unpack() {
+ +        GenericArgKind::Type(inner_ty) => other_ty == inner_ty,
+ +        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+ +    })
+ +}
+ +
+ +/// Walks into `ty` and returns `true` if any inner type is an instance of the given adt
+ +/// constructor.
+ +pub fn contains_adt_constructor(ty: Ty<'_>, adt: &AdtDef) -> bool {
+ +    ty.walk().any(|inner| match inner.unpack() {
+ +        GenericArgKind::Type(inner_ty) => inner_ty.ty_adt_def() == Some(adt),
+ +        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
+ +    })
+ +}
+ +
+ +/// Resolves `<T as Iterator>::Item` for `T`
+ +/// Do not invoke without first verifying that the type implements `Iterator`
+ +pub fn get_iterator_item_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+ +    cx.tcx
+ +        .get_diagnostic_item(sym::Iterator)
+ +        .and_then(|iter_did| get_associated_type(cx, ty, iter_did, "Item"))
+ +}
+ +
+ +/// Returns the associated type `name` for `ty` as an implementation of `trait_id`.
+ +/// Do not invoke without first verifying that the type implements the trait.
+ +pub fn get_associated_type<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    ty: Ty<'tcx>,
+ +    trait_id: DefId,
+ +    name: &str,
+ +) -> Option<Ty<'tcx>> {
+ +    cx.tcx
+ +        .associated_items(trait_id)
+ +        .find_by_name_and_kind(cx.tcx, Ident::from_str(name), ty::AssocKind::Type, trait_id)
+ +        .map(|assoc| {
+ +            let proj = cx.tcx.mk_projection(assoc.def_id, cx.tcx.mk_substs_trait(ty, &[]));
+ +            cx.tcx.normalize_erasing_regions(cx.param_env, proj)
+ +        })
+ +}
+ +
+ +/// Returns true if ty has `iter` or `iter_mut` methods
+ +pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
+ +    // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
+ +    // exists and has the desired signature. Unfortunately FnCtxt is not exported
+ +    // so we can't use its `lookup_method` method.
+ +    let into_iter_collections: &[Symbol] = &[
+ +        sym::Vec,
+ +        sym::Option,
+ +        sym::Result,
+ +        sym::BTreeMap,
+ +        sym::BTreeSet,
+ +        sym::VecDeque,
+ +        sym::LinkedList,
+ +        sym::BinaryHeap,
+ +        sym::HashSet,
+ +        sym::HashMap,
+ +        sym::PathBuf,
+ +        sym::Path,
+ +        sym::Receiver,
+ +    ];
+ +
+ +    let ty_to_check = match probably_ref_ty.kind() {
+ +        ty::Ref(_, ty_to_check, _) => ty_to_check,
+ +        _ => probably_ref_ty,
+ +    };
+ +
+ +    let def_id = match ty_to_check.kind() {
+ +        ty::Array(..) => return Some(sym::array),
+ +        ty::Slice(..) => return Some(sym::slice),
+ +        ty::Adt(adt, _) => adt.did,
+ +        _ => return None,
+ +    };
+ +
+ +    for &name in into_iter_collections {
+ +        if cx.tcx.is_diagnostic_item(name, def_id) {
+ +            return Some(cx.tcx.item_name(def_id));
+ +        }
+ +    }
+ +    None
+ +}
+ +
+ +/// Checks whether a type implements a trait.
+ +/// The function returns false in case the type contains an inference variable.
+ +///
+ +/// See:
+ +/// * [`get_trait_def_id`](super::get_trait_def_id) to get a trait [`DefId`].
+ +/// * [Common tools for writing lints] for an example how to use this function and other options.
+ +///
+ +/// [Common tools for writing lints]: https://github.com/rust-lang/rust-clippy/blob/master/doc/common_tools_writing_lints.md#checking-if-a-type-implements-a-specific-trait
+ +pub fn implements_trait<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    ty: Ty<'tcx>,
+ +    trait_id: DefId,
+ +    ty_params: &[GenericArg<'tcx>],
+ +) -> bool {
+ +    // Clippy shouldn't have infer types
+ +    assert!(!ty.needs_infer());
+ +
+ +    let ty = cx.tcx.erase_regions(ty);
+ +    if ty.has_escaping_bound_vars() {
+ +        return false;
+ +    }
+ +    let ty_params = cx.tcx.mk_substs(ty_params.iter());
+ +    cx.tcx.infer_ctxt().enter(|infcx| {
+ +        infcx
+ +            .type_implements_trait(trait_id, ty, ty_params, cx.param_env)
+ +            .must_apply_modulo_regions()
+ +    })
+ +}
+ +
+ +/// Checks whether this type implements `Drop`.
+ +pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+ +    match ty.ty_adt_def() {
+ +        Some(def) => def.has_dtor(cx.tcx),
+ +        None => false,
+ +    }
+ +}
+ +
+ +// Returns whether the type has #[must_use] attribute
+ +pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+ +    match ty.kind() {
+ +        ty::Adt(adt, _) => must_use_attr(cx.tcx.get_attrs(adt.did)).is_some(),
+ +        ty::Foreign(ref did) => must_use_attr(cx.tcx.get_attrs(*did)).is_some(),
+ +        ty::Slice(ty) | ty::Array(ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) | ty::Ref(_, ty, _) => {
+ +            // for the Array case we don't need to care for the len == 0 case
+ +            // because we don't want to lint functions returning empty arrays
+ +            is_must_use_ty(cx, *ty)
+ +        },
+ +        ty::Tuple(substs) => substs.types().any(|ty| is_must_use_ty(cx, ty)),
+ +        ty::Opaque(ref def_id, _) => {
+ +            for (predicate, _) in cx.tcx.explicit_item_bounds(*def_id) {
+ +                if let ty::PredicateKind::Trait(trait_predicate) = predicate.kind().skip_binder() {
+ +                    if must_use_attr(cx.tcx.get_attrs(trait_predicate.trait_ref.def_id)).is_some() {
+ +                        return true;
+ +                    }
+ +                }
+ +            }
+ +            false
+ +        },
+ +        ty::Dynamic(binder, _) => {
+ +            for predicate in binder.iter() {
+ +                if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
+ +                    if must_use_attr(cx.tcx.get_attrs(trait_ref.def_id)).is_some() {
+ +                        return true;
+ +                    }
+ +                }
+ +            }
+ +            false
+ +        },
+ +        _ => false,
+ +    }
+ +}
+ +
+ +// FIXME: Per https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/infer/at/struct.At.html#method.normalize
+ +// this function can be removed once the `normalize` method does not panic when normalization does
+ +// not succeed
+ +/// Checks if `Ty` is normalizable. This function is useful
+ +/// to avoid crashes on `layout_of`.
+ +pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
+ +    is_normalizable_helper(cx, param_env, ty, &mut FxHashMap::default())
+ +}
+ +
+ +fn is_normalizable_helper<'tcx>(
+ +    cx: &LateContext<'tcx>,
+ +    param_env: ty::ParamEnv<'tcx>,
+ +    ty: Ty<'tcx>,
+ +    cache: &mut FxHashMap<Ty<'tcx>, bool>,
+ +) -> bool {
+ +    if let Some(&cached_result) = cache.get(ty) {
+ +        return cached_result;
+ +    }
+ +    // prevent recursive loops, false-negative is better than endless loop leading to stack overflow
+ +    cache.insert(ty, false);
+ +    let result = cx.tcx.infer_ctxt().enter(|infcx| {
+ +        let cause = rustc_middle::traits::ObligationCause::dummy();
+ +        if infcx.at(&cause, param_env).normalize(ty).is_ok() {
+ +            match ty.kind() {
+ +                ty::Adt(def, substs) => def.variants.iter().all(|variant| {
+ +                    variant
+ +                        .fields
+ +                        .iter()
+ +                        .all(|field| is_normalizable_helper(cx, param_env, field.ty(cx.tcx, substs), cache))
+ +                }),
+ +                _ => ty.walk().all(|generic_arg| match generic_arg.unpack() {
+ +                    GenericArgKind::Type(inner_ty) if inner_ty != ty => {
+ +                        is_normalizable_helper(cx, param_env, inner_ty, cache)
+ +                    },
+ +                    _ => true, // if inner_ty == ty, we've already checked it
+ +                }),
+ +            }
+ +        } else {
+ +            false
+ +        }
+ +    });
+ +    cache.insert(ty, result);
+ +    result
+ +}
+ +
+ +/// Returns `true` if the given type is a non aggregate primitive (a `bool` or `char`, any
+ +/// integer or floating-point number type). For checking aggregation of primitive types (e.g.
+ +/// tuples and slices of primitive type) see `is_recursively_primitive_type`
+ +pub fn is_non_aggregate_primitive_type(ty: Ty<'_>) -> bool {
+ +    matches!(ty.kind(), ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_))
+ +}
+ +
+ +/// Returns `true` if the given type is a primitive (a `bool` or `char`, any integer or
+ +/// floating-point number type, a `str`, or an array, slice, or tuple of those types).
+ +pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
+ +    match ty.kind() {
+ +        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
+ +        ty::Ref(_, inner, _) if *inner.kind() == ty::Str => true,
+ +        ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
+ +        ty::Tuple(inner_types) => inner_types.types().all(is_recursively_primitive_type),
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Checks if the type is a reference equals to a diagnostic item
+ +pub fn is_type_ref_to_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
+ +    match ty.kind() {
+ +        ty::Ref(_, ref_ty, _) => match ref_ty.kind() {
+ +            ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
+ +            _ => false,
+ +        },
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Checks if the type is equal to a diagnostic item. To check if a type implements a
+ +/// trait marked with a diagnostic item use [`implements_trait`].
+ +///
+ +/// For a further exploitation what diagnostic items are see [diagnostic items] in
+ +/// rustc-dev-guide.
+ +///
+ +/// ---
+ +///
+ +/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
+ +///
+ +/// [Diagnostic Items]: https://rustc-dev-guide.rust-lang.org/diagnostics/diagnostic-items.html
+ +pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
+ +    match ty.kind() {
+ +        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did),
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Checks if the type is equal to a lang item.
+ +///
+ +/// Returns `false` if the `LangItem` is not defined.
+ +pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangItem) -> bool {
+ +    match ty.kind() {
+ +        ty::Adt(adt, _) => cx.tcx.lang_items().require(lang_item).map_or(false, |li| li == adt.did),
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Return `true` if the passed `typ` is `isize` or `usize`.
+ +pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
+ +    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
+ +}
+ +
+ +/// Checks if type is struct, enum or union type with the given def path.
+ +///
+ +/// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
+ +/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
+ +pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
+ +    match ty.kind() {
+ +        ty::Adt(adt, _) => match_def_path(cx, adt.did, path),
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Peels off all references on the type. Returns the underlying type and the number of references
+ +/// removed.
+ +pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
+ +    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
+ +        if let ty::Ref(_, ty, _) = ty.kind() {
+ +            peel(ty, count + 1)
+ +        } else {
+ +            (ty, count)
+ +        }
+ +    }
+ +    peel(ty, 0)
+ +}
+ +
+ +/// Peels off all references on the type.Returns the underlying type, the number of references
+ +/// removed, and whether the pointer is ultimately mutable or not.
+ +pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
+ +    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
+ +        match ty.kind() {
+ +            ty::Ref(_, ty, Mutability::Mut) => f(ty, count + 1, mutability),
+ +            ty::Ref(_, ty, Mutability::Not) => f(ty, count + 1, Mutability::Not),
+ +            _ => (ty, count, mutability),
+ +        }
+ +    }
+ +    f(ty, 0, Mutability::Mut)
+ +}
+ +
+ +/// Returns `true` if the given type is an `unsafe` function.
+ +pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+ +    match ty.kind() {
+ +        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Returns the base type for HIR references and pointers.
+ +pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
+ +    match ty.kind {
+ +        TyKind::Ptr(ref mut_ty) | TyKind::Rptr(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
+ +        _ => ty,
+ +    }
+ +}
+ +
+ +/// Returns the base type for references and raw pointers, and count reference
+ +/// depth.
+ +pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
+ +    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
+ +        match ty.kind() {
+ +            ty::Ref(_, ty, _) => inner(ty, depth + 1),
+ +            _ => (ty, depth),
+ +        }
+ +    }
+ +    inner(ty, 0)
+ +}
+ +
+ +/// Returns `true` if types `a` and `b` are same types having same `Const` generic args,
+ +/// otherwise returns `false`
+ +pub fn same_type_and_consts<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
+ +    match (&a.kind(), &b.kind()) {
+ +        (&ty::Adt(did_a, substs_a), &ty::Adt(did_b, substs_b)) => {
+ +            if did_a != did_b {
+ +                return false;
+ +            }
+ +
+ +            substs_a
+ +                .iter()
+ +                .zip(substs_b.iter())
+ +                .all(|(arg_a, arg_b)| match (arg_a.unpack(), arg_b.unpack()) {
+ +                    (GenericArgKind::Const(inner_a), GenericArgKind::Const(inner_b)) => inner_a == inner_b,
+ +                    (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => {
+ +                        same_type_and_consts(type_a, type_b)
+ +                    },
+ +                    _ => true,
+ +                })
+ +        },
+ +        _ => a == b,
+ +    }
+ +}
+ +
+ +/// Checks if a given type looks safe to be uninitialized.
+ +pub fn is_uninit_value_valid_for_ty(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+ +    match ty.kind() {
+ +        ty::Array(component, _) => is_uninit_value_valid_for_ty(cx, component),
+ +        ty::Tuple(types) => types.types().all(|ty| is_uninit_value_valid_for_ty(cx, ty)),
+ +        ty::Adt(adt, _) => cx.tcx.lang_items().maybe_uninit() == Some(adt.did),
+ +        _ => false,
+ +    }
+ +}
+ +
+ +/// Gets an iterator over all predicates which apply to the given item.
+ +pub fn all_predicates_of(tcx: TyCtxt<'_>, id: DefId) -> impl Iterator<Item = &(Predicate<'_>, Span)> {
+ +    let mut next_id = Some(id);
+ +    iter::from_fn(move || {
+ +        next_id.take().map(|id| {
+ +            let preds = tcx.predicates_of(id);
+ +            next_id = preds.parent;
+ +            preds.predicates.iter()
+ +        })
+ +    })
+ +    .flatten()
+ +}
+ +
+ +/// A signature for a function like type.
+ +#[derive(Clone, Copy)]
+ +pub enum ExprFnSig<'tcx> {
+ +    Sig(Binder<'tcx, FnSig<'tcx>>),
+ +    Closure(Binder<'tcx, FnSig<'tcx>>),
+ +    Trait(Binder<'tcx, Ty<'tcx>>, Option<Binder<'tcx, Ty<'tcx>>>),
+ +}
+ +impl<'tcx> ExprFnSig<'tcx> {
+ +    /// Gets the argument type at the given offset.
+ +    pub fn input(self, i: usize) -> Binder<'tcx, Ty<'tcx>> {
+ +        match self {
+ +            Self::Sig(sig) => sig.input(i),
+ +            Self::Closure(sig) => sig.input(0).map_bound(|ty| ty.tuple_element_ty(i).unwrap()),
+ +            Self::Trait(inputs, _) => inputs.map_bound(|ty| ty.tuple_element_ty(i).unwrap()),
+ +        }
+ +    }
+ +
+ +    /// Gets the result type, if one could be found. Note that the result type of a trait may not be
+ +    /// specified.
+ +    pub fn output(self) -> Option<Binder<'tcx, Ty<'tcx>>> {
+ +        match self {
+ +            Self::Sig(sig) | Self::Closure(sig) => Some(sig.output()),
+ +            Self::Trait(_, output) => output,
+ +        }
+ +    }
+ +}
+ +
+ +/// If the expression is function like, get the signature for it.
+ +pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnSig<'tcx>> {
++    if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = path_res(cx, expr) {
+ +        Some(ExprFnSig::Sig(cx.tcx.fn_sig(id)))
+ +    } else {
+ +        let ty = cx.typeck_results().expr_ty_adjusted(expr).peel_refs();
+ +        match *ty.kind() {
+ +            ty::Closure(_, subs) => Some(ExprFnSig::Closure(subs.as_closure().sig())),
+ +            ty::FnDef(id, subs) => Some(ExprFnSig::Sig(cx.tcx.fn_sig(id).subst(cx.tcx, subs))),
+ +            ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig)),
+ +            ty::Dynamic(bounds, _) => {
+ +                let lang_items = cx.tcx.lang_items();
+ +                match bounds.principal() {
+ +                    Some(bound)
+ +                        if Some(bound.def_id()) == lang_items.fn_trait()
+ +                            || Some(bound.def_id()) == lang_items.fn_once_trait()
+ +                            || Some(bound.def_id()) == lang_items.fn_mut_trait() =>
+ +                    {
+ +                        let output = bounds
+ +                            .projection_bounds()
+ +                            .find(|p| lang_items.fn_once_output().map_or(false, |id| id == p.item_def_id()))
+ +                            .map(|p| p.map_bound(|p| p.term.ty().expect("return type was a const")));
+ +                        Some(ExprFnSig::Trait(bound.map_bound(|b| b.substs.type_at(0)), output))
+ +                    },
+ +                    _ => None,
+ +                }
+ +            },
+ +            ty::Param(_) | ty::Projection(..) => {
+ +                let mut inputs = None;
+ +                let mut output = None;
+ +                let lang_items = cx.tcx.lang_items();
+ +
+ +                for (pred, _) in all_predicates_of(cx.tcx, cx.typeck_results().hir_owner.to_def_id()) {
+ +                    let mut is_input = false;
+ +                    if let Some(ty) = pred
+ +                        .kind()
+ +                        .map_bound(|pred| match pred {
+ +                            PredicateKind::Trait(p)
+ +                                if (lang_items.fn_trait() == Some(p.def_id())
+ +                                    || lang_items.fn_mut_trait() == Some(p.def_id())
+ +                                    || lang_items.fn_once_trait() == Some(p.def_id()))
+ +                                    && p.self_ty() == ty =>
+ +                            {
+ +                                is_input = true;
+ +                                Some(p.trait_ref.substs.type_at(1))
+ +                            },
+ +                            PredicateKind::Projection(p)
+ +                                if Some(p.projection_ty.item_def_id) == lang_items.fn_once_output()
+ +                                    && p.projection_ty.self_ty() == ty =>
+ +                            {
+ +                                is_input = false;
+ +                                p.term.ty()
+ +                            },
+ +                            _ => None,
+ +                        })
+ +                        .transpose()
+ +                    {
+ +                        if is_input && inputs.is_none() {
+ +                            inputs = Some(ty);
+ +                        } else if !is_input && output.is_none() {
+ +                            output = Some(ty);
+ +                        } else {
+ +                            // Multiple different fn trait impls. Is this even allowed?
+ +                            return None;
+ +                        }
+ +                    }
+ +                }
+ +
+ +                inputs.map(|ty| ExprFnSig::Trait(ty, output))
+ +            },
+ +            _ => None,
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/doc/common_tools_writing_lints.md

index 6c8a3dc418b1517f4156a7c58a0146f4b9ca2a0a,0000000000000000000000000000000000000000..36c454745ba06a5cc91cccb178fc987950c830f4

mode 100644,000000..100644
--- 1/src/tools/clippy/doc/common_tools_writing_lints.md
--- /dev/null
+++ b/src/tools/clippy/doc/common_tools_writing_lints.md
@@@ -1,265 -1,0 +1,269 @@@
- - `differing_macro_contexts()`: returns true if the two given spans are not from the same context
+ +# Common tools for writing lints
+ +
+ +You may need following tooltips to catch up with common operations.
+ +
+ +- [Common tools for writing lints](#common-tools-for-writing-lints)
+ +  - [Retrieving the type of an expression](#retrieving-the-type-of-an-expression)
+ +  - [Checking if an expr is calling a specific method](#checking-if-an-expr-is-calling-a-specific-method)
+ +  - [Checking for a specific type](#checking-for-a-specific-type)
+ +  - [Checking if a type implements a specific trait](#checking-if-a-type-implements-a-specific-trait)
+ +  - [Checking if a type defines a specific method](#checking-if-a-type-defines-a-specific-method)
+ +  - [Dealing with macros](#dealing-with-macros-and-expansions)
+ +
+ +Useful Rustc dev guide links:
+ +- [Stages of compilation](https://rustc-dev-guide.rust-lang.org/compiler-src.html#the-main-stages-of-compilation)
+ +- [Diagnostic items](https://rustc-dev-guide.rust-lang.org/diagnostics/diagnostic-items.html)
+ +- [Type checking](https://rustc-dev-guide.rust-lang.org/type-checking.html)
+ +- [Ty module](https://rustc-dev-guide.rust-lang.org/ty.html)
+ +
+ +## Retrieving the type of an expression
+ +
+ +Sometimes you may want to retrieve the type `Ty` of an expression `Expr`, for example to answer following questions:
+ +
+ +- which type does this expression correspond to (using its [`TyKind`][TyKind])?
+ +- is it a sized type?
+ +- is it a primitive type?
+ +- does it implement a trait?
+ +
+ +This operation is performed using the [`expr_ty()`][expr_ty] method from the [`TypeckResults`][TypeckResults] struct,
+ +that gives you access to the underlying structure [`TyS`][TyS].
+ +
+ +Example of use:
+ +```rust
+ +impl LateLintPass<'_> for MyStructLint {
+ +    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+ +        // Get type of `expr`
+ +        let ty = cx.typeck_results().expr_ty(expr);
+ +        // Match its kind to enter its type
+ +        match ty.kind {
+ +            ty::Adt(adt_def, _) if adt_def.is_struct() => println!("Our `expr` is a struct!"),
+ +            _ => ()
+ +        }
+ +    }
+ +}
+ +```
+ +
+ +Similarly in [`TypeckResults`][TypeckResults] methods, you have the [`pat_ty()`][pat_ty] method
+ +to retrieve a type from a pattern.
+ +
+ +Two noticeable items here:
+ +- `cx` is the lint context [`LateContext`][LateContext]. The two most useful
+ +  data structures in this context are `tcx` and the `TypeckResults` returned by
+ +  `LateContext::typeck_results`, allowing us to jump to type definitions and
+ +  other compilation stages such as HIR.
+ +- `typeck_results`'s return value is [`TypeckResults`][TypeckResults] and is
+ +  created by type checking step, it includes useful information such as types
+ +  of expressions, ways to resolve methods and so on.
+ +
+ +## Checking if an expr is calling a specific method
+ +
+ +Starting with an `expr`, you can check whether it is calling a specific method `some_method`:
+ +
+ +```rust
+ +impl<'tcx> LateLintPass<'tcx> for MyStructLint {
+ +    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) {
+ +        if_chain! {
+ +            // Check our expr is calling a method
+ +            if let hir::ExprKind::MethodCall(path, _, [_self_arg, ..]) = &expr.kind;
+ +            // Check the name of this method is `some_method`
+ +            if path.ident.name == sym!(some_method);
+ +            // Optionally, check the type of the self argument.
+ +            // - See "Checking for a specific type"
+ +            then {
+ +                // ...
+ +            }
+ +        }
+ +    }
+ +}
+ +```
+ +
+ +## Checking for a specific type
+ +
+ +There are three ways to check if an expression type is a specific type we want to check for.
+ +All of these methods only check for the base type, generic arguments have to be checked separately.
+ +
+ +```rust
+ +use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
+ +use clippy_utils::{paths, match_def_path};
+ +use rustc_span::symbol::sym;
+ +use rustc_hir::LangItem;
+ +
+ +impl LateLintPass<'_> for MyStructLint {
+ +    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+ +        // Getting the expression type
+ +        let ty = cx.typeck_results().expr_ty(expr);
+ +
+ +        // 1. Using diagnostic items
+ +        // The last argument is the diagnostic item to check for
+ +        if is_type_diagnostic_item(cx, ty, sym::Option) {
+ +            // The type is an `Option`
+ +        }
+ +
+ +        // 2. Using lang items
+ +        if is_type_lang_item(cx, ty, LangItem::RangeFull) {
+ +            // The type is a full range like `.drain(..)`
+ +        }
+ +
+ +        // 3. Using the type path
+ +        // This method should be avoided if possible
+ +        if match_def_path(cx, def_id, &paths::RESULT) {
+ +            // The type is a `core::result::Result`
+ +        }
+ +    }
+ +}
+ +```
+ +
+ +Prefer using diagnostic items and lang items where possible.
+ +
+ +## Checking if a type implements a specific trait
+ +
+ +There are three ways to do this, depending on if the target trait has a diagnostic item, lang item or neither.
+ +
+ +```rust
+ +use clippy_utils::{implements_trait, is_trait_method, match_trait_method, paths};
+ +use rustc_span::symbol::sym;
+ +
+ +impl LateLintPass<'_> for MyStructLint {
+ +    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+ +        // 1. Using diagnostic items with the expression
+ +        // we use `is_trait_method` function from Clippy's utils
+ +        if is_trait_method(cx, expr, sym::Iterator) {
+ +            // method call in `expr` belongs to `Iterator` trait
+ +        }
+ +
+ +        // 2. Using lang items with the expression type
+ +        let ty = cx.typeck_results().expr_ty(expr);
+ +        if cx.tcx.lang_items()
+ +            // we are looking for the `DefId` of `Drop` trait in lang items
+ +            .drop_trait()
+ +            // then we use it with our type `ty` by calling `implements_trait` from Clippy's utils
+ +            .map_or(false, |id| implements_trait(cx, ty, id, &[])) {
+ +                // `expr` implements `Drop` trait
+ +            }
+ +
+ +        // 3. Using the type path with the expression
+ +        // we use `match_trait_method` function from Clippy's utils
+ +        // (This method should be avoided if possible)
+ +        if match_trait_method(cx, expr, &paths::INTO) {
+ +            // `expr` implements `Into` trait
+ +        }
+ +    }
+ +}
+ +```
+ +
+ +> Prefer using diagnostic and lang items, if the target trait has one.
+ +
+ +We access lang items through the type context `tcx`. `tcx` is of type [`TyCtxt`][TyCtxt] and is defined in the `rustc_middle` crate.
+ +A list of defined paths for Clippy can be found in [paths.rs][paths]
+ +
+ +## Checking if a type defines a specific method
+ +
+ +To check if our type defines a method called `some_method`:
+ +
+ +```rust
+ +use clippy_utils::{is_type_diagnostic_item, return_ty};
+ +
+ +impl<'tcx> LateLintPass<'tcx> for MyTypeImpl {
+ +    fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) {
+ +        if_chain! {
+ +            // Check if item is a method/function
+ +            if let ImplItemKind::Fn(ref signature, _) = impl_item.kind;
+ +            // Check the method is named `some_method`
+ +            if impl_item.ident.name == sym!(some_method);
+ +            // We can also check it has a parameter `self`
+ +            if signature.decl.implicit_self.has_implicit_self();
+ +            // We can go further and even check if its return type is `String`
+ +            if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym!(string_type));
+ +            then {
+ +                // ...
+ +            }
+ +        }
+ +    }
+ +}
+ +```
+ +
+ +## Dealing with macros and expansions
+ +
+ +Keep in mind that macros are already expanded and desugaring is already applied
+ +to the code representation that you are working with in Clippy. This unfortunately causes a lot of
+ +false positives because macro expansions are "invisible" unless you actively check for them.
+ +Generally speaking, code with macro expansions should just be ignored by Clippy because that code can be
+ +dynamic in ways that are difficult or impossible to see.
+ +Use the following functions to deal with macros:
+ +
+ +- `span.from_expansion()`: detects if a span is from macro expansion or desugaring.
+ +  Checking this is a common first step in a lint.
+ +
+ +   ```rust
+ +   if expr.span.from_expansion() {
+ +       // just forget it
+ +       return;
+ +   }
+ +   ```
+ +
+ +- `span.ctxt()`: the span's context represents whether it is from expansion, and if so, which macro call expanded it.
+ +   It is sometimes useful to check if the context of two spans are equal.
+ +
+ +   ```rust
+ +   // expands to `1 + 0`, but don't lint
+ +   1 + mac!()
+ +   ```
+ +   ```rust
+ +   if left.span.ctxt() != right.span.ctxt() {
+ +       // the coder most likely cannot modify this expression
+ +       return;
+ +   }
+ +   ```
+ +  Note: Code that is not from expansion is in the "root" context. So any spans where `from_expansion` returns `true` can
+ +  be assumed to have the same context. And so just using `span.from_expansion()` is often good enough.
+ +
+ +
+ +- `in_external_macro(span)`: detect if the given span is from a macro defined in a foreign crate.
+ +   If you want the lint to work with macro-generated code, this is the next line of defense to avoid macros
+ +   not defined in the current crate. It doesn't make sense to lint code that the coder can't change.
+ +
+ +   You may want to use it for example to not start linting in macros from other crates
+ +
+ +   ```rust
+ +   #[macro_use]
+ +   extern crate a_crate_with_macros;
+ +
+ +   // `foo` is defined in `a_crate_with_macros`
+ +   foo!("bar");
+ +
+ +   // if we lint the `match` of `foo` call and test its span
+ +   assert_eq!(in_external_macro(cx.sess(), match_span), true);
+ +   ```
+ +
-    assert_eq!(differing_macro_contexts(x_is_some_span, x_unwrap_span), true);
++- `span.ctxt()`: the span's context represents whether it is from expansion, and if so, what expanded it
++
++One thing `SpanContext` is useful for is to check if two spans are in the same context. For example,
++in `a == b`, `a` and `b` have the same context. In a `macro_rules!` with `a == $b`, `$b` is expanded to some
++expression with a different context from `a`.
+ +
+ +   ```rust
+ +   macro_rules! m {
+ +       ($a:expr, $b:expr) => {
+ +           if $a.is_some() {
+ +               $b;
+ +           }
+ +       }
+ +   }
+ +
+ +   let x: Option<u32> = Some(42);
+ +   m!(x, x.unwrap());
+ +
+ +   // These spans are not from the same context
+ +   // x.is_some() is from inside the macro
+ +   // x.unwrap() is from outside the macro
++   assert_eq!(x_is_some_span.ctxt(), x_unwrap_span.ctxt());
+ +   ```
+ +
+ +[TyS]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyS.html
+ +[TyKind]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/enum.TyKind.html
+ +[TypeckResults]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TypeckResults.html
+ +[expr_ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TypeckResults.html#method.expr_ty
+ +[LateContext]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LateContext.html
+ +[TyCtxt]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TyCtxt.html
+ +[pat_ty]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/context/struct.TypeckResults.html#method.pat_ty
+ +[paths]: ../clippy_utils/src/paths.rs
diff --cc src/tools/clippy/rust-toolchain

index e23dc73ab08c1233e51d9b926923e2790fbabb5c,0000000000000000000000000000000000000000..f065f0bffc7bf70fc934bec08ab33408bad2874c

mode 100644,000000..100644
--- 1/src/tools/clippy/rust-toolchain
--- /dev/null
+++ b/src/tools/clippy/rust-toolchain
@@@ -1,3 -1,0 +1,3 @@@
- channel = "nightly-2022-01-27"
+ +[toolchain]
++channel = "nightly-2022-02-10"
+ +components = ["cargo", "llvm-tools-preview", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
diff --cc src/tools/clippy/tests/compile-test.rs

index 6505028db9fadc1f5e75e62e468bcde1d805d737,0000000000000000000000000000000000000000..a82ff182839314d625cd0078cbe2d17fda1fe670

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/compile-test.rs
--- /dev/null
+++ b/src/tools/clippy/tests/compile-test.rs
@@@ -1,364 -1,0 +1,350 @@@
- fn extern_flags() -> String {
+ +#![feature(test)] // compiletest_rs requires this attribute
+ +#![feature(once_cell)]
+ +#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+ +#![warn(rust_2018_idioms, unused_lifetimes)]
+ +
+ +use compiletest_rs as compiletest;
+ +use compiletest_rs::common::Mode as TestMode;
+ +
+ +use std::collections::HashMap;
+ +use std::env::{self, remove_var, set_var, var_os};
+ +use std::ffi::{OsStr, OsString};
+ +use std::fs;
+ +use std::io;
++use std::lazy::SyncLazy;
+ +use std::path::{Path, PathBuf};
+ +use test_utils::IS_RUSTC_TEST_SUITE;
+ +
+ +mod test_utils;
+ +
+ +// whether to run internal tests or not
+ +const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal");
+ +
+ +/// All crates used in UI tests are listed here
+ +static TEST_DEPENDENCIES: &[&str] = &[
+ +    "clippy_utils",
+ +    "derive_new",
+ +    "futures",
+ +    "if_chain",
+ +    "itertools",
+ +    "quote",
+ +    "regex",
+ +    "serde",
+ +    "serde_derive",
+ +    "syn",
+ +    "tokio",
+ +    "parking_lot",
+ +];
+ +
+ +// Test dependencies may need an `extern crate` here to ensure that they show up
+ +// in the depinfo file (otherwise cargo thinks they are unused)
+ +#[allow(unused_extern_crates)]
+ +extern crate clippy_utils;
+ +#[allow(unused_extern_crates)]
+ +extern crate derive_new;
+ +#[allow(unused_extern_crates)]
+ +extern crate futures;
+ +#[allow(unused_extern_crates)]
+ +extern crate if_chain;
+ +#[allow(unused_extern_crates)]
+ +extern crate itertools;
+ +#[allow(unused_extern_crates)]
+ +extern crate parking_lot;
+ +#[allow(unused_extern_crates)]
+ +extern crate quote;
+ +#[allow(unused_extern_crates)]
+ +extern crate syn;
+ +#[allow(unused_extern_crates)]
+ +extern crate tokio;
+ +
+ +/// Produces a string with an `--extern` flag for all UI test crate
+ +/// dependencies.
+ +///
+ +/// The dependency files are located by parsing the depinfo file for this test
+ +/// module. This assumes the `-Z binary-dep-depinfo` flag is enabled. All test
+ +/// dependencies must be added to Cargo.toml at the project root. Test
+ +/// dependencies that are not *directly* used by this test module require an
+ +/// `extern crate` declaration.
-         std::fs::read_to_string(path).unwrap()
++static EXTERN_FLAGS: SyncLazy<String> = SyncLazy::new(|| {
+ +    let current_exe_depinfo = {
+ +        let mut path = env::current_exe().unwrap();
+ +        path.set_extension("d");
- }
++        fs::read_to_string(path).unwrap()
+ +    };
+ +    let mut crates: HashMap<&str, &str> = HashMap::with_capacity(TEST_DEPENDENCIES.len());
+ +    for line in current_exe_depinfo.lines() {
+ +        // each dependency is expected to have a Makefile rule like `/path/to/crate-hash.rlib:`
+ +        let parse_name_path = || {
+ +            if line.starts_with(char::is_whitespace) {
+ +                return None;
+ +            }
+ +            let path_str = line.strip_suffix(':')?;
+ +            let path = Path::new(path_str);
+ +            if !matches!(path.extension()?.to_str()?, "rlib" | "so" | "dylib" | "dll") {
+ +                return None;
+ +            }
+ +            let (name, _hash) = path.file_stem()?.to_str()?.rsplit_once('-')?;
+ +            // the "lib" prefix is not present for dll files
+ +            let name = name.strip_prefix("lib").unwrap_or(name);
+ +            Some((name, path_str))
+ +        };
+ +        if let Some((name, path)) = parse_name_path() {
+ +            if TEST_DEPENDENCIES.contains(&name) {
+ +                // A dependency may be listed twice if it is available in sysroot,
+ +                // and the sysroot dependencies are listed first. As of the writing,
+ +                // this only seems to apply to if_chain.
+ +                crates.insert(name, path);
+ +            }
+ +        }
+ +    }
+ +    let not_found: Vec<&str> = TEST_DEPENDENCIES
+ +        .iter()
+ +        .copied()
+ +        .filter(|n| !crates.contains_key(n))
+ +        .collect();
+ +    assert!(
+ +        not_found.is_empty(),
+ +        "dependencies not found in depinfo: {:?}\n\
+ +        help: Make sure the `-Z binary-dep-depinfo` rust flag is enabled\n\
+ +        help: Try adding to dev-dependencies in Cargo.toml",
+ +        not_found
+ +    );
+ +    crates
+ +        .into_iter()
+ +        .map(|(name, path)| format!(" --extern {}={}", name, path))
+ +        .collect()
- fn default_config() -> compiletest::Config {
++});
+ +
-         config.filters = filters.split(',').map(std::string::ToString::to_string).collect();
++fn base_config(test_dir: &str) -> compiletest::Config {
+ +    let mut config = compiletest::Config {
+ +        edition: Some("2021".into()),
++        mode: TestMode::Ui,
+ +        ..compiletest::Config::default()
+ +    };
+ +
+ +    if let Ok(filters) = env::var("TESTNAME") {
-     let current_exe_path = std::env::current_exe().unwrap();
++        config.filters = filters.split(',').map(ToString::to_string).collect();
+ +    }
+ +
+ +    if let Some(path) = option_env!("RUSTC_LIB_PATH") {
+ +        let path = PathBuf::from(path);
+ +        config.run_lib_path = path.clone();
+ +        config.compile_lib_path = path;
+ +    }
-         extern_flags(),
++    let current_exe_path = env::current_exe().unwrap();
+ +    let deps_path = current_exe_path.parent().unwrap();
+ +    let profile_path = deps_path.parent().unwrap();
+ +
+ +    // Using `-L dependency={}` enforces that external dependencies are added with `--extern`.
+ +    // This is valuable because a) it allows us to monitor what external dependencies are used
+ +    // and b) it ensures that conflicting rlibs are resolved properly.
+ +    let host_libs = option_env!("HOST_LIBS")
+ +        .map(|p| format!(" -L dependency={}", Path::new(p).join("deps").display()))
+ +        .unwrap_or_default();
+ +    config.target_rustcflags = Some(format!(
+ +        "--emit=metadata -Dwarnings -Zui-testing -L dependency={}{}{}",
+ +        deps_path.display(),
+ +        host_libs,
-     config.build_base = profile_path.join("test");
++        &*EXTERN_FLAGS,
+ +    ));
+ +
- fn run_ui(cfg: &mut compiletest::Config) {
-     cfg.mode = TestMode::Ui;
-     cfg.src_base = Path::new("tests").join("ui");
++    config.src_base = Path::new("tests").join(test_dir);
++    config.build_base = profile_path.join("test").join(test_dir);
+ +    config.rustc_path = profile_path.join(if cfg!(windows) {
+ +        "clippy-driver.exe"
+ +    } else {
+ +        "clippy-driver"
+ +    });
+ +    config
+ +}
+ +
-     let _g = VarGuard::set("CARGO_MANIFEST_DIR", std::fs::canonicalize("tests").unwrap());
-     compiletest::run_tests(cfg);
- }
- 
- fn run_ui_test(cfg: &mut compiletest::Config) {
-     cfg.mode = TestMode::Ui;
-     cfg.src_base = Path::new("tests").join("ui_test");
-     let _g = VarGuard::set("CARGO_MANIFEST_DIR", std::fs::canonicalize("tests").unwrap());
-     let rustcflags = cfg.target_rustcflags.get_or_insert_with(Default::default);
-     let len = rustcflags.len();
-     rustcflags.push_str(" --test");
-     compiletest::run_tests(cfg);
-     if let Some(ref mut flags) = &mut cfg.target_rustcflags {
-         flags.truncate(len);
-     }
++fn run_ui() {
++    let config = base_config("ui");
+ +    // use tests/clippy.toml
- fn run_internal_tests(cfg: &mut compiletest::Config) {
++    let _g = VarGuard::set("CARGO_MANIFEST_DIR", fs::canonicalize("tests").unwrap());
++    compiletest::run_tests(&config);
+ +}
+ +
-     cfg.mode = TestMode::Ui;
-     cfg.src_base = Path::new("tests").join("ui-internal");
-     compiletest::run_tests(cfg);
++fn run_internal_tests() {
+ +    // only run internal tests with the internal-tests feature
+ +    if !RUN_INTERNAL_TESTS {
+ +        return;
+ +    }
- fn run_ui_toml(config: &mut compiletest::Config) {
++    let config = base_config("ui-internal");
++    compiletest::run_tests(&config);
+ +}
+ +
-     config.mode = TestMode::Ui;
-     config.src_base = Path::new("tests").join("ui-toml").canonicalize().unwrap();
++fn run_ui_toml() {
+ +    fn run_tests(config: &compiletest::Config, mut tests: Vec<tester::TestDescAndFn>) -> Result<bool, io::Error> {
+ +        let mut result = true;
+ +        let opts = compiletest::test_opts(config);
+ +        for dir in fs::read_dir(&config.src_base)? {
+ +            let dir = dir?;
+ +            if !dir.file_type()?.is_dir() {
+ +                continue;
+ +            }
+ +            let dir_path = dir.path();
+ +            let _g = VarGuard::set("CARGO_MANIFEST_DIR", &dir_path);
+ +            for file in fs::read_dir(&dir_path)? {
+ +                let file = file?;
+ +                let file_path = file.path();
+ +                if file.file_type()?.is_dir() {
+ +                    continue;
+ +                }
+ +                if file_path.extension() != Some(OsStr::new("rs")) {
+ +                    continue;
+ +                }
+ +                let paths = compiletest::common::TestPaths {
+ +                    file: file_path,
+ +                    base: config.src_base.clone(),
+ +                    relative_dir: dir_path.file_name().unwrap().into(),
+ +                };
+ +                let test_name = compiletest::make_test_name(config, &paths);
+ +                let index = tests
+ +                    .iter()
+ +                    .position(|test| test.desc.name == test_name)
+ +                    .expect("The test should be in there");
+ +                result &= tester::run_tests_console(&opts, vec![tests.swap_remove(index)])?;
+ +            }
+ +        }
+ +        Ok(result)
+ +    }
+ +
-     let tests = compiletest::make_tests(config);
++    let mut config = base_config("ui-toml");
++    config.src_base = config.src_base.canonicalize().unwrap();
+ +
-     let res = run_tests(config, tests);
++    let tests = compiletest::make_tests(&config);
+ +
- fn run_ui_cargo(config: &mut compiletest::Config) {
++    let res = run_tests(&config, tests);
+ +    match res {
+ +        Ok(true) => {},
+ +        Ok(false) => panic!("Some tests failed"),
+ +        Err(e) => {
+ +            panic!("I/O failure during tests: {:?}", e);
+ +        },
+ +    }
+ +}
+ +
-     config.mode = TestMode::Ui;
-     config.src_base = Path::new("tests").join("ui-cargo").canonicalize().unwrap();
++fn run_ui_cargo() {
+ +    fn run_tests(
+ +        config: &compiletest::Config,
+ +        filters: &[String],
+ +        mut tests: Vec<tester::TestDescAndFn>,
+ +    ) -> Result<bool, io::Error> {
+ +        let mut result = true;
+ +        let opts = compiletest::test_opts(config);
+ +
+ +        for dir in fs::read_dir(&config.src_base)? {
+ +            let dir = dir?;
+ +            if !dir.file_type()?.is_dir() {
+ +                continue;
+ +            }
+ +
+ +            // Use the filter if provided
+ +            let dir_path = dir.path();
+ +            for filter in filters {
+ +                if !dir_path.ends_with(filter) {
+ +                    continue;
+ +                }
+ +            }
+ +
+ +            for case in fs::read_dir(&dir_path)? {
+ +                let case = case?;
+ +                if !case.file_type()?.is_dir() {
+ +                    continue;
+ +                }
+ +
+ +                let src_path = case.path().join("src");
+ +
+ +                // When switching between branches, if the previous branch had a test
+ +                // that the current branch does not have, the directory is not removed
+ +                // because an ignored Cargo.lock file exists.
+ +                if !src_path.exists() {
+ +                    continue;
+ +                }
+ +
+ +                env::set_current_dir(&src_path)?;
+ +                for file in fs::read_dir(&src_path)? {
+ +                    let file = file?;
+ +                    if file.file_type()?.is_dir() {
+ +                        continue;
+ +                    }
+ +
+ +                    // Search for the main file to avoid running a test for each file in the project
+ +                    let file_path = file.path();
+ +                    match file_path.file_name().and_then(OsStr::to_str) {
+ +                        Some("main.rs") => {},
+ +                        _ => continue,
+ +                    }
+ +                    let _g = VarGuard::set("CLIPPY_CONF_DIR", case.path());
+ +                    let paths = compiletest::common::TestPaths {
+ +                        file: file_path,
+ +                        base: config.src_base.clone(),
+ +                        relative_dir: src_path.strip_prefix(&config.src_base).unwrap().into(),
+ +                    };
+ +                    let test_name = compiletest::make_test_name(config, &paths);
+ +                    let index = tests
+ +                        .iter()
+ +                        .position(|test| test.desc.name == test_name)
+ +                        .expect("The test should be in there");
+ +                    result &= tester::run_tests_console(&opts, vec![tests.swap_remove(index)])?;
+ +                }
+ +            }
+ +        }
+ +        Ok(result)
+ +    }
+ +
+ +    if IS_RUSTC_TEST_SUITE {
+ +        return;
+ +    }
+ +
-     let tests = compiletest::make_tests(config);
++    let mut config = base_config("ui-cargo");
++    config.src_base = config.src_base.canonicalize().unwrap();
+ +
-     let res = run_tests(config, &config.filters, tests);
++    let tests = compiletest::make_tests(&config);
+ +
+ +    let current_dir = env::current_dir().unwrap();
-     let mut config = default_config();
-     run_ui(&mut config);
-     run_ui_test(&mut config);
-     run_ui_toml(&mut config);
-     run_ui_cargo(&mut config);
-     run_internal_tests(&mut config);
++    let res = run_tests(&config, &config.filters, tests);
+ +    env::set_current_dir(current_dir).unwrap();
+ +
+ +    match res {
+ +        Ok(true) => {},
+ +        Ok(false) => panic!("Some tests failed"),
+ +        Err(e) => {
+ +            panic!("I/O failure during tests: {:?}", e);
+ +        },
+ +    }
+ +}
+ +
+ +#[test]
+ +fn compile_test() {
+ +    set_var("CLIPPY_DISABLE_DOCS_LINKS", "true");
++    run_ui();
++    run_ui_toml();
++    run_ui_cargo();
++    run_internal_tests();
+ +}
+ +
+ +/// Restores an env var on drop
+ +#[must_use]
+ +struct VarGuard {
+ +    key: &'static str,
+ +    value: Option<OsString>,
+ +}
+ +
+ +impl VarGuard {
+ +    fn set(key: &'static str, val: impl AsRef<OsStr>) -> Self {
+ +        let value = var_os(key);
+ +        set_var(key, val);
+ +        Self { key, value }
+ +    }
+ +}
+ +
+ +impl Drop for VarGuard {
+ +    fn drop(&mut self) {
+ +        match self.value.as_deref() {
+ +            None => remove_var(self.key),
+ +            Some(value) => set_var(self.key, value),
+ +        }
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..79c973cbfd2d57a4cb9a6732a6cda7fa4cf405dc

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml
@@@ -1,0 -1,0 +1,8 @@@
++[package]
++name = "no_warn"
++version = "0.1.0"
++edition = "2021"
++
++# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
++
++[dependencies]
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/clippy.toml

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..cda8d17eed44c7cdb9e9fc1609d90e71a146fdfa

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/clippy.toml
@@@ -1,0 -1,0 +1,1 @@@
++avoid-breaking-exported-api = false
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/src/main.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..e7a11a969c037e00a796aafeff6258501ec15e9a

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/src/main.rs
@@@ -1,0 -1,0 +1,3 @@@
++fn main() {
++    println!("Hello, world!");
++}
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/.clippy.toml

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..cda8d17eed44c7cdb9e9fc1609d90e71a146fdfa

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/.clippy.toml
@@@ -1,0 -1,0 +1,1 @@@
++avoid-breaking-exported-api = false
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/Cargo.toml

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..3d5c707579bcae8b63c54519c6c522e59dbb3c13

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/Cargo.toml
@@@ -1,0 -1,0 +1,8 @@@
++[package]
++name = "warn"
++version = "0.1.0"
++edition = "2021"
++
++# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
++
++[dependencies]
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/clippy.toml

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..cda8d17eed44c7cdb9e9fc1609d90e71a146fdfa

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/clippy.toml
@@@ -1,0 -1,0 +1,1 @@@
++avoid-breaking-exported-api = false
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/src/main.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..2d0b4a7948c4a3b7c6c6d31c2b371e31c4602857

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/src/main.rs
@@@ -1,0 -1,0 +1,5 @@@
++// ignore-windows
++
++fn main() {
++    println!("Hello, world!");
++}
diff --cc src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/src/main.stderr

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..2abb4e3e06e64327dc81f3cdabaf44f646f1f571

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/src/main.stderr
@@@ -1,0 -1,0 +1,2 @@@
++Using config file `$SRC_DIR/tests/ui-cargo/multiple_config_files/warn/.clippy.toml`
++Warning: `$SRC_DIR/tests/ui-cargo/multiple_config_files/warn/clippy.toml` will be ignored.
diff --cc src/tools/clippy/tests/ui/crashes/ice-4968.rs

index 3822f174598540ea2980e6469795872029d5a9e7,0000000000000000000000000000000000000000..e0510d942c200843abd0432b756f60ab9002d265

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/crashes/ice-4968.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-4968.rs
@@@ -1,20 -1,0 +1,21 @@@
+ +// check-pass
+ +
+ +// Test for https://github.com/rust-lang/rust-clippy/issues/4968
+ +
+ +#![warn(clippy::unsound_collection_transmute)]
++#![allow(clippy::transmute_undefined_repr)]
+ +
+ +trait Trait {
+ +    type Assoc;
+ +}
+ +
+ +use std::mem::{self, ManuallyDrop};
+ +
+ +#[allow(unused)]
+ +fn func<T: Trait>(slice: Vec<T::Assoc>) {
+ +    unsafe {
+ +        let _: Vec<ManuallyDrop<T::Assoc>> = mem::transmute(slice);
+ +    }
+ +}
+ +
+ +fn main() {}
diff --cc src/tools/clippy/tests/ui/crashes/ice-8250.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..d9a5ee1162a49cb0a9daa52157037caa0e3f9b1f

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-8250.rs
@@@ -1,0 -1,0 +1,6 @@@
++fn _f(s: &str) -> Option<()> {
++    let _ = s[1..].splitn(2, '.').next()?;
++    Some(())
++}
++
++fn main() {}
diff --cc src/tools/clippy/tests/ui/crashes/ice-8250.stderr

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..04ea4456656525c570cd1a39eb4348119ab291f4

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-8250.stderr
@@@ -1,0 -1,0 +1,18 @@@
++error: manual implementation of `split_once`
++  --> $DIR/ice-8250.rs:2:13
++   |
++LL |     let _ = s[1..].splitn(2, '.').next()?;
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `s[1..].split_once('.').map_or(s[1..], |x| x.0)`
++   |
++   = note: `-D clippy::manual-split-once` implied by `-D warnings`
++
++error: unnecessary use of `splitn`
++  --> $DIR/ice-8250.rs:2:13
++   |
++LL |     let _ = s[1..].splitn(2, '.').next()?;
++   |             ^^^^^^^^^^^^^^^^^^^^^ help: try this: `s[1..].split('.')`
++   |
++   = note: `-D clippy::needless-splitn` implied by `-D warnings`
++
++error: aborting due to 2 previous errors
++
diff --cc src/tools/clippy/tests/ui/crashes/ice-8386.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..3e38b1408d8ca1f509ce6ab05f4b6b580febd8c9

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-8386.rs
@@@ -1,0 -1,0 +1,3 @@@
++fn f(x: u32, mut arg: &String) {}
++
++fn main() {}
diff --cc src/tools/clippy/tests/ui/default_union_representation.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..93b2d33da2cd2163f34cbc6cee5a64149d60ef48

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/default_union_representation.rs
@@@ -1,0 -1,0 +1,78 @@@
++#![feature(transparent_unions)]
++#![warn(clippy::default_union_representation)]
++
++union NoAttribute {
++    a: i32,
++    b: u32,
++}
++
++#[repr(C)]
++union ReprC {
++    a: i32,
++    b: u32,
++}
++
++#[repr(packed)]
++union ReprPacked {
++    a: i32,
++    b: u32,
++}
++
++#[repr(C, packed)]
++union ReprCPacked {
++    a: i32,
++    b: u32,
++}
++
++#[repr(C, align(32))]
++union ReprCAlign {
++    a: i32,
++    b: u32,
++}
++
++#[repr(align(32))]
++union ReprAlign {
++    a: i32,
++    b: u32,
++}
++
++union SingleZST {
++    f0: (),
++}
++union ZSTsAndField1 {
++    f0: u32,
++    f1: (),
++    f2: (),
++    f3: (),
++}
++union ZSTsAndField2 {
++    f0: (),
++    f1: (),
++    f2: u32,
++    f3: (),
++}
++union ZSTAndTwoFields {
++    f0: u32,
++    f1: u64,
++    f2: (),
++}
++
++#[repr(C)]
++union CZSTAndTwoFields {
++    f0: u32,
++    f1: u64,
++    f2: (),
++}
++
++#[repr(transparent)]
++union ReprTransparent {
++    a: i32,
++}
++
++#[repr(transparent)]
++union ReprTransparentZST {
++    a: i32,
++    b: (),
++}
++
++fn main() {}
diff --cc src/tools/clippy/tests/ui/default_union_representation.stderr

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..138884af868c70c52673092638caacc9e31e6fee

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/default_union_representation.stderr
@@@ -1,0 -1,0 +1,48 @@@
++error: this union has the default representation
++  --> $DIR/default_union_representation.rs:4:1
++   |
++LL | / union NoAttribute {
++LL | |     a: i32,
++LL | |     b: u32,
++LL | | }
++   | |_^
++   |
++   = note: `-D clippy::default-union-representation` implied by `-D warnings`
++   = help: consider annotating `NoAttribute` with `#[repr(C)]` to explicitly specify memory layout
++
++error: this union has the default representation
++  --> $DIR/default_union_representation.rs:16:1
++   |
++LL | / union ReprPacked {
++LL | |     a: i32,
++LL | |     b: u32,
++LL | | }
++   | |_^
++   |
++   = help: consider annotating `ReprPacked` with `#[repr(C)]` to explicitly specify memory layout
++
++error: this union has the default representation
++  --> $DIR/default_union_representation.rs:34:1
++   |
++LL | / union ReprAlign {
++LL | |     a: i32,
++LL | |     b: u32,
++LL | | }
++   | |_^
++   |
++   = help: consider annotating `ReprAlign` with `#[repr(C)]` to explicitly specify memory layout
++
++error: this union has the default representation
++  --> $DIR/default_union_representation.rs:54:1
++   |
++LL | / union ZSTAndTwoFields {
++LL | |     f0: u32,
++LL | |     f1: u64,
++LL | |     f2: (),
++LL | | }
++   | |_^
++   |
++   = help: consider annotating `ZSTAndTwoFields` with `#[repr(C)]` to explicitly specify memory layout
++
++error: aborting due to 4 previous errors
++
diff --cc src/tools/clippy/tests/ui/eq_op.rs

index 707b449f82e4f04ea4e85b4efeb76b17820aaa33,0000000000000000000000000000000000000000..422f9486503d2396a484653531936afe7aa18814

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/eq_op.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/eq_op.rs
@@@ -1,97 -1,0 +1,108 @@@
- // does not test any rustfixable lints
- 
- #[rustfmt::skip]
- #[warn(clippy::eq_op)]
- #[allow(clippy::identity_op, clippy::double_parens)]
- #[allow(clippy::no_effect, unused_variables, clippy::unnecessary_operation, clippy::short_circuit_statement)]
- #[allow(clippy::nonminimal_bool)]
- #[allow(unused)]
- #[allow(clippy::unnecessary_cast)]
++// compile-flags: --test
++
++#![warn(clippy::eq_op)]
++#![allow(clippy::double_parens, clippy::identity_op, clippy::nonminimal_bool)]
++
+ +fn main() {
+ +    // simple values and comparisons
-     1 == 1;
-     "no" == "no";
++    let _ = 1 == 1;
++    let _ = "no" == "no";
+ +    // even though I agree that no means no ;-)
-     false != false;
-     1.5 < 1.5;
-     1u64 >= 1u64;
++    let _ = false != false;
++    let _ = 1.5 < 1.5;
++    let _ = 1u64 >= 1u64;
+ +
+ +    // casts, methods, parentheses
-     (1 as u64) & (1 as u64);
-     1 ^ ((((((1))))));
++    let _ = (1u32 as u64) & (1u32 as u64);
++    #[rustfmt::skip]
++    {
++        let _ = 1 ^ ((((((1))))));
++    };
+ +
+ +    // unary and binary operators
-     (-(2) < -(2));
-     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
-     (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
++    let _ = (-(2) < -(2));
++    let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
++    let _ = (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
+ +
+ +    // various other things
-     ([1] != [1]);
-     ((1, 2) != (1, 2));
-     vec![1, 2, 3] == vec![1, 2, 3]; //no error yet, as we don't match macros
++    let _ = ([1] != [1]);
++    let _ = ((1, 2) != (1, 2));
++    let _ = vec![1, 2, 3] == vec![1, 2, 3]; //no error yet, as we don't match macros
+ +
+ +    // const folding
-     1 + 1 == 2;
-     1 - 1 == 0;
++    let _ = 1 + 1 == 2;
++    let _ = 1 - 1 == 0;
+ +
-     1 - 1;
-     1 / 1;
-     true && true;
- 
-     true || true;
++    let _ = 1 - 1;
++    let _ = 1 / 1;
++    let _ = true && true;
+ +
++    let _ = true || true;
+ +
+ +    let a: u32 = 0;
+ +    let b: u32 = 0;
+ +
-     a == b && b == a;
-     a != b && b != a;
-     a < b && b > a;
-     a <= b && b >= a;
++    let _ = a == b && b == a;
++    let _ = a != b && b != a;
++    let _ = a < b && b > a;
++    let _ = a <= b && b >= a;
+ +
+ +    let mut a = vec![1];
-     a == a;
-     2*a.len() == 2*a.len(); // ok, functions
-     a.pop() == a.pop(); // ok, functions
++    let _ = a == a;
++    let _ = 2 * a.len() == 2 * a.len(); // ok, functions
++    let _ = a.pop() == a.pop(); // ok, functions
+ +
+ +    check_ignore_macro();
+ +
+ +    // named constants
+ +    const A: u32 = 10;
+ +    const B: u32 = 10;
+ +    const C: u32 = A / B; // ok, different named constants
+ +    const D: u32 = A / A;
+ +}
+ +
- #[rustfmt::skip]
+ +macro_rules! check_if_named_foo {
-     ($expression:expr) => (
++    ($expression:expr) => {
+ +        if stringify!($expression) == "foo" {
+ +            println!("foo!");
+ +        } else {
+ +            println!("not foo.");
+ +        }
-     )
++    };
+ +}
+ +
+ +macro_rules! bool_macro {
+ +    ($expression:expr) => {
+ +        true
+ +    };
+ +}
+ +
- #[allow(clippy::short_circuit_statement)]
+ +fn check_ignore_macro() {
+ +    check_if_named_foo!(foo);
+ +    // checks if the lint ignores macros with `!` operator
-     !bool_macro!(1) && !bool_macro!("");
++    let _ = !bool_macro!(1) && !bool_macro!("");
+ +}
+ +
+ +struct Nested {
+ +    inner: ((i32,), (i32,), (i32,)),
+ +}
+ +
+ +fn check_nested(n1: &Nested, n2: &Nested) -> bool {
+ +    // `n2.inner.0.0` mistyped as `n1.inner.0.0`
+ +    (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
+ +}
++
++#[test]
++fn eq_op_shouldnt_trigger_in_tests() {
++    let a = 1;
++    let result = a + 1 == 1 + a;
++    assert!(result);
++}
++
++#[test]
++fn eq_op_macros_shouldnt_trigger_in_tests() {
++    let a = 1;
++    let b = 2;
++    assert_eq!(a, a);
++    assert_eq!(a + b, b + a);
++}
diff --cc src/tools/clippy/tests/ui/eq_op.stderr

index 8ef658af8df429829ec50d85dfcdbe4f8ab3bd74,0000000000000000000000000000000000000000..313ceed2b41facad2b115d1b36d0d77bbb4693a2

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/eq_op.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/eq_op.stderr
@@@ -1,174 -1,0 +1,172 @@@
-   --> $DIR/eq_op.rs:12:5
+ +error: equal expressions as operands to `==`
- LL |     1 == 1;
-    |     ^^^^^^
++  --> $DIR/eq_op.rs:8:13
+ +   |
-   --> $DIR/eq_op.rs:13:5
++LL |     let _ = 1 == 1;
++   |             ^^^^^^
+ +   |
+ +   = note: `-D clippy::eq-op` implied by `-D warnings`
+ +
+ +error: equal expressions as operands to `==`
- LL |     "no" == "no";
-    |     ^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:9:13
+ +   |
-   --> $DIR/eq_op.rs:15:5
++LL |     let _ = "no" == "no";
++   |             ^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `!=`
- LL |     false != false;
-    |     ^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:11:13
+ +   |
-   --> $DIR/eq_op.rs:16:5
++LL |     let _ = false != false;
++   |             ^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `<`
- LL |     1.5 < 1.5;
-    |     ^^^^^^^^^
++  --> $DIR/eq_op.rs:12:13
+ +   |
-   --> $DIR/eq_op.rs:17:5
++LL |     let _ = 1.5 < 1.5;
++   |             ^^^^^^^^^
+ +
+ +error: equal expressions as operands to `>=`
- LL |     1u64 >= 1u64;
-    |     ^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:13:13
+ +   |
-   --> $DIR/eq_op.rs:20:5
++LL |     let _ = 1u64 >= 1u64;
++   |             ^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `&`
- LL |     (1 as u64) & (1 as u64);
-    |     ^^^^^^^^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:16:13
+ +   |
-   --> $DIR/eq_op.rs:21:5
++LL |     let _ = (1u32 as u64) & (1u32 as u64);
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `^`
- LL |     1 ^ ((((((1))))));
-    |     ^^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:19:17
+ +   |
-   --> $DIR/eq_op.rs:24:5
++LL |         let _ = 1 ^ ((((((1))))));
++   |                 ^^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `<`
- LL |     (-(2) < -(2));
-    |     ^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:23:13
+ +   |
-   --> $DIR/eq_op.rs:25:5
++LL |     let _ = (-(2) < -(2));
++   |             ^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `==`
- LL |     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:24:13
+ +   |
-   --> $DIR/eq_op.rs:25:6
++LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `&`
- LL |     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
-    |      ^^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:24:14
+ +   |
-   --> $DIR/eq_op.rs:25:27
++LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
++   |              ^^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `&`
- LL |     ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
-    |                           ^^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:24:35
+ +   |
-   --> $DIR/eq_op.rs:26:5
++LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
++   |                                   ^^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `==`
- LL |     (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:25:13
+ +   |
-   --> $DIR/eq_op.rs:29:5
++LL |     let _ = (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
++   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `!=`
- LL |     ([1] != [1]);
-    |     ^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:28:13
+ +   |
-   --> $DIR/eq_op.rs:30:5
++LL |     let _ = ([1] != [1]);
++   |             ^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `!=`
- LL |     ((1, 2) != (1, 2));
-    |     ^^^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:29:13
+ +   |
-   --> $DIR/eq_op.rs:34:5
++LL |     let _ = ((1, 2) != (1, 2));
++   |             ^^^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `==`
- LL |     1 + 1 == 2;
-    |     ^^^^^^^^^^
++  --> $DIR/eq_op.rs:33:13
+ +   |
-   --> $DIR/eq_op.rs:35:5
++LL |     let _ = 1 + 1 == 2;
++   |             ^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `==`
- LL |     1 - 1 == 0;
-    |     ^^^^^^^^^^
++  --> $DIR/eq_op.rs:34:13
+ +   |
-   --> $DIR/eq_op.rs:35:5
++LL |     let _ = 1 - 1 == 0;
++   |             ^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `-`
- LL |     1 - 1 == 0;
-    |     ^^^^^
++  --> $DIR/eq_op.rs:34:13
+ +   |
-   --> $DIR/eq_op.rs:37:5
++LL |     let _ = 1 - 1 == 0;
++   |             ^^^^^
+ +
+ +error: equal expressions as operands to `-`
- LL |     1 - 1;
-    |     ^^^^^
++  --> $DIR/eq_op.rs:36:13
+ +   |
-   --> $DIR/eq_op.rs:38:5
++LL |     let _ = 1 - 1;
++   |             ^^^^^
+ +
+ +error: equal expressions as operands to `/`
- LL |     1 / 1;
-    |     ^^^^^
++  --> $DIR/eq_op.rs:37:13
+ +   |
-   --> $DIR/eq_op.rs:39:5
++LL |     let _ = 1 / 1;
++   |             ^^^^^
+ +
+ +error: equal expressions as operands to `&&`
- LL |     true && true;
-    |     ^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:38:13
+ +   |
-   --> $DIR/eq_op.rs:41:5
++LL |     let _ = true && true;
++   |             ^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `||`
- LL |     true || true;
-    |     ^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:40:13
+ +   |
-   --> $DIR/eq_op.rs:47:5
++LL |     let _ = true || true;
++   |             ^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `&&`
- LL |     a == b && b == a;
-    |     ^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:45:13
+ +   |
-   --> $DIR/eq_op.rs:48:5
++LL |     let _ = a == b && b == a;
++   |             ^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `&&`
- LL |     a != b && b != a;
-    |     ^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:46:13
+ +   |
-   --> $DIR/eq_op.rs:49:5
++LL |     let _ = a != b && b != a;
++   |             ^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `&&`
- LL |     a < b && b > a;
-    |     ^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:47:13
+ +   |
-   --> $DIR/eq_op.rs:50:5
++LL |     let _ = a < b && b > a;
++   |             ^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `&&`
- LL |     a <= b && b >= a;
-    |     ^^^^^^^^^^^^^^^^
++  --> $DIR/eq_op.rs:48:13
+ +   |
-   --> $DIR/eq_op.rs:53:5
++LL |     let _ = a <= b && b >= a;
++   |             ^^^^^^^^^^^^^^^^
+ +
+ +error: equal expressions as operands to `==`
- LL |     a == a;
-    |     ^^^^^^
++  --> $DIR/eq_op.rs:51:13
+ +   |
-   --> $DIR/eq_op.rs:63:20
++LL |     let _ = a == a;
++   |             ^^^^^^
+ +
+ +error: equal expressions as operands to `/`
-   --> $DIR/eq_op.rs:96:5
++  --> $DIR/eq_op.rs:61:20
+ +   |
+ +LL |     const D: u32 = A / A;
+ +   |                    ^^^^^
+ +
+ +error: equal expressions as operands to `==`
-    |
-    = note: `#[deny(clippy::eq_op)]` on by default
++  --> $DIR/eq_op.rs:92:5
+ +   |
+ +LL |     (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ +
+ +error: aborting due to 28 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/expect_fun_call.fixed

index cf923a6a5940c3574216eca71be849f9cd89d6e5,0000000000000000000000000000000000000000..53e45d28bded91a7ab772f5aa2afd15c3f8a379e

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/expect_fun_call.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/expect_fun_call.fixed
@@@ -1,95 -1,0 +1,104 @@@
+ +// run-rustfix
+ +
+ +#![warn(clippy::expect_fun_call)]
+ +#![allow(clippy::to_string_in_format_args)]
+ +
+ +/// Checks implementation of the `EXPECT_FUN_CALL` lint
+ +
++macro_rules! one {
++    () => {
++        1
++    };
++}
++
+ +fn main() {
+ +    struct Foo;
+ +
+ +    impl Foo {
+ +        fn new() -> Self {
+ +            Foo
+ +        }
+ +
+ +        fn expect(&self, msg: &str) {
+ +            panic!("{}", msg)
+ +        }
+ +    }
+ +
+ +    let with_some = Some("value");
+ +    with_some.expect("error");
+ +
+ +    let with_none: Option<i32> = None;
+ +    with_none.expect("error");
+ +
+ +    let error_code = 123_i32;
+ +    let with_none_and_format: Option<i32> = None;
+ +    with_none_and_format.unwrap_or_else(|| panic!("Error {}: fake error", error_code));
+ +
+ +    let with_none_and_as_str: Option<i32> = None;
+ +    with_none_and_as_str.unwrap_or_else(|| panic!("Error {}: fake error", error_code));
+ +
++    let with_none_and_format_with_macro: Option<i32> = None;
++    with_none_and_format_with_macro.unwrap_or_else(|| panic!("Error {}: fake error", one!()));
++
+ +    let with_ok: Result<(), ()> = Ok(());
+ +    with_ok.expect("error");
+ +
+ +    let with_err: Result<(), ()> = Err(());
+ +    with_err.expect("error");
+ +
+ +    let error_code = 123_i32;
+ +    let with_err_and_format: Result<(), ()> = Err(());
+ +    with_err_and_format.unwrap_or_else(|_| panic!("Error {}: fake error", error_code));
+ +
+ +    let with_err_and_as_str: Result<(), ()> = Err(());
+ +    with_err_and_as_str.unwrap_or_else(|_| panic!("Error {}: fake error", error_code));
+ +
+ +    let with_dummy_type = Foo::new();
+ +    with_dummy_type.expect("another test string");
+ +
+ +    let with_dummy_type_and_format = Foo::new();
+ +    with_dummy_type_and_format.expect(&format!("Error {}: fake error", error_code));
+ +
+ +    let with_dummy_type_and_as_str = Foo::new();
+ +    with_dummy_type_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+ +
+ +    //Issue #2937
+ +    Some("foo").unwrap_or_else(|| panic!("{} {}", 1, 2));
+ +
+ +    //Issue #2979 - this should not lint
+ +    {
+ +        let msg = "bar";
+ +        Some("foo").expect(msg);
+ +    }
+ +
+ +    {
+ +        fn get_string() -> String {
+ +            "foo".to_string()
+ +        }
+ +
+ +        fn get_static_str() -> &'static str {
+ +            "foo"
+ +        }
+ +
+ +        fn get_non_static_str(_: &u32) -> &str {
+ +            "foo"
+ +        }
+ +
+ +        Some("foo").unwrap_or_else(|| { panic!("{}", get_string()) });
+ +        Some("foo").unwrap_or_else(|| { panic!("{}", get_string()) });
+ +        Some("foo").unwrap_or_else(|| { panic!("{}", get_string()) });
+ +
+ +        Some("foo").unwrap_or_else(|| { panic!("{}", get_static_str()) });
+ +        Some("foo").unwrap_or_else(|| { panic!("{}", get_non_static_str(&0).to_string()) });
+ +    }
+ +
+ +    //Issue #3839
+ +    Some(true).unwrap_or_else(|| panic!("key {}, {}", 1, 2));
+ +
+ +    //Issue #4912 - the receiver is a &Option
+ +    {
+ +        let opt = Some(1);
+ +        let opt_ref = &opt;
+ +        opt_ref.unwrap_or_else(|| panic!("{:?}", opt_ref));
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/expect_fun_call.rs

index e6f252259df70427e2da39b9ca9a3c6172f51659,0000000000000000000000000000000000000000..22e530b80349d81e27ef8fdeb015acbe54a027a5

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/expect_fun_call.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/expect_fun_call.rs
@@@ -1,95 -1,0 +1,104 @@@
+ +// run-rustfix
+ +
+ +#![warn(clippy::expect_fun_call)]
+ +#![allow(clippy::to_string_in_format_args)]
+ +
+ +/// Checks implementation of the `EXPECT_FUN_CALL` lint
+ +
++macro_rules! one {
++    () => {
++        1
++    };
++}
++
+ +fn main() {
+ +    struct Foo;
+ +
+ +    impl Foo {
+ +        fn new() -> Self {
+ +            Foo
+ +        }
+ +
+ +        fn expect(&self, msg: &str) {
+ +            panic!("{}", msg)
+ +        }
+ +    }
+ +
+ +    let with_some = Some("value");
+ +    with_some.expect("error");
+ +
+ +    let with_none: Option<i32> = None;
+ +    with_none.expect("error");
+ +
+ +    let error_code = 123_i32;
+ +    let with_none_and_format: Option<i32> = None;
+ +    with_none_and_format.expect(&format!("Error {}: fake error", error_code));
+ +
+ +    let with_none_and_as_str: Option<i32> = None;
+ +    with_none_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+ +
++    let with_none_and_format_with_macro: Option<i32> = None;
++    with_none_and_format_with_macro.expect(format!("Error {}: fake error", one!()).as_str());
++
+ +    let with_ok: Result<(), ()> = Ok(());
+ +    with_ok.expect("error");
+ +
+ +    let with_err: Result<(), ()> = Err(());
+ +    with_err.expect("error");
+ +
+ +    let error_code = 123_i32;
+ +    let with_err_and_format: Result<(), ()> = Err(());
+ +    with_err_and_format.expect(&format!("Error {}: fake error", error_code));
+ +
+ +    let with_err_and_as_str: Result<(), ()> = Err(());
+ +    with_err_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+ +
+ +    let with_dummy_type = Foo::new();
+ +    with_dummy_type.expect("another test string");
+ +
+ +    let with_dummy_type_and_format = Foo::new();
+ +    with_dummy_type_and_format.expect(&format!("Error {}: fake error", error_code));
+ +
+ +    let with_dummy_type_and_as_str = Foo::new();
+ +    with_dummy_type_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+ +
+ +    //Issue #2937
+ +    Some("foo").expect(format!("{} {}", 1, 2).as_ref());
+ +
+ +    //Issue #2979 - this should not lint
+ +    {
+ +        let msg = "bar";
+ +        Some("foo").expect(msg);
+ +    }
+ +
+ +    {
+ +        fn get_string() -> String {
+ +            "foo".to_string()
+ +        }
+ +
+ +        fn get_static_str() -> &'static str {
+ +            "foo"
+ +        }
+ +
+ +        fn get_non_static_str(_: &u32) -> &str {
+ +            "foo"
+ +        }
+ +
+ +        Some("foo").expect(&get_string());
+ +        Some("foo").expect(get_string().as_ref());
+ +        Some("foo").expect(get_string().as_str());
+ +
+ +        Some("foo").expect(get_static_str());
+ +        Some("foo").expect(get_non_static_str(&0));
+ +    }
+ +
+ +    //Issue #3839
+ +    Some(true).expect(&format!("key {}, {}", 1, 2));
+ +
+ +    //Issue #4912 - the receiver is a &Option
+ +    {
+ +        let opt = Some(1);
+ +        let opt_ref = &opt;
+ +        opt_ref.expect(&format!("{:?}", opt_ref));
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/expect_fun_call.stderr

index ac48a06671cd2e0d572ecc36637c0237bc90426c,0000000000000000000000000000000000000000..aca15935fca06596dca5f84edebe35b693baaa15

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/expect_fun_call.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/expect_fun_call.stderr
@@@ -1,76 -1,0 +1,82 @@@
-   --> $DIR/expect_fun_call.rs:29:26
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:32:26
++  --> $DIR/expect_fun_call.rs:35:26
+ +   |
+ +LL |     with_none_and_format.expect(&format!("Error {}: fake error", error_code));
+ +   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("Error {}: fake error", error_code))`
+ +   |
+ +   = note: `-D clippy::expect-fun-call` implied by `-D warnings`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:42:25
++  --> $DIR/expect_fun_call.rs:38:26
+ +   |
+ +LL |     with_none_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+ +   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("Error {}: fake error", error_code))`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:45:25
++  --> $DIR/expect_fun_call.rs:41:37
++   |
++LL |     with_none_and_format_with_macro.expect(format!("Error {}: fake error", one!()).as_str());
++   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("Error {}: fake error", one!()))`
++
++error: use of `expect` followed by a function call
++  --> $DIR/expect_fun_call.rs:51:25
+ +   |
+ +LL |     with_err_and_format.expect(&format!("Error {}: fake error", error_code));
+ +   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:57:17
++  --> $DIR/expect_fun_call.rs:54:25
+ +   |
+ +LL |     with_err_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+ +   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:78:21
++  --> $DIR/expect_fun_call.rs:66:17
+ +   |
+ +LL |     Some("foo").expect(format!("{} {}", 1, 2).as_ref());
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{} {}", 1, 2))`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:79:21
++  --> $DIR/expect_fun_call.rs:87:21
+ +   |
+ +LL |         Some("foo").expect(&get_string());
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_string()) })`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:80:21
++  --> $DIR/expect_fun_call.rs:88:21
+ +   |
+ +LL |         Some("foo").expect(get_string().as_ref());
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_string()) })`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:82:21
++  --> $DIR/expect_fun_call.rs:89:21
+ +   |
+ +LL |         Some("foo").expect(get_string().as_str());
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_string()) })`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:83:21
++  --> $DIR/expect_fun_call.rs:91:21
+ +   |
+ +LL |         Some("foo").expect(get_static_str());
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_static_str()) })`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:87:16
++  --> $DIR/expect_fun_call.rs:92:21
+ +   |
+ +LL |         Some("foo").expect(get_non_static_str(&0));
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| { panic!("{}", get_non_static_str(&0).to_string()) })`
+ +
+ +error: use of `expect` followed by a function call
-   --> $DIR/expect_fun_call.rs:93:17
++  --> $DIR/expect_fun_call.rs:96:16
+ +   |
+ +LL |     Some(true).expect(&format!("key {}, {}", 1, 2));
+ +   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("key {}, {}", 1, 2))`
+ +
+ +error: use of `expect` followed by a function call
- error: aborting due to 12 previous errors
++  --> $DIR/expect_fun_call.rs:102:17
+ +   |
+ +LL |         opt_ref.expect(&format!("{:?}", opt_ref));
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `unwrap_or_else(|| panic!("{:?}", opt_ref))`
+ +
++error: aborting due to 13 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/explicit_counter_loop.stderr

index 9edddea651c26f01c12b1a7f774dafa0098d77ec,0000000000000000000000000000000000000000..f9f8407d57755481de85bad8ad47efe42eba1563

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
@@@ -1,60 -1,0 +1,60 @@@
-    |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_usize, _item) in slice.into_iter().enumerate()`
+ +error: the variable `_index` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:6:5
+ +   |
+ +LL |     for _v in &vec {
+ +   |     ^^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.iter().enumerate()`
+ +   |
+ +   = note: `-D clippy::explicit-counter-loop` implied by `-D warnings`
+ +
+ +error: the variable `_index` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:12:5
+ +   |
+ +LL |     for _v in &vec {
+ +   |     ^^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.iter().enumerate()`
+ +
+ +error: the variable `_index` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:17:5
+ +   |
+ +LL |     for _v in &mut vec {
+ +   |     ^^^^^^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.iter_mut().enumerate()`
+ +
+ +error: the variable `_index` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:22:5
+ +   |
+ +LL |     for _v in vec {
+ +   |     ^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.into_iter().enumerate()`
+ +
+ +error: the variable `count` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:61:9
+ +   |
+ +LL |         for ch in text.chars() {
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `for (count, ch) in text.chars().enumerate()`
+ +
+ +error: the variable `count` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:72:9
+ +   |
+ +LL |         for ch in text.chars() {
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `for (count, ch) in text.chars().enumerate()`
+ +
+ +error: the variable `count` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:130:9
+ +   |
+ +LL |         for _i in 3..10 {
+ +   |         ^^^^^^^^^^^^^^^ help: consider using: `for (count, _i) in (3..10).enumerate()`
+ +
+ +error: the variable `idx_usize` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:170:9
+ +   |
+ +LL |         for _item in slice {
-    |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_u32, _item) in (0_u32..).zip(slice.into_iter())`
++   |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_usize, _item) in slice.iter().enumerate()`
+ +
+ +error: the variable `idx_u32` is used as a loop counter
+ +  --> $DIR/explicit_counter_loop.rs:182:9
+ +   |
+ +LL |         for _item in slice {
++   |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_u32, _item) in (0_u32..).zip(slice.iter())`
+ +   |
+ +   = note: `idx_u32` is of type `u32`, making it ineligible for `Iterator::enumerate`
+ +
+ +error: aborting due to 9 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/explicit_write.fixed

index 692d2ca675f91ac6712d46be511934876151e9bd,0000000000000000000000000000000000000000..74d0e5290282aff21105c871e8ba6223477e862b

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/explicit_write.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/explicit_write.fixed
@@@ -1,51 -1,0 +1,63 @@@
+ +// run-rustfix
+ +#![allow(unused_imports)]
+ +#![warn(clippy::explicit_write)]
+ +
+ +fn stdout() -> String {
+ +    String::new()
+ +}
+ +
+ +fn stderr() -> String {
+ +    String::new()
+ +}
+ +
++macro_rules! one {
++    () => {
++        1
++    };
++}
++
+ +fn main() {
+ +    // these should warn
+ +    {
+ +        use std::io::Write;
+ +        print!("test");
+ +        eprint!("test");
+ +        println!("test");
+ +        eprintln!("test");
+ +        print!("test");
+ +        eprint!("test");
+ +
+ +        // including newlines
+ +        println!("test\ntest");
+ +        eprintln!("test\ntest");
++
++        let value = 1;
++        eprintln!("with {}", value);
++        eprintln!("with {} {}", 2, value);
++        eprintln!("with {value}");
++        eprintln!("macro arg {}", one!());
+ +    }
+ +    // these should not warn, different destination
+ +    {
+ +        use std::fmt::Write;
+ +        let mut s = String::new();
+ +        write!(s, "test").unwrap();
+ +        write!(s, "test").unwrap();
+ +        writeln!(s, "test").unwrap();
+ +        writeln!(s, "test").unwrap();
+ +        s.write_fmt(format_args!("test")).unwrap();
+ +        s.write_fmt(format_args!("test")).unwrap();
+ +        write!(stdout(), "test").unwrap();
+ +        write!(stderr(), "test").unwrap();
+ +        writeln!(stdout(), "test").unwrap();
+ +        writeln!(stderr(), "test").unwrap();
+ +        stdout().write_fmt(format_args!("test")).unwrap();
+ +        stderr().write_fmt(format_args!("test")).unwrap();
+ +    }
+ +    // these should not warn, no unwrap
+ +    {
+ +        use std::io::Write;
+ +        std::io::stdout().write_fmt(format_args!("test")).expect("no stdout");
+ +        std::io::stderr().write_fmt(format_args!("test")).expect("no stderr");
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/explicit_write.rs

index 455c5ef55d05c4209be525017565edc7706f26be,0000000000000000000000000000000000000000..e7a698d3e012d35049febcde9222b519904e06e8

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/explicit_write.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/explicit_write.rs
@@@ -1,51 -1,0 +1,63 @@@
+ +// run-rustfix
+ +#![allow(unused_imports)]
+ +#![warn(clippy::explicit_write)]
+ +
+ +fn stdout() -> String {
+ +    String::new()
+ +}
+ +
+ +fn stderr() -> String {
+ +    String::new()
+ +}
+ +
++macro_rules! one {
++    () => {
++        1
++    };
++}
++
+ +fn main() {
+ +    // these should warn
+ +    {
+ +        use std::io::Write;
+ +        write!(std::io::stdout(), "test").unwrap();
+ +        write!(std::io::stderr(), "test").unwrap();
+ +        writeln!(std::io::stdout(), "test").unwrap();
+ +        writeln!(std::io::stderr(), "test").unwrap();
+ +        std::io::stdout().write_fmt(format_args!("test")).unwrap();
+ +        std::io::stderr().write_fmt(format_args!("test")).unwrap();
+ +
+ +        // including newlines
+ +        writeln!(std::io::stdout(), "test\ntest").unwrap();
+ +        writeln!(std::io::stderr(), "test\ntest").unwrap();
++
++        let value = 1;
++        writeln!(std::io::stderr(), "with {}", value).unwrap();
++        writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
++        writeln!(std::io::stderr(), "with {value}").unwrap();
++        writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
+ +    }
+ +    // these should not warn, different destination
+ +    {
+ +        use std::fmt::Write;
+ +        let mut s = String::new();
+ +        write!(s, "test").unwrap();
+ +        write!(s, "test").unwrap();
+ +        writeln!(s, "test").unwrap();
+ +        writeln!(s, "test").unwrap();
+ +        s.write_fmt(format_args!("test")).unwrap();
+ +        s.write_fmt(format_args!("test")).unwrap();
+ +        write!(stdout(), "test").unwrap();
+ +        write!(stderr(), "test").unwrap();
+ +        writeln!(stdout(), "test").unwrap();
+ +        writeln!(stderr(), "test").unwrap();
+ +        stdout().write_fmt(format_args!("test")).unwrap();
+ +        stderr().write_fmt(format_args!("test")).unwrap();
+ +    }
+ +    // these should not warn, no unwrap
+ +    {
+ +        use std::io::Write;
+ +        std::io::stdout().write_fmt(format_args!("test")).expect("no stdout");
+ +        std::io::stderr().write_fmt(format_args!("test")).expect("no stderr");
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/explicit_write.stderr

index 9feef9c0dc8443cb0ef33f4df01e59a9110bea1c,0000000000000000000000000000000000000000..29ae0cdece2499e6466a957b8409f1faf007397b

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/explicit_write.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/explicit_write.stderr
@@@ -1,52 -1,0 +1,76 @@@
-   --> $DIR/explicit_write.rs:17:9
+ +error: use of `write!(stdout(), ...).unwrap()`
-   --> $DIR/explicit_write.rs:18:9
++  --> $DIR/explicit_write.rs:23:9
+ +   |
+ +LL |         write!(std::io::stdout(), "test").unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `print!("test")`
+ +   |
+ +   = note: `-D clippy::explicit-write` implied by `-D warnings`
+ +
+ +error: use of `write!(stderr(), ...).unwrap()`
-   --> $DIR/explicit_write.rs:19:9
++  --> $DIR/explicit_write.rs:24:9
+ +   |
+ +LL |         write!(std::io::stderr(), "test").unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprint!("test")`
+ +
+ +error: use of `writeln!(stdout(), ...).unwrap()`
-   --> $DIR/explicit_write.rs:20:9
++  --> $DIR/explicit_write.rs:25:9
+ +   |
+ +LL |         writeln!(std::io::stdout(), "test").unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `println!("test")`
+ +
+ +error: use of `writeln!(stderr(), ...).unwrap()`
-   --> $DIR/explicit_write.rs:21:9
++  --> $DIR/explicit_write.rs:26:9
+ +   |
+ +LL |         writeln!(std::io::stderr(), "test").unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("test")`
+ +
+ +error: use of `stdout().write_fmt(...).unwrap()`
-   --> $DIR/explicit_write.rs:22:9
++  --> $DIR/explicit_write.rs:27:9
+ +   |
+ +LL |         std::io::stdout().write_fmt(format_args!("test")).unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `print!("test")`
+ +
+ +error: use of `stderr().write_fmt(...).unwrap()`
-   --> $DIR/explicit_write.rs:25:9
++  --> $DIR/explicit_write.rs:28:9
+ +   |
+ +LL |         std::io::stderr().write_fmt(format_args!("test")).unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprint!("test")`
+ +
+ +error: use of `writeln!(stdout(), ...).unwrap()`
-   --> $DIR/explicit_write.rs:26:9
++  --> $DIR/explicit_write.rs:31:9
+ +   |
+ +LL |         writeln!(std::io::stdout(), "test/ntest").unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `println!("test/ntest")`
+ +
+ +error: use of `writeln!(stderr(), ...).unwrap()`
- error: aborting due to 8 previous errors
++  --> $DIR/explicit_write.rs:32:9
+ +   |
+ +LL |         writeln!(std::io::stderr(), "test/ntest").unwrap();
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("test/ntest")`
+ +
++error: use of `writeln!(stderr(), ...).unwrap()`
++  --> $DIR/explicit_write.rs:35:9
++   |
++LL |         writeln!(std::io::stderr(), "with {}", value).unwrap();
++   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {}", value)`
++
++error: use of `writeln!(stderr(), ...).unwrap()`
++  --> $DIR/explicit_write.rs:36:9
++   |
++LL |         writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
++   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {} {}", 2, value)`
++
++error: use of `writeln!(stderr(), ...).unwrap()`
++  --> $DIR/explicit_write.rs:37:9
++   |
++LL |         writeln!(std::io::stderr(), "with {value}").unwrap();
++   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("with {value}")`
++
++error: use of `writeln!(stderr(), ...).unwrap()`
++  --> $DIR/explicit_write.rs:38:9
++   |
++LL |         writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
++   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `eprintln!("macro arg {}", one!())`
++
++error: aborting due to 12 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/get_unwrap.fixed

index 924c02a4054d4022ef54225853514053b1b59980,0000000000000000000000000000000000000000..c3a36dcabd1a9392278988dd9150ddd69a847649

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/get_unwrap.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/get_unwrap.fixed
@@@ -1,62 -1,0 +1,68 @@@
-         *some_hashmap.get_mut(&1).unwrap() = 'b';
-         *some_btreemap.get_mut(&1).unwrap() = 'b';
-         *false_positive.get_mut(0).unwrap() = 1;
+ +// run-rustfix
++
+ +#![allow(unused_mut, clippy::from_iter_instead_of_collect)]
++#![warn(clippy::unwrap_used)]
+ +#![deny(clippy::get_unwrap)]
+ +
+ +use std::collections::BTreeMap;
+ +use std::collections::HashMap;
+ +use std::collections::VecDeque;
+ +use std::iter::FromIterator;
+ +
+ +struct GetFalsePositive {
+ +    arr: [u32; 3],
+ +}
+ +
+ +impl GetFalsePositive {
+ +    fn get(&self, pos: usize) -> Option<&u32> {
+ +        self.arr.get(pos)
+ +    }
+ +    fn get_mut(&mut self, pos: usize) -> Option<&mut u32> {
+ +        self.arr.get_mut(pos)
+ +    }
+ +}
+ +
+ +fn main() {
+ +    let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+ +    let mut some_slice = &mut [0, 1, 2, 3];
+ +    let mut some_vec = vec![0, 1, 2, 3];
+ +    let mut some_vecdeque: VecDeque<_> = some_vec.iter().cloned().collect();
+ +    let mut some_hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(1, 'a'), (2, 'b')]);
+ +    let mut some_btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(1, 'a'), (2, 'b')]);
+ +    let mut false_positive = GetFalsePositive { arr: [0, 1, 2] };
+ +
+ +    {
+ +        // Test `get().unwrap()`
+ +        let _ = &boxed_slice[1];
+ +        let _ = &some_slice[0];
+ +        let _ = &some_vec[0];
+ +        let _ = &some_vecdeque[0];
+ +        let _ = &some_hashmap[&1];
+ +        let _ = &some_btreemap[&1];
++        #[allow(clippy::unwrap_used)]
+ +        let _ = false_positive.get(0).unwrap();
+ +        // Test with deref
+ +        let _: u8 = boxed_slice[1];
+ +    }
+ +
+ +    {
+ +        // Test `get_mut().unwrap()`
+ +        boxed_slice[0] = 1;
+ +        some_slice[0] = 1;
+ +        some_vec[0] = 1;
+ +        some_vecdeque[0] = 1;
+ +        // Check false positives
++        #[allow(clippy::unwrap_used)]
++        {
++            *some_hashmap.get_mut(&1).unwrap() = 'b';
++            *some_btreemap.get_mut(&1).unwrap() = 'b';
++            *false_positive.get_mut(0).unwrap() = 1;
++        }
+ +    }
+ +
+ +    {
+ +        // Test `get().unwrap().foo()` and `get_mut().unwrap().bar()`
+ +        let _ = some_vec[0..1].to_vec();
+ +        let _ = some_vec[0..1].to_vec();
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/get_unwrap.rs

index c0c37bb7206631e48334b79ac731c178f25dde72,0000000000000000000000000000000000000000..d77a202aa39c3455026a095bd64e71b56c13fa40

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/get_unwrap.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/get_unwrap.rs
@@@ -1,62 -1,0 +1,68 @@@
-         *some_hashmap.get_mut(&1).unwrap() = 'b';
-         *some_btreemap.get_mut(&1).unwrap() = 'b';
-         *false_positive.get_mut(0).unwrap() = 1;
+ +// run-rustfix
++
+ +#![allow(unused_mut, clippy::from_iter_instead_of_collect)]
++#![warn(clippy::unwrap_used)]
+ +#![deny(clippy::get_unwrap)]
+ +
+ +use std::collections::BTreeMap;
+ +use std::collections::HashMap;
+ +use std::collections::VecDeque;
+ +use std::iter::FromIterator;
+ +
+ +struct GetFalsePositive {
+ +    arr: [u32; 3],
+ +}
+ +
+ +impl GetFalsePositive {
+ +    fn get(&self, pos: usize) -> Option<&u32> {
+ +        self.arr.get(pos)
+ +    }
+ +    fn get_mut(&mut self, pos: usize) -> Option<&mut u32> {
+ +        self.arr.get_mut(pos)
+ +    }
+ +}
+ +
+ +fn main() {
+ +    let mut boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
+ +    let mut some_slice = &mut [0, 1, 2, 3];
+ +    let mut some_vec = vec![0, 1, 2, 3];
+ +    let mut some_vecdeque: VecDeque<_> = some_vec.iter().cloned().collect();
+ +    let mut some_hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(1, 'a'), (2, 'b')]);
+ +    let mut some_btreemap: BTreeMap<u8, char> = BTreeMap::from_iter(vec![(1, 'a'), (2, 'b')]);
+ +    let mut false_positive = GetFalsePositive { arr: [0, 1, 2] };
+ +
+ +    {
+ +        // Test `get().unwrap()`
+ +        let _ = boxed_slice.get(1).unwrap();
+ +        let _ = some_slice.get(0).unwrap();
+ +        let _ = some_vec.get(0).unwrap();
+ +        let _ = some_vecdeque.get(0).unwrap();
+ +        let _ = some_hashmap.get(&1).unwrap();
+ +        let _ = some_btreemap.get(&1).unwrap();
++        #[allow(clippy::unwrap_used)]
+ +        let _ = false_positive.get(0).unwrap();
+ +        // Test with deref
+ +        let _: u8 = *boxed_slice.get(1).unwrap();
+ +    }
+ +
+ +    {
+ +        // Test `get_mut().unwrap()`
+ +        *boxed_slice.get_mut(0).unwrap() = 1;
+ +        *some_slice.get_mut(0).unwrap() = 1;
+ +        *some_vec.get_mut(0).unwrap() = 1;
+ +        *some_vecdeque.get_mut(0).unwrap() = 1;
+ +        // Check false positives
++        #[allow(clippy::unwrap_used)]
++        {
++            *some_hashmap.get_mut(&1).unwrap() = 'b';
++            *some_btreemap.get_mut(&1).unwrap() = 'b';
++            *false_positive.get_mut(0).unwrap() = 1;
++        }
+ +    }
+ +
+ +    {
+ +        // Test `get().unwrap().foo()` and `get_mut().unwrap().bar()`
+ +        let _ = some_vec.get(0..1).unwrap().to_vec();
+ +        let _ = some_vec.get_mut(0..1).unwrap().to_vec();
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/get_unwrap.stderr

index 76a098df82aa199adb0186eb098b0e540fc6ba91,0000000000000000000000000000000000000000..cb5f44fbd59ee6114a6f339a533c93cf24dbd5a9

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/get_unwrap.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/get_unwrap.stderr
@@@ -1,86 -1,0 +1,191 @@@
-   --> $DIR/get_unwrap.rs:34:17
+ +error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:3:9
++  --> $DIR/get_unwrap.rs:36:17
+ +   |
+ +LL |         let _ = boxed_slice.get(1).unwrap();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&boxed_slice[1]`
+ +   |
+ +note: the lint level is defined here
-   --> $DIR/get_unwrap.rs:35:17
++  --> $DIR/get_unwrap.rs:5:9
+ +   |
+ +LL | #![deny(clippy::get_unwrap)]
+ +   |         ^^^^^^^^^^^^^^^^^^
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:36:17
++   |
++LL |         let _ = boxed_slice.get(1).unwrap();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = note: `-D clippy::unwrap-used` implied by `-D warnings`
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:36:17
++  --> $DIR/get_unwrap.rs:37:17
+ +   |
+ +LL |         let _ = some_slice.get(0).unwrap();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_slice[0]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:37:17
++   |
++LL |         let _ = some_slice.get(0).unwrap();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:37:17
++  --> $DIR/get_unwrap.rs:38:17
+ +   |
+ +LL |         let _ = some_vec.get(0).unwrap();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vec[0]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:38:17
++   |
++LL |         let _ = some_vec.get(0).unwrap();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:38:17
++  --> $DIR/get_unwrap.rs:39:17
+ +   |
+ +LL |         let _ = some_vecdeque.get(0).unwrap();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_vecdeque[0]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:39:17
++   |
++LL |         let _ = some_vecdeque.get(0).unwrap();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:39:17
++  --> $DIR/get_unwrap.rs:40:17
+ +   |
+ +LL |         let _ = some_hashmap.get(&1).unwrap();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_hashmap[&1]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:40:17
++   |
++LL |         let _ = some_hashmap.get(&1).unwrap();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:42:21
++  --> $DIR/get_unwrap.rs:41:17
+ +   |
+ +LL |         let _ = some_btreemap.get(&1).unwrap();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `&some_btreemap[&1]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:41:17
++   |
++LL |         let _ = some_btreemap.get(&1).unwrap();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:47:9
++  --> $DIR/get_unwrap.rs:45:21
+ +   |
+ +LL |         let _: u8 = *boxed_slice.get(1).unwrap();
+ +   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[1]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:45:22
++   |
++LL |         let _: u8 = *boxed_slice.get(1).unwrap();
++   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:48:9
++  --> $DIR/get_unwrap.rs:50:9
+ +   |
+ +LL |         *boxed_slice.get_mut(0).unwrap() = 1;
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `boxed_slice[0]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:50:10
++   |
++LL |         *boxed_slice.get_mut(0).unwrap() = 1;
++   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:49:9
++  --> $DIR/get_unwrap.rs:51:9
+ +   |
+ +LL |         *some_slice.get_mut(0).unwrap() = 1;
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_slice[0]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:51:10
++   |
++LL |         *some_slice.get_mut(0).unwrap() = 1;
++   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:50:9
++  --> $DIR/get_unwrap.rs:52:9
+ +   |
+ +LL |         *some_vec.get_mut(0).unwrap() = 1;
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:52:10
++   |
++LL |         *some_vec.get_mut(0).unwrap() = 1;
++   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:59:17
++  --> $DIR/get_unwrap.rs:53:9
+ +   |
+ +LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
+ +   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vecdeque[0]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:53:10
++   |
++LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
++   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
-   --> $DIR/get_unwrap.rs:60:17
++  --> $DIR/get_unwrap.rs:65:17
+ +   |
+ +LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:65:17
++   |
++LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
+ +error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
- error: aborting due to 13 previous errors
++  --> $DIR/get_unwrap.rs:66:17
+ +   |
+ +LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
+ +   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try this: `some_vec[0..1]`
+ +
++error: used `unwrap()` on `an Option` value
++  --> $DIR/get_unwrap.rs:66:17
++   |
++LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
++   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = help: if you don't want to handle the `None` case gracefully, consider using `expect()` to provide a better panic message
++
++error: aborting due to 26 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/manual_assert.edition2018.fixed

index 6c2a25c37d8d73f6a1bd5960dbe8a8db954c91f7,0000000000000000000000000000000000000000..d0bc640db88994c7c59312de4dfcb001aa984a78

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/manual_assert.edition2018.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_assert.edition2018.fixed
@@@ -1,45 -1,0 +1,52 @@@
+ +// revisions: edition2018 edition2021
+ +// [edition2018] edition:2018
+ +// [edition2021] edition:2021
+ +// run-rustfix
+ +
+ +#![warn(clippy::manual_assert)]
+ +#![allow(clippy::nonminimal_bool)]
+ +
++macro_rules! one {
++    () => {
++        1
++    };
++}
++
+ +fn main() {
+ +    let a = vec![1, 2, 3];
+ +    let c = Some(2);
+ +    if !a.is_empty()
+ +        && a.len() == 3
+ +        && c != None
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +    {
+ +        panic!("qaqaq{:?}", a);
+ +    }
+ +    assert!(a.is_empty(), "qaqaq{:?}", a);
+ +    assert!(a.is_empty(), "qwqwq");
+ +    if a.len() == 3 {
+ +        println!("qwq");
+ +        println!("qwq");
+ +        println!("qwq");
+ +    }
+ +    if let Some(b) = c {
+ +        panic!("orz {}", b);
+ +    }
+ +    if a.len() == 3 {
+ +        panic!("qaqaq");
+ +    } else {
+ +        println!("qwq");
+ +    }
+ +    let b = vec![1, 2, 3];
+ +    assert!(!b.is_empty(), "panic1");
+ +    assert!(!(b.is_empty() && a.is_empty()), "panic2");
+ +    assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+ +    assert!(!(b.is_empty() || a.is_empty()), "panic4");
+ +    assert!(!(a.is_empty() || !b.is_empty()), "panic5");
++    assert!(!a.is_empty(), "with expansion {}", one!());
+ +}
diff --cc src/tools/clippy/tests/ui/manual_assert.edition2018.stderr

index 77511631e449a9c4768780d531694aafdf144909,0000000000000000000000000000000000000000..a0f31afd6ebfe5986ff06e2f716b539e713b1535

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/manual_assert.edition2018.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_assert.edition2018.stderr
@@@ -1,60 -1,0 +1,68 @@@
-   --> $DIR/manual_assert.rs:24:5
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:27:5
++  --> $DIR/manual_assert.rs:30:5
+ +   |
+ +LL | /     if !a.is_empty() {
+ +LL | |         panic!("qaqaq{:?}", a);
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+ +   |
+ +   = note: `-D clippy::manual-assert` implied by `-D warnings`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:44:5
++  --> $DIR/manual_assert.rs:33:5
+ +   |
+ +LL | /     if !a.is_empty() {
+ +LL | |         panic!("qwqwq");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:47:5
++  --> $DIR/manual_assert.rs:50:5
+ +   |
+ +LL | /     if b.is_empty() {
+ +LL | |         panic!("panic1");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:50:5
++  --> $DIR/manual_assert.rs:53:5
+ +   |
+ +LL | /     if b.is_empty() && a.is_empty() {
+ +LL | |         panic!("panic2");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:53:5
++  --> $DIR/manual_assert.rs:56:5
+ +   |
+ +LL | /     if a.is_empty() && !b.is_empty() {
+ +LL | |         panic!("panic3");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:56:5
++  --> $DIR/manual_assert.rs:59:5
+ +   |
+ +LL | /     if b.is_empty() || a.is_empty() {
+ +LL | |         panic!("panic4");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+ +
+ +error: only a `panic!` in `if`-then statement
- error: aborting due to 7 previous errors
++  --> $DIR/manual_assert.rs:62:5
+ +   |
+ +LL | /     if a.is_empty() || !b.is_empty() {
+ +LL | |         panic!("panic5");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+ +
++error: only a `panic!` in `if`-then statement
++  --> $DIR/manual_assert.rs:65:5
++   |
++LL | /     if a.is_empty() {
++LL | |         panic!("with expansion {}", one!())
++LL | |     }
++   | |_____^ help: try: `assert!(!a.is_empty(), "with expansion {}", one!());`
++
++error: aborting due to 8 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/manual_assert.edition2021.fixed

index 6c2a25c37d8d73f6a1bd5960dbe8a8db954c91f7,0000000000000000000000000000000000000000..d0bc640db88994c7c59312de4dfcb001aa984a78

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/manual_assert.edition2021.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_assert.edition2021.fixed
@@@ -1,45 -1,0 +1,52 @@@
+ +// revisions: edition2018 edition2021
+ +// [edition2018] edition:2018
+ +// [edition2021] edition:2021
+ +// run-rustfix
+ +
+ +#![warn(clippy::manual_assert)]
+ +#![allow(clippy::nonminimal_bool)]
+ +
++macro_rules! one {
++    () => {
++        1
++    };
++}
++
+ +fn main() {
+ +    let a = vec![1, 2, 3];
+ +    let c = Some(2);
+ +    if !a.is_empty()
+ +        && a.len() == 3
+ +        && c != None
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +    {
+ +        panic!("qaqaq{:?}", a);
+ +    }
+ +    assert!(a.is_empty(), "qaqaq{:?}", a);
+ +    assert!(a.is_empty(), "qwqwq");
+ +    if a.len() == 3 {
+ +        println!("qwq");
+ +        println!("qwq");
+ +        println!("qwq");
+ +    }
+ +    if let Some(b) = c {
+ +        panic!("orz {}", b);
+ +    }
+ +    if a.len() == 3 {
+ +        panic!("qaqaq");
+ +    } else {
+ +        println!("qwq");
+ +    }
+ +    let b = vec![1, 2, 3];
+ +    assert!(!b.is_empty(), "panic1");
+ +    assert!(!(b.is_empty() && a.is_empty()), "panic2");
+ +    assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+ +    assert!(!(b.is_empty() || a.is_empty()), "panic4");
+ +    assert!(!(a.is_empty() || !b.is_empty()), "panic5");
++    assert!(!a.is_empty(), "with expansion {}", one!());
+ +}
diff --cc src/tools/clippy/tests/ui/manual_assert.edition2021.stderr

index 77511631e449a9c4768780d531694aafdf144909,0000000000000000000000000000000000000000..a0f31afd6ebfe5986ff06e2f716b539e713b1535

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/manual_assert.edition2021.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_assert.edition2021.stderr
@@@ -1,60 -1,0 +1,68 @@@
-   --> $DIR/manual_assert.rs:24:5
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:27:5
++  --> $DIR/manual_assert.rs:30:5
+ +   |
+ +LL | /     if !a.is_empty() {
+ +LL | |         panic!("qaqaq{:?}", a);
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+ +   |
+ +   = note: `-D clippy::manual-assert` implied by `-D warnings`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:44:5
++  --> $DIR/manual_assert.rs:33:5
+ +   |
+ +LL | /     if !a.is_empty() {
+ +LL | |         panic!("qwqwq");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(a.is_empty(), "qwqwq");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:47:5
++  --> $DIR/manual_assert.rs:50:5
+ +   |
+ +LL | /     if b.is_empty() {
+ +LL | |         panic!("panic1");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!b.is_empty(), "panic1");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:50:5
++  --> $DIR/manual_assert.rs:53:5
+ +   |
+ +LL | /     if b.is_empty() && a.is_empty() {
+ +LL | |         panic!("panic2");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:53:5
++  --> $DIR/manual_assert.rs:56:5
+ +   |
+ +LL | /     if a.is_empty() && !b.is_empty() {
+ +LL | |         panic!("panic3");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+ +
+ +error: only a `panic!` in `if`-then statement
-   --> $DIR/manual_assert.rs:56:5
++  --> $DIR/manual_assert.rs:59:5
+ +   |
+ +LL | /     if b.is_empty() || a.is_empty() {
+ +LL | |         panic!("panic4");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+ +
+ +error: only a `panic!` in `if`-then statement
- error: aborting due to 7 previous errors
++  --> $DIR/manual_assert.rs:62:5
+ +   |
+ +LL | /     if a.is_empty() || !b.is_empty() {
+ +LL | |         panic!("panic5");
+ +LL | |     }
+ +   | |_____^ help: try: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+ +
++error: only a `panic!` in `if`-then statement
++  --> $DIR/manual_assert.rs:65:5
++   |
++LL | /     if a.is_empty() {
++LL | |         panic!("with expansion {}", one!())
++LL | |     }
++   | |_____^ help: try: `assert!(!a.is_empty(), "with expansion {}", one!());`
++
++error: aborting due to 8 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/manual_assert.rs

index d3e0897488f0c1ce8f315c4f8e4cf367e2f6ee76,0000000000000000000000000000000000000000..027747d8386319431e82d9a836cf095063d2f2b9

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/manual_assert.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_assert.rs
@@@ -1,59 -1,0 +1,68 @@@
+ +// revisions: edition2018 edition2021
+ +// [edition2018] edition:2018
+ +// [edition2021] edition:2021
+ +// run-rustfix
+ +
+ +#![warn(clippy::manual_assert)]
+ +#![allow(clippy::nonminimal_bool)]
+ +
++macro_rules! one {
++    () => {
++        1
++    };
++}
++
+ +fn main() {
+ +    let a = vec![1, 2, 3];
+ +    let c = Some(2);
+ +    if !a.is_empty()
+ +        && a.len() == 3
+ +        && c != None
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +        && !a.is_empty()
+ +        && a.len() == 3
+ +    {
+ +        panic!("qaqaq{:?}", a);
+ +    }
+ +    if !a.is_empty() {
+ +        panic!("qaqaq{:?}", a);
+ +    }
+ +    if !a.is_empty() {
+ +        panic!("qwqwq");
+ +    }
+ +    if a.len() == 3 {
+ +        println!("qwq");
+ +        println!("qwq");
+ +        println!("qwq");
+ +    }
+ +    if let Some(b) = c {
+ +        panic!("orz {}", b);
+ +    }
+ +    if a.len() == 3 {
+ +        panic!("qaqaq");
+ +    } else {
+ +        println!("qwq");
+ +    }
+ +    let b = vec![1, 2, 3];
+ +    if b.is_empty() {
+ +        panic!("panic1");
+ +    }
+ +    if b.is_empty() && a.is_empty() {
+ +        panic!("panic2");
+ +    }
+ +    if a.is_empty() && !b.is_empty() {
+ +        panic!("panic3");
+ +    }
+ +    if b.is_empty() || a.is_empty() {
+ +        panic!("panic4");
+ +    }
+ +    if a.is_empty() || !b.is_empty() {
+ +        panic!("panic5");
+ +    }
++    if a.is_empty() {
++        panic!("with expansion {}", one!())
++    }
+ +}
diff --cc src/tools/clippy/tests/ui/manual_flatten.rs

index 7db6b730963c94f6399e4ff2a69921b2a0d3ff61,0000000000000000000000000000000000000000..6c5232ec5f55b7d0e59dec9373f55b4f91cd0f16

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/manual_flatten.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_flatten.rs
@@@ -1,111 -1,0 +1,109 @@@
-     // Note: if `clippy::manual_flatten` is made autofixable, this case will
-     // lead to a follow-up lint `clippy::into_iter_on_ref`
+ +#![warn(clippy::manual_flatten)]
+ +#![allow(clippy::useless_vec)]
+ +
+ +fn main() {
+ +    // Test for loop over implicitly adjusted `Iterator` with `if let` expression
+ +    let x = vec![Some(1), Some(2), Some(3)];
+ +    for n in x {
+ +        if let Some(y) = n {
+ +            println!("{}", y);
+ +        }
+ +    }
+ +
+ +    // Test for loop over implicitly implicitly adjusted `Iterator` with `if let` statement
+ +    let y: Vec<Result<i32, i32>> = vec![];
+ +    for n in y.clone() {
+ +        if let Ok(n) = n {
+ +            println!("{}", n);
+ +        };
+ +    }
+ +
+ +    // Test for loop over by reference
+ +    for n in &y {
+ +        if let Ok(n) = n {
+ +            println!("{}", n);
+ +        }
+ +    }
+ +
+ +    // Test for loop over an implicit reference
+ +    let z = &y;
+ +    for n in z {
+ +        if let Ok(n) = n {
+ +            println!("{}", n);
+ +        }
+ +    }
+ +
+ +    // Test for loop over `Iterator` with `if let` expression
+ +    let z = vec![Some(1), Some(2), Some(3)];
+ +    let z = z.iter();
+ +    for n in z {
+ +        if let Some(m) = n {
+ +            println!("{}", m);
+ +        }
+ +    }
+ +
+ +    // Using the `None` variant should not trigger the lint
+ +    // Note: for an autofixable suggestion, the binding in the for loop has to take the
+ +    // name of the binding in the `if let`
+ +    let z = vec![Some(1), Some(2), Some(3)];
+ +    for n in z {
+ +        if n.is_none() {
+ +            println!("Nada.");
+ +        }
+ +    }
+ +
+ +    // Using the `Err` variant should not trigger the lint
+ +    for n in y.clone() {
+ +        if let Err(e) = n {
+ +            println!("Oops: {}!", e);
+ +        }
+ +    }
+ +
+ +    // Having an else clause should not trigger the lint
+ +    for n in y.clone() {
+ +        if let Ok(n) = n {
+ +            println!("{}", n);
+ +        } else {
+ +            println!("Oops!");
+ +        }
+ +    }
+ +
+ +    let vec_of_ref = vec![&Some(1)];
+ +    for n in &vec_of_ref {
+ +        if let Some(n) = n {
+ +            println!("{:?}", n);
+ +        }
+ +    }
+ +
+ +    let vec_of_ref = &vec_of_ref;
+ +    for n in vec_of_ref {
+ +        if let Some(n) = n {
+ +            println!("{:?}", n);
+ +        }
+ +    }
+ +
+ +    let slice_of_ref = &[&Some(1)];
+ +    for n in slice_of_ref {
+ +        if let Some(n) = n {
+ +            println!("{:?}", n);
+ +        }
+ +    }
+ +
+ +    struct Test {
+ +        a: usize,
+ +    }
+ +
+ +    let mut vec_of_struct = [Some(Test { a: 1 }), None];
+ +
+ +    // Usage of `if let` expression should not trigger lint
+ +    for n in vec_of_struct.iter_mut() {
+ +        if let Some(z) = n {
+ +            *n = None;
+ +        }
+ +    }
+ +
+ +    // Using manual flatten should not trigger the lint
+ +    for n in vec![Some(1), Some(2), Some(3)].iter().flatten() {
+ +        println!("{}", n);
+ +    }
+ +}
diff --cc src/tools/clippy/tests/ui/manual_flatten.stderr

index be5f8a1d818847b8ce672df247d5e218d80bbd71,0000000000000000000000000000000000000000..392e1a39393754214ce44a4c04bdc222b85cb6b3

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/manual_flatten.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_flatten.stderr
@@@ -1,171 -1,0 +1,171 @@@
-   --> $DIR/manual_flatten.rs:32:5
+ +error: unnecessary `if let` since only the `Some` variant of the iterator element is used
+ +  --> $DIR/manual_flatten.rs:7:5
+ +   |
+ +LL |       for n in x {
+ +   |       ^        - help: try: `x.into_iter().flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Some(y) = n {
+ +LL | |             println!("{}", y);
+ +LL | |         }
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +   = note: `-D clippy::manual-flatten` implied by `-D warnings`
+ +help: ...and remove the `if let` statement in the for loop
+ +  --> $DIR/manual_flatten.rs:8:9
+ +   |
+ +LL | /         if let Some(y) = n {
+ +LL | |             println!("{}", y);
+ +LL | |         }
+ +   | |_________^
+ +
+ +error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
+ +  --> $DIR/manual_flatten.rs:15:5
+ +   |
+ +LL |       for n in y.clone() {
+ +   |       ^        --------- help: try: `y.clone().into_iter().flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Ok(n) = n {
+ +LL | |             println!("{}", n);
+ +LL | |         };
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +help: ...and remove the `if let` statement in the for loop
+ +  --> $DIR/manual_flatten.rs:16:9
+ +   |
+ +LL | /         if let Ok(n) = n {
+ +LL | |             println!("{}", n);
+ +LL | |         };
+ +   | |_________^
+ +
+ +error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
+ +  --> $DIR/manual_flatten.rs:22:5
+ +   |
+ +LL |       for n in &y {
+ +   |       ^        -- help: try: `y.iter().flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Ok(n) = n {
+ +LL | |             println!("{}", n);
+ +LL | |         }
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +help: ...and remove the `if let` statement in the for loop
+ +  --> $DIR/manual_flatten.rs:23:9
+ +   |
+ +LL | /         if let Ok(n) = n {
+ +LL | |             println!("{}", n);
+ +LL | |         }
+ +   | |_________^
+ +
+ +error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
-    |       ^        - help: try: `z.into_iter().flatten()`
++  --> $DIR/manual_flatten.rs:30:5
+ +   |
+ +LL |       for n in z {
-   --> $DIR/manual_flatten.rs:33:9
++   |       ^        - help: try: `z.iter().flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Ok(n) = n {
+ +LL | |             println!("{}", n);
+ +LL | |         }
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +help: ...and remove the `if let` statement in the for loop
-   --> $DIR/manual_flatten.rs:41:5
++  --> $DIR/manual_flatten.rs:31:9
+ +   |
+ +LL | /         if let Ok(n) = n {
+ +LL | |             println!("{}", n);
+ +LL | |         }
+ +   | |_________^
+ +
+ +error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-   --> $DIR/manual_flatten.rs:42:9
++  --> $DIR/manual_flatten.rs:39:5
+ +   |
+ +LL |       for n in z {
+ +   |       ^        - help: try: `z.flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Some(m) = n {
+ +LL | |             println!("{}", m);
+ +LL | |         }
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +help: ...and remove the `if let` statement in the for loop
-   --> $DIR/manual_flatten.rs:74:5
++  --> $DIR/manual_flatten.rs:40:9
+ +   |
+ +LL | /         if let Some(m) = n {
+ +LL | |             println!("{}", m);
+ +LL | |         }
+ +   | |_________^
+ +
+ +error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-   --> $DIR/manual_flatten.rs:75:9
++  --> $DIR/manual_flatten.rs:72:5
+ +   |
+ +LL |       for n in &vec_of_ref {
+ +   |       ^        ----------- help: try: `vec_of_ref.iter().copied().flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Some(n) = n {
+ +LL | |             println!("{:?}", n);
+ +LL | |         }
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +help: ...and remove the `if let` statement in the for loop
-   --> $DIR/manual_flatten.rs:81:5
++  --> $DIR/manual_flatten.rs:73:9
+ +   |
+ +LL | /         if let Some(n) = n {
+ +LL | |             println!("{:?}", n);
+ +LL | |         }
+ +   | |_________^
+ +
+ +error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-    |       ^        ---------- help: try: `vec_of_ref.into_iter().copied().flatten()`
++  --> $DIR/manual_flatten.rs:79:5
+ +   |
+ +LL |       for n in vec_of_ref {
-   --> $DIR/manual_flatten.rs:82:9
++   |       ^        ---------- help: try: `vec_of_ref.iter().copied().flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Some(n) = n {
+ +LL | |             println!("{:?}", n);
+ +LL | |         }
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +help: ...and remove the `if let` statement in the for loop
-   --> $DIR/manual_flatten.rs:88:5
++  --> $DIR/manual_flatten.rs:80:9
+ +   |
+ +LL | /         if let Some(n) = n {
+ +LL | |             println!("{:?}", n);
+ +LL | |         }
+ +   | |_________^
+ +
+ +error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-    |       ^        ------------ help: try: `slice_of_ref.into_iter().copied().flatten()`
++  --> $DIR/manual_flatten.rs:86:5
+ +   |
+ +LL |       for n in slice_of_ref {
-   --> $DIR/manual_flatten.rs:89:9
++   |       ^        ------------ help: try: `slice_of_ref.iter().copied().flatten()`
+ +   |  _____|
+ +   | |
+ +LL | |         if let Some(n) = n {
+ +LL | |             println!("{:?}", n);
+ +LL | |         }
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +help: ...and remove the `if let` statement in the for loop
++  --> $DIR/manual_flatten.rs:87:9
+ +   |
+ +LL | /         if let Some(n) = n {
+ +LL | |             println!("{:?}", n);
+ +LL | |         }
+ +   | |_________^
+ +
+ +error: aborting due to 8 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/ptr_arg.rs

index ed72423780821792ae61ea24d6fb322547465e16,0000000000000000000000000000000000000000..00b99da2631c630aa1ef6e227e50c4c7f678f027

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/ptr_arg.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/ptr_arg.rs
@@@ -1,182 -1,0 +1,188 @@@
+ +#![allow(unused, clippy::many_single_char_names, clippy::redundant_clone)]
+ +#![warn(clippy::ptr_arg)]
+ +
+ +use std::borrow::Cow;
+ +use std::path::PathBuf;
+ +
+ +fn do_vec(x: &Vec<i64>) {
+ +    //Nothing here
+ +}
+ +
+ +fn do_vec_mut(x: &mut Vec<i64>) {
+ +    //Nothing here
+ +}
+ +
+ +fn do_str(x: &String) {
+ +    //Nothing here either
+ +}
+ +
+ +fn do_str_mut(x: &mut String) {
+ +    //Nothing here either
+ +}
+ +
+ +fn do_path(x: &PathBuf) {
+ +    //Nothing here either
+ +}
+ +
+ +fn do_path_mut(x: &mut PathBuf) {
+ +    //Nothing here either
+ +}
+ +
+ +fn main() {}
+ +
+ +trait Foo {
+ +    type Item;
+ +    fn do_vec(x: &Vec<i64>);
+ +    fn do_item(x: &Self::Item);
+ +}
+ +
+ +struct Bar;
+ +
+ +// no error, in trait impl (#425)
+ +impl Foo for Bar {
+ +    type Item = Vec<u8>;
+ +    fn do_vec(x: &Vec<i64>) {}
+ +    fn do_item(x: &Vec<u8>) {}
+ +}
+ +
+ +fn cloned(x: &Vec<u8>) -> Vec<u8> {
+ +    let e = x.clone();
+ +    let f = e.clone(); // OK
+ +    let g = x;
+ +    let h = g.clone();
+ +    let i = (e).clone();
+ +    x.clone()
+ +}
+ +
+ +fn str_cloned(x: &String) -> String {
+ +    let a = x.clone();
+ +    let b = x.clone();
+ +    let c = b.clone();
+ +    let d = a.clone().clone().clone();
+ +    x.clone()
+ +}
+ +
+ +fn path_cloned(x: &PathBuf) -> PathBuf {
+ +    let a = x.clone();
+ +    let b = x.clone();
+ +    let c = b.clone();
+ +    let d = a.clone().clone().clone();
+ +    x.clone()
+ +}
+ +
+ +fn false_positive_capacity(x: &Vec<u8>, y: &String) {
+ +    let a = x.capacity();
+ +    let b = y.clone();
+ +    let c = y.as_str();
+ +}
+ +
+ +fn false_positive_capacity_too(x: &String) -> String {
+ +    if x.capacity() > 1024 {
+ +        panic!("Too large!");
+ +    }
+ +    x.clone()
+ +}
+ +
+ +#[allow(dead_code)]
+ +fn test_cow_with_ref(c: &Cow<[i32]>) {}
+ +
+ +fn test_cow(c: Cow<[i32]>) {
+ +    let _c = c;
+ +}
+ +
+ +trait Foo2 {
+ +    fn do_string(&self);
+ +}
+ +
+ +// no error for &self references where self is of type String (#2293)
+ +impl Foo2 for String {
+ +    fn do_string(&self) {}
+ +}
+ +
+ +// Check that the allow attribute on parameters is honored
+ +mod issue_5644 {
+ +    use std::borrow::Cow;
+ +    use std::path::PathBuf;
+ +
+ +    fn allowed(
+ +        #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
+ +        #[allow(clippy::ptr_arg)] _s: &String,
+ +        #[allow(clippy::ptr_arg)] _p: &PathBuf,
+ +        #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+ +    ) {
+ +    }
+ +
+ +    struct S {}
+ +    impl S {
+ +        fn allowed(
+ +            #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
+ +            #[allow(clippy::ptr_arg)] _s: &String,
+ +            #[allow(clippy::ptr_arg)] _p: &PathBuf,
+ +            #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+ +        ) {
+ +        }
+ +    }
+ +
+ +    trait T {
+ +        fn allowed(
+ +            #[allow(clippy::ptr_arg)] _v: &Vec<u32>,
+ +            #[allow(clippy::ptr_arg)] _s: &String,
+ +            #[allow(clippy::ptr_arg)] _p: &PathBuf,
+ +            #[allow(clippy::ptr_arg)] _c: &Cow<[i32]>,
+ +        ) {
+ +        }
+ +    }
+ +}
+ +
+ +mod issue6509 {
+ +    use std::path::PathBuf;
+ +
+ +    fn foo_vec(vec: &Vec<u8>) {
+ +        let _ = vec.clone().pop();
+ +        let _ = vec.clone().clone();
+ +    }
+ +
+ +    fn foo_path(path: &PathBuf) {
+ +        let _ = path.clone().pop();
+ +        let _ = path.clone().clone();
+ +    }
+ +
+ +    fn foo_str(str: &PathBuf) {
+ +        let _ = str.clone().pop();
+ +        let _ = str.clone().clone();
+ +    }
+ +}
+ +
+ +fn mut_vec_slice_methods(v: &mut Vec<u32>) {
+ +    v.copy_within(1..5, 10);
+ +}
+ +
+ +fn mut_vec_vec_methods(v: &mut Vec<u32>) {
+ +    v.clear();
+ +}
+ +
+ +fn vec_contains(v: &Vec<u32>) -> bool {
+ +    [vec![], vec![0]].as_slice().contains(v)
+ +}
+ +
+ +fn fn_requires_vec(v: &Vec<u32>) -> bool {
+ +    vec_contains(v)
+ +}
+ +
+ +fn impl_fn_requires_vec(v: &Vec<u32>, f: impl Fn(&Vec<u32>)) {
+ +    f(v);
+ +}
+ +
+ +fn dyn_fn_requires_vec(v: &Vec<u32>, f: &dyn Fn(&Vec<u32>)) {
+ +    f(v);
+ +}
+ +
+ +// No error for types behind an alias (#7699)
+ +type A = Vec<u8>;
+ +fn aliased(a: &A) {}
++
++// Issue #8366
++pub trait Trait {
++    fn f(v: &mut Vec<i32>);
++    fn f2(v: &mut Vec<i32>) {}
++}
diff --cc src/tools/clippy/tests/ui/single_match.rs

index b1819e08d53bf5dc9054e41cde25c580077082c5,0000000000000000000000000000000000000000..bd371888046361ceea6c5ce3b9c866301df7e5a4

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/single_match.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/single_match.rs
@@@ -1,159 -1,0 +1,237 @@@
+ +#![warn(clippy::single_match)]
+ +
+ +fn dummy() {}
+ +
+ +fn single_match() {
+ +    let x = Some(1u8);
+ +
+ +    match x {
+ +        Some(y) => {
+ +            println!("{:?}", y);
+ +        },
+ +        _ => (),
+ +    };
+ +
+ +    let x = Some(1u8);
+ +    match x {
+ +        // Note the missing block braces.
+ +        // We suggest `if let Some(y) = x { .. }` because the macro
+ +        // is expanded before we can do anything.
+ +        Some(y) => println!("{:?}", y),
+ +        _ => (),
+ +    }
+ +
+ +    let z = (1u8, 1u8);
+ +    match z {
+ +        (2..=3, 7..=9) => dummy(),
+ +        _ => {},
+ +    };
+ +
+ +    // Not linted (pattern guards used)
+ +    match x {
+ +        Some(y) if y == 0 => println!("{:?}", y),
+ +        _ => (),
+ +    }
+ +
+ +    // Not linted (no block with statements in the single arm)
+ +    match z {
+ +        (2..=3, 7..=9) => println!("{:?}", z),
+ +        _ => println!("nope"),
+ +    }
+ +}
+ +
+ +enum Foo {
+ +    Bar,
+ +    Baz(u8),
+ +}
+ +use std::borrow::Cow;
+ +use Foo::*;
+ +
+ +fn single_match_know_enum() {
+ +    let x = Some(1u8);
+ +    let y: Result<_, i8> = Ok(1i8);
+ +
+ +    match x {
+ +        Some(y) => dummy(),
+ +        None => (),
+ +    };
+ +
+ +    match y {
+ +        Ok(y) => dummy(),
+ +        Err(..) => (),
+ +    };
+ +
+ +    let c = Cow::Borrowed("");
+ +
+ +    match c {
+ +        Cow::Borrowed(..) => dummy(),
+ +        Cow::Owned(..) => (),
+ +    };
+ +
+ +    let z = Foo::Bar;
+ +    // no warning
+ +    match z {
+ +        Bar => println!("42"),
+ +        Baz(_) => (),
+ +    }
+ +
+ +    match z {
+ +        Baz(_) => println!("42"),
+ +        Bar => (),
+ +    }
+ +}
+ +
+ +// issue #173
+ +fn if_suggestion() {
+ +    let x = "test";
+ +    match x {
+ +        "test" => println!(),
+ +        _ => (),
+ +    }
+ +
+ +    #[derive(PartialEq, Eq)]
+ +    enum Foo {
+ +        A,
+ +        B,
+ +        C(u32),
+ +    }
+ +
+ +    let x = Foo::A;
+ +    match x {
+ +        Foo::A => println!(),
+ +        _ => (),
+ +    }
+ +
+ +    const FOO_C: Foo = Foo::C(0);
+ +    match x {
+ +        FOO_C => println!(),
+ +        _ => (),
+ +    }
+ +
+ +    match &&x {
+ +        Foo::A => println!(),
+ +        _ => (),
+ +    }
+ +
+ +    let x = &x;
+ +    match &x {
+ +        Foo::A => println!(),
+ +        _ => (),
+ +    }
+ +
+ +    enum Bar {
+ +        A,
+ +        B,
+ +    }
+ +    impl PartialEq for Bar {
+ +        fn eq(&self, rhs: &Self) -> bool {
+ +            matches!((self, rhs), (Self::A, Self::A) | (Self::B, Self::B))
+ +        }
+ +    }
+ +    impl Eq for Bar {}
+ +
+ +    let x = Bar::A;
+ +    match x {
+ +        Bar::A => println!(),
+ +        _ => (),
+ +    }
+ +
+ +    // issue #7038
+ +    struct X;
+ +    let x = Some(X);
+ +    match x {
+ +        None => println!(),
+ +        _ => (),
+ +    };
+ +}
+ +
++// See: issue #8282
++fn ranges() {
++    enum E {
++        V,
++    }
++    let x = (Some(E::V), Some(42));
++
++    // Don't lint, because the `E` enum can be extended with additional fields later. Thus, the
++    // proposed replacement to `if let Some(E::V)` may hide non-exhaustive warnings that appeared
++    // because of `match` construction.
++    match x {
++        (Some(E::V), _) => {},
++        (None, _) => {},
++    }
++
++    // lint
++    match x {
++        (Some(_), _) => {},
++        (None, _) => {},
++    }
++
++    // lint
++    match x {
++        (Some(E::V), _) => todo!(),
++        (_, _) => {},
++    }
++
++    // lint
++    match (Some(42), Some(E::V), Some(42)) {
++        (.., Some(E::V), _) => {},
++        (..) => {},
++    }
++
++    // Don't lint, see above.
++    match (Some(E::V), Some(E::V), Some(E::V)) {
++        (.., Some(E::V), _) => {},
++        (.., None, _) => {},
++    }
++
++    // Don't lint, see above.
++    match (Some(E::V), Some(E::V), Some(E::V)) {
++        (Some(E::V), ..) => {},
++        (None, ..) => {},
++    }
++
++    // Don't lint, see above.
++    match (Some(E::V), Some(E::V), Some(E::V)) {
++        (_, Some(E::V), ..) => {},
++        (_, None, ..) => {},
++    }
++}
++
++fn skip_type_aliases() {
++    enum OptionEx {
++        Some(i32),
++        None,
++    }
++    enum ResultEx {
++        Err(i32),
++        Ok(i32),
++    }
++
++    use OptionEx::{None, Some};
++    use ResultEx::{Err, Ok};
++
++    // don't lint
++    match Err(42) {
++        Ok(_) => dummy(),
++        Err(_) => (),
++    };
++
++    // don't lint
++    match Some(1i32) {
++        Some(_) => dummy(),
++        None => (),
++    };
++}
++
+ +macro_rules! single_match {
+ +    ($num:literal) => {
+ +        match $num {
+ +            15 => println!("15"),
+ +            _ => (),
+ +        }
+ +    };
+ +}
+ +
+ +fn main() {
+ +    single_match!(5);
+ +}
diff --cc src/tools/clippy/tests/ui/single_match.stderr

index c261b5111c8bf3edb40c7adf333968aadcb2b555,0000000000000000000000000000000000000000..318faf2571758a1c5c7b7069207c014f645c8f90

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/single_match.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/single_match.stderr
@@@ -1,132 -1,0 +1,150 @@@
- error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-   --> $DIR/single_match.rs:54:5
-    |
- LL | /     match x {
- LL | |         Some(y) => dummy(),
- LL | |         None => (),
- LL | |     };
-    | |_____^ help: try this: `if let Some(y) = x { dummy() }`
- 
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match.rs:8:5
+ +   |
+ +LL | /     match x {
+ +LL | |         Some(y) => {
+ +LL | |             println!("{:?}", y);
+ +LL | |         },
+ +LL | |         _ => (),
+ +LL | |     };
+ +   | |_____^
+ +   |
+ +   = note: `-D clippy::single-match` implied by `-D warnings`
+ +help: try this
+ +   |
+ +LL ~     if let Some(y) = x {
+ +LL +         println!("{:?}", y);
+ +LL ~     };
+ +   |
+ +
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match.rs:16:5
+ +   |
+ +LL | /     match x {
+ +LL | |         // Note the missing block braces.
+ +LL | |         // We suggest `if let Some(y) = x { .. }` because the macro
+ +LL | |         // is expanded before we can do anything.
+ +LL | |         Some(y) => println!("{:?}", y),
+ +LL | |         _ => (),
+ +LL | |     }
+ +   | |_____^ help: try this: `if let Some(y) = x { println!("{:?}", y) }`
+ +
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match.rs:25:5
+ +   |
+ +LL | /     match z {
+ +LL | |         (2..=3, 7..=9) => dummy(),
+ +LL | |         _ => {},
+ +LL | |     };
+ +   | |_____^ help: try this: `if let (2..=3, 7..=9) = z { dummy() }`
+ +
- error: aborting due to 13 previous errors
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match.rs:59:5
+ +   |
+ +LL | /     match y {
+ +LL | |         Ok(y) => dummy(),
+ +LL | |         Err(..) => (),
+ +LL | |     };
+ +   | |_____^ help: try this: `if let Ok(y) = y { dummy() }`
+ +
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match.rs:66:5
+ +   |
+ +LL | /     match c {
+ +LL | |         Cow::Borrowed(..) => dummy(),
+ +LL | |         Cow::Owned(..) => (),
+ +LL | |     };
+ +   | |_____^ help: try this: `if let Cow::Borrowed(..) = c { dummy() }`
+ +
+ +error: you seem to be trying to use `match` for an equality check. Consider using `if`
+ +  --> $DIR/single_match.rs:87:5
+ +   |
+ +LL | /     match x {
+ +LL | |         "test" => println!(),
+ +LL | |         _ => (),
+ +LL | |     }
+ +   | |_____^ help: try this: `if x == "test" { println!() }`
+ +
+ +error: you seem to be trying to use `match` for an equality check. Consider using `if`
+ +  --> $DIR/single_match.rs:100:5
+ +   |
+ +LL | /     match x {
+ +LL | |         Foo::A => println!(),
+ +LL | |         _ => (),
+ +LL | |     }
+ +   | |_____^ help: try this: `if x == Foo::A { println!() }`
+ +
+ +error: you seem to be trying to use `match` for an equality check. Consider using `if`
+ +  --> $DIR/single_match.rs:106:5
+ +   |
+ +LL | /     match x {
+ +LL | |         FOO_C => println!(),
+ +LL | |         _ => (),
+ +LL | |     }
+ +   | |_____^ help: try this: `if x == FOO_C { println!() }`
+ +
+ +error: you seem to be trying to use `match` for an equality check. Consider using `if`
+ +  --> $DIR/single_match.rs:111:5
+ +   |
+ +LL | /     match &&x {
+ +LL | |         Foo::A => println!(),
+ +LL | |         _ => (),
+ +LL | |     }
+ +   | |_____^ help: try this: `if x == Foo::A { println!() }`
+ +
+ +error: you seem to be trying to use `match` for an equality check. Consider using `if`
+ +  --> $DIR/single_match.rs:117:5
+ +   |
+ +LL | /     match &x {
+ +LL | |         Foo::A => println!(),
+ +LL | |         _ => (),
+ +LL | |     }
+ +   | |_____^ help: try this: `if x == &Foo::A { println!() }`
+ +
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match.rs:134:5
+ +   |
+ +LL | /     match x {
+ +LL | |         Bar::A => println!(),
+ +LL | |         _ => (),
+ +LL | |     }
+ +   | |_____^ help: try this: `if let Bar::A = x { println!() }`
+ +
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match.rs:142:5
+ +   |
+ +LL | /     match x {
+ +LL | |         None => println!(),
+ +LL | |         _ => (),
+ +LL | |     };
+ +   | |_____^ help: try this: `if let None = x { println!() }`
+ +
++error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
++  --> $DIR/single_match.rs:164:5
++   |
++LL | /     match x {
++LL | |         (Some(_), _) => {},
++LL | |         (None, _) => {},
++LL | |     }
++   | |_____^ help: try this: `if let (Some(_), _) = x {}`
++
++error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
++  --> $DIR/single_match.rs:170:5
++   |
++LL | /     match x {
++LL | |         (Some(E::V), _) => todo!(),
++LL | |         (_, _) => {},
++LL | |     }
++   | |_____^ help: try this: `if let (Some(E::V), _) = x { todo!() }`
++
++error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
++  --> $DIR/single_match.rs:176:5
++   |
++LL | /     match (Some(42), Some(E::V), Some(42)) {
++LL | |         (.., Some(E::V), _) => {},
++LL | |         (..) => {},
++LL | |     }
++   | |_____^ help: try this: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
++
++error: aborting due to 15 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/single_match_else.stderr

index c61d80a905c9f0d0d5b097641c4d6719c7c8dc08,0000000000000000000000000000000000000000..21ea704b62ab5c9134fcccdcda1d853a27af1c42

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/single_match_else.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/single_match_else.stderr
@@@ -1,63 -1,0 +1,23 @@@
- error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-   --> $DIR/single_match_else.rs:70:5
-    |
- LL | /     match Some(1) {
- LL | |         Some(a) => println!("${:?}", a),
- LL | |         None => {
- LL | |             println!("else block");
- LL | |             return
- LL | |         },
- LL | |     }
-    | |_____^
-    |
- help: try this
-    |
- LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
- LL +         println!("else block");
- LL +         return
- LL +     }
-    |
- 
- error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-   --> $DIR/single_match_else.rs:79:5
-    |
- LL | /     match Some(1) {
- LL | |         Some(a) => println!("${:?}", a),
- LL | |         None => {
- LL | |             println!("else block");
- LL | |             return;
- LL | |         },
- LL | |     }
-    | |_____^
-    |
- help: try this
-    |
- LL ~     if let Some(a) = Some(1) { println!("${:?}", a) } else {
- LL +         println!("else block");
- LL +         return;
- LL +     }
-    |
- 
- error: aborting due to 3 previous errors
+ +error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+ +  --> $DIR/single_match_else.rs:14:5
+ +   |
+ +LL | /     match ExprNode::Butterflies {
+ +LL | |         ExprNode::ExprAddrOf => Some(&NODE),
+ +LL | |         _ => {
+ +LL | |             let x = 5;
+ +LL | |             None
+ +LL | |         },
+ +LL | |     }
+ +   | |_____^
+ +   |
+ +   = note: `-D clippy::single-match-else` implied by `-D warnings`
+ +help: try this
+ +   |
+ +LL ~     if let ExprNode::ExprAddrOf = ExprNode::Butterflies { Some(&NODE) } else {
+ +LL +         let x = 5;
+ +LL +         None
+ +LL +     }
+ +   |
+ +
++error: aborting due to previous error
+ +
diff --cc src/tools/clippy/tests/ui/starts_ends_with.fixed

index 7dfcf9c91e486a8b4bd7273660f4b358b99611c1,0000000000000000000000000000000000000000..983fac7afe69a58c42ea43c4a1cfc7881a9b3bd7

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/starts_ends_with.fixed
--- /dev/null
+++ b/src/tools/clippy/tests/ui/starts_ends_with.fixed
@@@ -1,46 -1,0 +1,54 @@@
-     if !s.ends_with('o') {
+ +// run-rustfix
+ +#![allow(dead_code, unused_must_use)]
+ +
+ +fn main() {}
+ +
+ +#[allow(clippy::unnecessary_operation)]
+ +fn starts_with() {
+ +    "".starts_with(' ');
+ +    !"".starts_with(' ');
++
++    // Ensure that suggestion is escaped correctly
++    "".starts_with('\n');
++    !"".starts_with('\n');
+ +}
+ +
+ +fn chars_cmp_with_unwrap() {
+ +    let s = String::from("foo");
+ +    if s.starts_with('f') {
+ +        // s.starts_with('f')
+ +        // Nothing here
+ +    }
+ +    if s.ends_with('o') {
+ +        // s.ends_with('o')
+ +        // Nothing here
+ +    }
+ +    if s.ends_with('o') {
+ +        // s.ends_with('o')
+ +        // Nothing here
+ +    }
+ +    if !s.starts_with('f') {
+ +        // !s.starts_with('f')
+ +        // Nothing here
+ +    }
+ +    if !s.ends_with('o') {
+ +        // !s.ends_with('o')
+ +        // Nothing here
+ +    }
++    if !s.ends_with('\n') {
+ +        // !s.ends_with('o')
+ +        // Nothing here
+ +    }
+ +}
+ +
+ +#[allow(clippy::unnecessary_operation)]
+ +fn ends_with() {
+ +    "".ends_with(' ');
+ +    !"".ends_with(' ');
+ +    "".ends_with(' ');
+ +    !"".ends_with(' ');
++
++    // Ensure that suggestion is escaped correctly
++    "".ends_with('\n');
++    !"".ends_with('\n');
+ +}
diff --cc src/tools/clippy/tests/ui/starts_ends_with.rs

index e48a4246354391000da93003a6347b02bafbd0cc,0000000000000000000000000000000000000000..e3335dd2e2ef7727f6e92500fbeebb4450a47164

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/starts_ends_with.rs
--- /dev/null
+++ b/src/tools/clippy/tests/ui/starts_ends_with.rs
@@@ -1,46 -1,0 +1,54 @@@
-     if s.chars().last().unwrap() != 'o' {
+ +// run-rustfix
+ +#![allow(dead_code, unused_must_use)]
+ +
+ +fn main() {}
+ +
+ +#[allow(clippy::unnecessary_operation)]
+ +fn starts_with() {
+ +    "".chars().next() == Some(' ');
+ +    Some(' ') != "".chars().next();
++
++    // Ensure that suggestion is escaped correctly
++    "".chars().next() == Some('\n');
++    Some('\n') != "".chars().next();
+ +}
+ +
+ +fn chars_cmp_with_unwrap() {
+ +    let s = String::from("foo");
+ +    if s.chars().next().unwrap() == 'f' {
+ +        // s.starts_with('f')
+ +        // Nothing here
+ +    }
+ +    if s.chars().next_back().unwrap() == 'o' {
+ +        // s.ends_with('o')
+ +        // Nothing here
+ +    }
+ +    if s.chars().last().unwrap() == 'o' {
+ +        // s.ends_with('o')
+ +        // Nothing here
+ +    }
+ +    if s.chars().next().unwrap() != 'f' {
+ +        // !s.starts_with('f')
+ +        // Nothing here
+ +    }
+ +    if s.chars().next_back().unwrap() != 'o' {
+ +        // !s.ends_with('o')
+ +        // Nothing here
+ +    }
++    if s.chars().last().unwrap() != '\n' {
+ +        // !s.ends_with('o')
+ +        // Nothing here
+ +    }
+ +}
+ +
+ +#[allow(clippy::unnecessary_operation)]
+ +fn ends_with() {
+ +    "".chars().last() == Some(' ');
+ +    Some(' ') != "".chars().last();
+ +    "".chars().next_back() == Some(' ');
+ +    Some(' ') != "".chars().next_back();
++
++    // Ensure that suggestion is escaped correctly
++    "".chars().last() == Some('\n');
++    Some('\n') != "".chars().last();
+ +}
diff --cc src/tools/clippy/tests/ui/starts_ends_with.stderr

index 7c726d0e010263ffca9352d1c41325cb042e9e86,0000000000000000000000000000000000000000..2dd9f53b8026afd215c7fdd3b436fab8e61bad21

mode 100644,000000..100644
--- 1/src/tools/clippy/tests/ui/starts_ends_with.stderr
--- /dev/null
+++ b/src/tools/clippy/tests/ui/starts_ends_with.stderr
@@@ -1,78 -1,0 +1,102 @@@
-   --> $DIR/starts_ends_with.rs:14:8
+ +error: you should use the `starts_with` method
+ +  --> $DIR/starts_ends_with.rs:8:5
+ +   |
+ +LL |     "".chars().next() == Some(' ');
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".starts_with(' ')`
+ +   |
+ +   = note: `-D clippy::chars-next-cmp` implied by `-D warnings`
+ +
+ +error: you should use the `starts_with` method
+ +  --> $DIR/starts_ends_with.rs:9:5
+ +   |
+ +LL |     Some(' ') != "".chars().next();
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".starts_with(' ')`
+ +
+ +error: you should use the `starts_with` method
-   --> $DIR/starts_ends_with.rs:18:8
++  --> $DIR/starts_ends_with.rs:12:5
++   |
++LL |     "".chars().next() == Some('/n');
++   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".starts_with('/n')`
++
++error: you should use the `starts_with` method
++  --> $DIR/starts_ends_with.rs:13:5
++   |
++LL |     Some('/n') != "".chars().next();
++   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".starts_with('/n')`
++
++error: you should use the `starts_with` method
++  --> $DIR/starts_ends_with.rs:18:8
+ +   |
+ +LL |     if s.chars().next().unwrap() == 'f' {
+ +   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.starts_with('f')`
+ +
+ +error: you should use the `ends_with` method
-   --> $DIR/starts_ends_with.rs:22:8
++  --> $DIR/starts_ends_with.rs:22:8
+ +   |
+ +LL |     if s.chars().next_back().unwrap() == 'o' {
+ +   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.ends_with('o')`
+ +   |
+ +   = note: `-D clippy::chars-last-cmp` implied by `-D warnings`
+ +
+ +error: you should use the `ends_with` method
-   --> $DIR/starts_ends_with.rs:26:8
++  --> $DIR/starts_ends_with.rs:26:8
+ +   |
+ +LL |     if s.chars().last().unwrap() == 'o' {
+ +   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.ends_with('o')`
+ +
+ +error: you should use the `starts_with` method
-   --> $DIR/starts_ends_with.rs:30:8
++  --> $DIR/starts_ends_with.rs:30:8
+ +   |
+ +LL |     if s.chars().next().unwrap() != 'f' {
+ +   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.starts_with('f')`
+ +
+ +error: you should use the `ends_with` method
-   --> $DIR/starts_ends_with.rs:34:8
++  --> $DIR/starts_ends_with.rs:34:8
+ +   |
+ +LL |     if s.chars().next_back().unwrap() != 'o' {
+ +   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('o')`
+ +
+ +error: you should use the `ends_with` method
- LL |     if s.chars().last().unwrap() != 'o' {
-    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('o')`
++  --> $DIR/starts_ends_with.rs:38:8
+ +   |
-   --> $DIR/starts_ends_with.rs:42:5
++LL |     if s.chars().last().unwrap() != '/n' {
++   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('/n')`
+ +
+ +error: you should use the `ends_with` method
-   --> $DIR/starts_ends_with.rs:43:5
++  --> $DIR/starts_ends_with.rs:46:5
+ +   |
+ +LL |     "".chars().last() == Some(' ');
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with(' ')`
+ +
+ +error: you should use the `ends_with` method
-   --> $DIR/starts_ends_with.rs:44:5
++  --> $DIR/starts_ends_with.rs:47:5
+ +   |
+ +LL |     Some(' ') != "".chars().last();
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with(' ')`
+ +
+ +error: you should use the `ends_with` method
-   --> $DIR/starts_ends_with.rs:45:5
++  --> $DIR/starts_ends_with.rs:48:5
+ +   |
+ +LL |     "".chars().next_back() == Some(' ');
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with(' ')`
+ +
+ +error: you should use the `ends_with` method
- error: aborting due to 12 previous errors
++  --> $DIR/starts_ends_with.rs:49:5
+ +   |
+ +LL |     Some(' ') != "".chars().next_back();
+ +   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with(' ')`
+ +
++error: you should use the `ends_with` method
++  --> $DIR/starts_ends_with.rs:52:5
++   |
++LL |     "".chars().last() == Some('/n');
++   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with('/n')`
++
++error: you should use the `ends_with` method
++  --> $DIR/starts_ends_with.rs:53:5
++   |
++LL |     Some('/n') != "".chars().last();
++   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with('/n')`
++
++error: aborting due to 16 previous errors
+ +
diff --cc src/tools/clippy/tests/ui/transmute_undefined_repr.rs

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..71539940fbf270e23d043b52d792f2e505c67906

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/transmute_undefined_repr.rs
@@@ -1,0 -1,0 +1,44 @@@
++#![warn(clippy::transmute_undefined_repr)]
++#![allow(clippy::unit_arg)]
++
++fn value<T>() -> T {
++    unimplemented!()
++}
++
++struct Empty;
++struct Ty<T>(T);
++struct Ty2<T, U>(T, U);
++
++#[repr(C)]
++struct Ty2C<T, U>(T, U);
++
++fn main() {
++    unsafe {
++        let _: () = core::mem::transmute(value::<Empty>());
++        let _: Empty = core::mem::transmute(value::<()>());
++
++        let _: Ty<u32> = core::mem::transmute(value::<u32>());
++        let _: Ty<u32> = core::mem::transmute(value::<u32>());
++
++        let _: Ty2C<u32, i32> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
++        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
++
++        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Ok, Ty2 types are the same
++        let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, Ty2 types are the same
++
++        let _: Ty2<u32, f32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
++        let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
++
++        let _: Ty<&()> = core::mem::transmute(value::<&()>());
++        let _: &() = core::mem::transmute(value::<Ty<&()>>());
++
++        let _: &Ty2<u32, f32> = core::mem::transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
++        let _: Ty<&Ty2<u32, i32>> = core::mem::transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
++
++        let _: Ty<usize> = core::mem::transmute(value::<&Ty2<u32, i32>>()); // Ok, pointer to usize conversion
++        let _: &Ty2<u32, i32> = core::mem::transmute(value::<Ty<usize>>()); // Ok, pointer to usize conversion
++
++        let _: Ty<[u8; 8]> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Ok, transmute to byte array
++        let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty<[u8; 8]>>()); // Ok, transmute from byte array
++    }
++}
diff --cc src/tools/clippy/tests/ui/transmute_undefined_repr.stderr

index 0000000000000000000000000000000000000000,0000000000000000000000000000000000000000..040c63c7afa625202d558097aec418e11a13a1b2

new file mode 100644 (file)
--- /dev/null
--- /dev/null
+++ b/src/tools/clippy/tests/ui/transmute_undefined_repr.stderr
@@@ -1,0 -1,0 +1,44 @@@
++error: transmute from `Ty2<u32, i32>` which has an undefined layout
++  --> $DIR/transmute_undefined_repr.rs:23:33
++   |
++LL |         let _: Ty2C<u32, i32> = core::mem::transmute(value::<Ty2<u32, i32>>()); // Lint, Ty2 is unordered
++   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = note: `-D clippy::transmute-undefined-repr` implied by `-D warnings`
++
++error: transmute into `Ty2<u32, i32>` which has an undefined layout
++  --> $DIR/transmute_undefined_repr.rs:24:32
++   |
++LL |         let _: Ty2<u32, i32> = core::mem::transmute(value::<Ty2C<u32, i32>>()); // Lint, Ty2 is unordered
++   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++
++error: transmute from `Ty<Ty2<u32, i32>>` to `Ty2<u32, f32>`, both of which have an undefined layout
++  --> $DIR/transmute_undefined_repr.rs:29:32
++   |
++LL |         let _: Ty2<u32, f32> = core::mem::transmute(value::<Ty<Ty2<u32, i32>>>()); // Lint, different Ty2 instances
++   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = note: two instances of the same generic type (`Ty2`) may have different layouts
++
++error: transmute from `Ty2<u32, f32>` to `Ty<Ty2<u32, i32>>`, both of which have an undefined layout
++  --> $DIR/transmute_undefined_repr.rs:30:36
++   |
++LL |         let _: Ty<Ty2<u32, i32>> = core::mem::transmute(value::<Ty2<u32, f32>>()); // Lint, different Ty2 instances
++   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++   |
++   = note: two instances of the same generic type (`Ty2`) may have different layouts
++
++error: transmute to `&Ty2<u32, f32>` which has an undefined layout
++  --> $DIR/transmute_undefined_repr.rs:35:33
++   |
++LL |         let _: &Ty2<u32, f32> = core::mem::transmute(value::<Ty<&Ty2<u32, i32>>>()); // Lint, different Ty2 instances
++   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++
++error: transmute from `&Ty2<u32, f32>` which has an undefined layout
++  --> $DIR/transmute_undefined_repr.rs:36:37
++   |
++LL |         let _: Ty<&Ty2<u32, i32>> = core::mem::transmute(value::<&Ty2<u32, f32>>()); // Lint, different Ty2 instances
++   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
++
++error: aborting due to 6 previous errors
++
author	flip1995 <philipp.krones@embecosm.com>
	Thu, 10 Feb 2022 17:40:06 +0000 (18:40 +0100)
committer	flip1995 <philipp.krones@embecosm.com>
	Thu, 10 Feb 2022 17:40:06 +0000 (18:40 +0100)
		1	2
src/tools/clippy/CHANGELOG.md	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_dev/src/bless.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/blocks_in_if_conditions.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/default_union_representation.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/disallowed_methods.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/disallowed_types.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/explicit_write.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/formatting.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/implicit_hasher.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/infinite_iter.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_correctness.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_restriction.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/lib.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/loops/single_element_loop.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/loops/utils.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/matches/infalliable_detructuring_match.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_bool.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_single_binding.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/mod.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/single_match.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/matches/wild_in_or_pats.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/chars_cmp_with_unwrap.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/mod.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/option_map_or_none.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/str_splitn.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/misc.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/missing_enforced_import_rename.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/ptr.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/ranges.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/swap.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/mod.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_bool.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_char.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_ref_to_ref.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/transmute_undefined_repr.rs	patch \|	\|	\|	blob
src/tools/clippy/clippy_lints/src/transmute/transmutes_expressible_as_ptr_casts.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/unsound_collection_transmute.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/transmute/useless_transmute.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/types/box_collection.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/types/option_option.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/types/rc_buffer.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/types/rc_mutex.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/types/redundant_allocation.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/unwrap.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/utils/conf.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/utils/internal_lints.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_lints/src/utils/internal_lints/metadata_collector.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_utils/src/consts.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_utils/src/higher.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_utils/src/hir_utils.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_utils/src/lib.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_utils/src/macros.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/clippy_utils/src/ty.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/doc/common_tools_writing_lints.md	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/rust-toolchain	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/compile-test.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/Cargo.toml	patch \|	\|	\|	blob
src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/clippy.toml	patch \|	\|	\|	blob
src/tools/clippy/tests/ui-cargo/multiple_config_files/no_warn/src/main.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/.clippy.toml	patch \|	\|	\|	blob
src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/Cargo.toml	patch \|	\|	\|	blob
src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/clippy.toml	patch \|	\|	\|	blob
src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/src/main.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui-cargo/multiple_config_files/warn/src/main.stderr	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/crashes/ice-4968.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/crashes/ice-8250.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/crashes/ice-8250.stderr	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/crashes/ice-8386.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/default_union_representation.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/default_union_representation.stderr	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/eq_op.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/eq_op.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/expect_fun_call.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/expect_fun_call.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/expect_fun_call.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/explicit_counter_loop.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/explicit_write.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/explicit_write.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/explicit_write.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/get_unwrap.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/get_unwrap.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/get_unwrap.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/manual_assert.edition2018.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/manual_assert.edition2018.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/manual_assert.edition2021.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/manual_assert.edition2021.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/manual_assert.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/manual_flatten.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/manual_flatten.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/ptr_arg.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/single_match.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/single_match.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/single_match_else.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/starts_ends_with.fixed	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/starts_ends_with.rs	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/starts_ends_with.stderr	patch \|	diff1 \|	\|	blob \| history
src/tools/clippy/tests/ui/transmute_undefined_repr.rs	patch \|	\|	\|	blob
src/tools/clippy/tests/ui/transmute_undefined_repr.stderr	patch \|	\|	\|	blob