Implement issue finder for lint names

[flip1995]

Since we're going towards 1000 issues and simply don't have enough manpower to triage them properly and therefore the issue tracker gets kind of convoluted, I thought it would be a good idea to have one tracking issue for all lints. In the tracking issue, for every lint a list of issues mentioning this lint in its title or in the issue body would be displayed.

This is what this tool does. This tool is behind a feature, because it requires reqwest and serde, which would otherwise blow up the clippy_dev build.

Output

GITHUB_TOKEN=*** cargo run --features issues -- issues_for_lint --all --filter "2845,2846"

absurd_extreme_comparisons

• Should absurd_extreme_comparisons alert for comparison between usize and u64? #1802 (Should absurd_extreme_comparisons alert for comparison between usize and u64?)

approx_constant

• Clippy doesn't report error/warnings after cargo check #4612 (Clippy doesn't report error/warnings after cargo check)

assign_op_pattern

• assign_op_pattern misleading on wrongly implemented assign impl. #2268 (assign_op_pattern misleading on wrongly implemented assign impl.)

blacklisted_name

• Lint for denylisted-strings, similar to denylisted-names #1624 (Lint for blacklisted-strings, similar to blacklisted-names)
• Allow blacklisted names in tests #2198 (Allow blacklisted names in tests)
• redundant_pattern_matching fixit suggestion fails to apply #4344 (redundant_pattern_matching fixit suggestion fails to apply)

block_in_if_condition_expr

• Merge some lints together #1078 (Merge some lints together)

block_in_if_condition_stmt

• Merge some lints together #1078 (Merge some lints together)
• block_in_if_condition_stmt: false positive with blocks inside iterator method calls #1141 (block_in_if_condition_stmt: false positive in macros)

bool_comparison

• bool_comparison should not fire when testing for false #1043 (bool_comparison should not fire when testing for false)
• needless_bool triggers on cfg! comparisons #3973 (needless_bool triggers on cfg! comparisons)
• New lint: comparing option to Some(true) #4987 (New lint: comparing option to Some(true))

borrow_interior_mutable_const

• borrow_interior_mutable_const interacts poorly with the http crate #3825 (borrow_interior_mutable_const interacts poorly with the http crate)
• declare_interior_mutable_const and borrow_interior_mutable_const need to respect enum variants #3962 (declare_interior_mutable_const and borrow_interior_mutable_const need to respect enum variants)

borrowed_box

• borrowed_box should not be emitted for mutable boxed trait object #1845 (borrowed_box should not be emitted for mutable boxed trait object)
• The github.io links don't work for non-master releases if the Travis release build failed #2614 (The github.io links don't work for non-master releases if the Travis release build failed)
• borrowed_box incorrectly assumes mutable boxed slice allocation won't change #2907 (borrowed_box incorrectly assumes mutable boxed slice allocation won't change)
• borrowed_box gives syntactically invalid suggestion #3128 (borrowed_box gives syntactically invalid suggestion)
• Clippy incorrectly complains about borrowed_box when trait object is boxed #3971 (Clippy incorrectly complains about borrowed_box when trait object is boxed)

box_vec

• Reword or even allow-by-default box_vec #2404 (Reword or even allow-by-default box_vec)

boxed_local

• False positive for boxed local with wasm_bindgen #4351 (False positive for boxed local with wasm_bindgen)
• FN in boxed_local lint #4642 (FN in boxed_local lint)
• boxed_local false positive for ?Sized #4740 (boxed_local false positive for ?Sized)
• False positive for boxed local in default Trait method implementation #4804 (False positive for boxed local in default Trait method implementation)

cargo_common_metadata

• Meta issue for Rust API Guidelines #1798 (Meta issue for Rust API Guidelines)

cast_lossless

• On 32-bit, usize as f64 recommends f64::from(usize) #3689 (On 32-bit, usize as f64 recommends f64::from(usize))
• Re-enable cast_lossless lint by default #4864 (Re-enable cast_lossless lint by default)

cast_possible_truncation

• Optionally disable allows unless linked to a justification #3695 (Optionally disable allows unless linked to a justification)

cast_ptr_alignment

• cast_ptr_alignment is acceptable in a narrow set of contexts #2881 (cast_ptr_alignment is acceptable in a narrow set of contexts)
• Cast_ptr_alignment false negative in trait method default impl #3440 (Cast_ptr_alignment false negative in trait method default impl)
• Extend cast_ptr_alignment lint for pointer::cast method #4708 (Extend cast_ptr_alignment lint for pointer::cast method)
• Extend cast_ptr_alignment for type alias #4754 (Extend cast_ptr_alignment for type alias)

cast_sign_loss

• cast_sign_loss: value can't be negative if guarded by assert: #3089 (cast_sign_loss: value can't be negative if guarded by assert:)

clone_on_copy

• Disable expl_impl_clone_on_copy when Copy is manually implemented. #1254 (Disable expl_impl_clone_on_copy when Copy is manually implemented.)
• False positive for clone_on_copy when the clone is immediately borrowed #1472 (False positive for clone_on_copy when the clone is immediately borrowed)
• Why prefer dereference to clone on Copy types? #2870 (Why prefer dereference to clone on Copy types?)
• Make clone_on_copy lint machine applicable #4826 (Make clone_on_copy lint machine applicable)

clone_on_ref_ptr

• clone_on_ref_ptr and macros #2076 (clone_on_ref_ptr and macros)

cmp_owned

• cmp_owned false positives - proc_macro Ident #4874 (cmp_owned false positives - proc_macro Ident)
• False positive in cmp_owned lint #4909 (False positive in cmp_owned lint)

cognitive_complexity

• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• Suggestion for new lint: Cognitive Complexity #3793 (Suggestion for new lint: Cognitive Complexity)
• Ignore cognitive complexity in macro expanded code #3900 (Ignore cognitive complexity in macro expanded code)
• Clippy links to master instead of actual version #4167 (Clippy links to master instead of actual version)
• Improve the cognitive_complexity lint to show what lines are causing the complexity #4470 (Improve the cognitive_complexity lint to show what lines are causing the complexity)

collapsible_if

• improve collapsible if in complex cases with same expressions #812 (improve collapsible if in complex cases with same expressions)
• False positive on collapsible_if with if let #1197 (False positive on collapsible_if with if let)
• collapsible_if shouldn't warn on else after multiple else if #1401 (collapsible_if shouldn't warn on else after multiple else if)
• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• Incorrect indentation in suggestion of collapsible_if #2974 (Incorrect indentation in suggestion of collapsible_if)

comparison_chain

• detect if comparison chain that could be a tuple comparison instead #1111 (detect if comparison chain that could be a tuple comparison instead)
• should comparison_chain only trigger for "if x > y {} else if x <y {} else {}" ? #4725 (should comparison_chain only trigger for "if x > y {} else if x <y {} else {}" ?)

debug_assert_with_mut_call

• debug_assert_with_mut_call: false positive on immutable method call #4737 (debug_assert_with_mut_call: false positive on immutable method call)

declare_interior_mutable_const

• declare_interior_mutable_const and borrow_interior_mutable_const need to respect enum variants #3962 (declare_interior_mutable_const and borrow_interior_mutable_const need to respect enum variants)

deprecated_cfg_attr

• deprecated_cfg_attr lint: Also lint inner attributes once custom_inner_attributes is stabilized #3660 (deprecated_cfg_attr lint: Also lint inner attributes once custom_inner_attributes is stabilized)

derive_hash_xor_eq

• False positive in derive_hash_xor_eq with multiple Eq implementations #2025 (False positive in derive_hash_xor_eq with multiple Eq implementations)

doc_markdown

• doc_markdown a bit too eager #902 (doc_markdown a bit too eager)
• doc_markdown should ignore things which just contain acronyms #1136 (doc_markdown should ignore things which just contain acronyms)
• off-by-one span in doc_markdown warning on single tick #2481 (off-by-one span in doc_markdown warning on single tick)
• (false positive) doc_markdown should disregard escaped underscores #2581 ((false positive) doc_markdown should disregard escaped underscores)

double_comparisons

• lint double comparisons #753 (lint double comparisons)

double_neg

• nonminimal_bool lint for meta items #1893 (nonminimal_bool lint for meta items)

drop_copy

• FP clippy::drop_copy ?: new() called inside drop() #3939 (FP clippy::drop_copy ?: new() called inside drop())

drop_ref

• clippy::drop_ref will trigger on &mut T as well as &T #4461 (clippy::drop_ref will trigger on &mut T as well as &T)

else_if_without_else

• Lint suggestions based on MISRA 2004 #2227 (Lint suggestions based on MISRA 2004)

empty_enum

• Improve empty_enum lint #4905 (Improve empty_enum lint)

empty_loop

• Lint: empty_loop lint on no_std #3746 (Lint: empty_loop lint on no_std)

enum_clike_unportable_variant

• False positive on enum_clike_unportable_variant #816 (False positive on enum_clike_unportable_variant)
• False positive for C-like enums involving configuration-dependent constants #1134 (False positive for C-like enums involving configuration-dependent constants)
• vet all lints for 16 bit compat #1149 (vet all lints for 16 bit compat)

enum_glob_use

• add lint for prevent global import #1228 (add lint for prevent global import)

enum_variant_names

• Incomplete postfix detected for enum_variant_names #4639 (Incomplete postfix detected for enum_variant_names)

eq_op

• Use const_eval instead of constant for more lints? #461 (Use const_eval instead of constant for more lints?)
• eq_op false positive with floats #1466 (eq_op false positive)
• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)

erasing_op

• lint useless operands in binary operations #2086 (lint useless operands in binary operations)

eval_order_dependence

• eval_order_dependence shouldn't fire for struct initializers #4637 (eval_order_dependence shouldn't fire for struct initializers)

exit

• Stronger macro check for identity-op and type-complexity #301 (Stronger macro check for identity-op and type-complexity)
• Warn when forgetting to flush stdout before calling std::process::exit. #713 (Warn when forgetting to flush stdout before calling std::process::exit.)
• Create more than 2 lint groups #743 (Create more than 2 lint groups)
• lint on a call to exit in tests #966 (lint on a call to exit in tests)
• Type complexity should not be considered when defining an associated type #1013 (Type complexity should not be considered when defining an associated type)
• Feature request: flag for non-zero exit status if warnings are present #1209 (Feature request: flag for non-zero exit status if warnings are present)
• Clean up the error reporting in the cargo clippy code #1329 (Clean up the error reporting in the cargo clippy code)
• clippy subcommand does not work properly when root directory is an executable #1330 (clippy subcommand does not work properly when root directory is an executable)
• Lint generic methods using Into/AsRef/AsMut above very modest complexity #1375 ( Lint generic methods using Into/AsRef/AsMut above very modest complexity)
• 0.0.105 doesn't work at all on windows 10/msvc target/rust 1.16.0-nightly 2017-01-03 #1422 (0.0.105 doesn't work at all on windows 10/msvc target/rust 1.16.0-nightly 2017-01-03)
• New Lint: Avoid too many static code paths #1681 (New Lint: Avoid too many static code paths)
• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• Lint against impl in block expressions when could be outside of block expression #2124 (Lint against impl in block expressions when could be outside of block expression)
• Lint suggestions based on MISRA 2004 #2227 (Lint suggestions based on MISRA 2004)
• Cyclomatic Complexity should not count code in debug_assert #2249 (Cyclomatic Complexity should not count code in debug_assert)
• Panic in nightly-msvc (cddc4a62d 2017-12-26), "thread 'rustc' panicked at 'failed to create span for type arguments'," #2306 (Panic in nightly-msvc (cddc4a6 2017-12-26), "thread 'rustc' panicked at 'failed to create span for type arguments',")
• error: multiple input filenames provided with clippy 0.0.191 and last nightly #2602 (error: multiple input filenames provided with clippy 0.0.191 and last nightly)
• Doesn't work with custom rustc path #2765 (Doesn't work with custom rustc path)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)
• Suggestion for new lint: Cognitive Complexity #3793 (Suggestion for new lint: Cognitive Complexity)
• Ignore cognitive complexity in macro expanded code #3900 (Ignore cognitive complexity in macro expanded code)
• FP clippy::drop_copy ?: new() called inside drop() #3939 (FP clippy::drop_copy ?: new() called inside drop())
• Clippy links to master instead of actual version #4167 (Clippy links to master instead of actual version)
• Make find_map lint be more conservative #4193 (Make find_map lint be more conservative)
• Improve the cognitive_complexity lint to show what lines are causing the complexity #4470 (Improve the cognitive_complexity lint to show what lines are causing the complexity)
• Clippy leaves cargo running in the background on SIGTERM  #4505 (Clippy leaves cargo running in the background on SIGTERM )
• New lint: API complexity #4524 (New lint: API complexity)
• New lint: Unnecessarily complex types #4844 (New lint: Unnecessarily complex types)
• New Lint: Explicit ranges with p0 | ... | p_n => range pat #4931 (New Lint: Explicit ranges with p0 | ... | p_n => range pat)

expect_fun_call

• expect_fun_call recommends code which is not equivalent #2928 (expect_fun_call recommends code which is not equivalent)

expl_impl_clone_on_copy

• Disable expl_impl_clone_on_copy when Copy is manually implemented. #1254 (Disable expl_impl_clone_on_copy when Copy is manually implemented.)

explicit_counter_loop

• explicit_counter_loop improvement suggestion #1670 (explicit_counter_loop improvement suggestion)
• explicit_counter_loop produces incorrect advice #4677 (explicit_counter_loop produces incorrect advice)

explicit_into_iter_loop

• Lint suggestions around vector iterations are counterproductive #3063 (Lint suggestions around vector iterations are counterproductive)
• Tracking issue for RFC 2476, Clippy 1.0 #3343 (Tracking issue for RFC 2476, Clippy 1.0)

explicit_iter_loop

• explicit_iter_loop should warn &[T].iter() #1518 (explicit_iter_loop should warn &[T].iter())
• Lint suggestions around vector iterations are counterproductive #3063 (Lint suggestions around vector iterations are counterproductive)
• Tracking issue for RFC 2476, Clippy 1.0 #3343 (Tracking issue for RFC 2476, Clippy 1.0)

explicit_write

• Revive suggestion on explicit_write #4542 (Revive suggestion on explicit_write)

extend_from_slice

• New lint: vec.extend(&vec![elem; len]) is slow, vec.resize() should be used instead #4660 (New lint: vec.extend(&vec![elem; len]) is slow, vec.resize() should be used instead)

filter_map

• lint flat_map into filter_map #2241 (lint flat_map into filter_map)
• Make the filter_map lint more specific #3188 (Make the filter_map lint more specific)
• lint vec.clone().into_iter().stuff().collect() to suggest vec.iter().stuff().cloned().collect() #3302 (lint vec.clone().into_iter().stuff().collect() to suggest vec.iter().stuff().cloned().collect())
• filter_map docs woefully incomplete #3424 (filter_map docs woefully incomplete)
• add a lint for find_map #3474 (add a lint for find_map)
• Add utils helper for filtering out type/lifetime parameters on generics #3787 (Add utils helper for filtering out type/lifetime parameters on generics)
• Make find_map lint be more conservative #4193 (Make find_map lint be more conservative)
• False positive for unnecessary_filter_map #4433 (False positive for unnecessary_filter_map)
• New lint: map to Option followed by flatten #4496 (New lint: map to Option followed by flatten)

filter_next

• add a lint for find_map #3474 (add a lint for find_map)
• Improvement Idea: the ilter_next should also cover skip_while().next() #4036 (Improvement Idea: the ilter_next should also cover skip_while().next())

find_map

• add a lint for find_map #3474 (add a lint for find_map)
• Make find_map lint be more conservative #4193 (Make find_map lint be more conservative)

float_arithmetic

• lint long chains of into/float additions/multiplications #1243 (lint long chains of into/float additions/multiplications)

float_cmp

• Findings from running Clippy on Servo #164 (Findings from running Clippy on Servo)
• Use const_eval instead of constant for more lints? #461 (Use const_eval instead of constant for more lints?)
• Additions to float_cmp check #1683 (Additions to float_cmp check)
• Expand float_cmp to structs with PartialEq #1685 (Expand float_cmp to structs with PartialEq)
• float_cmp false positive: catching underflow #2834 (float_cmp false positive: catching underflow)
• Allow float comparison with zero #3804 (Allow float comparison with zero)
• Should //run-rustfix tests apply HasPlaceholders suggestions? #4557 (Should //run-rustfix tests apply HasPlaceholders suggestions?)

float_cmp_const

• Should //run-rustfix tests apply HasPlaceholders suggestions? #4557 (Should //run-rustfix tests apply HasPlaceholders suggestions?)

fn_to_numeric_cast

• fn_to_numeric_cast incorrect suggestion #3896 (fn_to_numeric_cast incorrect suggestion)

fn_to_numeric_cast_with_truncation

• fn_to_numeric_cast incorrect suggestion #3896 (fn_to_numeric_cast incorrect suggestion)

for_loop_over_option

• Merge some lints together #1078 (Merge some lints together)

for_loop_over_result

• Merge some lints together #1078 (Merge some lints together)

forget_ref

• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)

get_unwrap

• False positive?: get_unwrap #1725 (False positive?: get_unwrap)

identity_conversion

• lint identity_conversion name is misleading #3106 (lint identity_conversion name is misleading)
• [cargo fix] identity_conversion removes parenthesis with inner expression, that needs them. #4750 ([cargo fix] identity_conversion removes parenthesis with inner expression, that needs them.)

identity_op

• Stronger macro check for identity-op and type-complexity #301 (Stronger macro check for identity-op and type-complexity)
• Use const_eval instead of constant for more lints? #461 (Use const_eval instead of constant for more lints?)
• Merge some lints together #1078 (Merge some lints together)
• identity_op warns for bitflag constant #3430 (identity_op warns for bitflag constant)
• Consider excluding Duration's associated constants from identity_op lint #3866 (Consider excluding Duration's associated constants from identity_op lint)

if_let_redundant_pattern_matching

• Do not suggest replacing simple if let Some(_) / None with methods #2353 (Do not suggest replacing simple if let Some(_) / None with methods)

if_let_some_result

• Add suggestion to if_let_some_result lint #4991 (Add suggestion to if_let_some_result lint)

if_same_then_else

• detect if comparison chain that could be a tuple comparison instead #1111 (detect if comparison chain that could be a tuple comparison instead)
• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• FN implicit if_same_then_else #3030 (FN implicit if_same_then_else)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)
• if_same_then_else Should not warn for else if blocks. #3770 (if_same_then_else Should not warn for else if blocks.)

implicit_hasher

• clippy::implicit_hasher shouldn't warn on From<Thing> for HashMap<K, V> #3899 (clippy::implicit_hasher shouldn't warn on From for HashMap<K, V>)

implicit_return

• crash ./ui/trivial-bounds/trivial-bounds-inconsistent.rs #3969 (crash ./ui/trivial-bounds/trivial-bounds-inconsistent.rs)

indexing_slicing

• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• Improve indexing_slicing help message #2866 (Improve indexing_slicing help message)

inherent_to_string

• False positive for inherent_to_string_shadow_display? #4396 (False positive for inherent_to_string_shadow_display?)

inherent_to_string_shadow_display

• False positive for inherent_to_string_shadow_display? #4396 (False positive for inherent_to_string_shadow_display?)

inline_always

• Warn if 'nonstandard Clone' used in vec! #4288 (Warn if 'nonstandard Clone' used in vec!)

integer_arithmetic

• integer_arithmetic gives unhelpful warnings for const expressions #1761 (integer_arithmetic gives unhelpful warnings for const expressions)

integer_division

• Lint std::panic::catch_unwind #1196 (Lint std::panic::catch_unwind)
• useless op on lhs of integer division or modulo #1324 (useless op on lhs of integer division or modulo)

into_iter_on_array

• Calling into_iter on an oversized array only triggers into_iter_on_ref #4492 (Calling into_iter on an oversized array only triggers into_iter_on_ref)

into_iter_on_ref

• Calling into_iter on an oversized array only triggers into_iter_on_ref #4492 (Calling into_iter on an oversized array only triggers into_iter_on_ref)

invalid_atomic_ordering

• Extend invalid_atomic_ordering lint to memory fence calls #5026 (Extend invalid_atomic_ordering lint to memory fence calls)

invalid_regex

• Unrecognized escape sequence #4170 (Unrecognized escape sequence)

invalid_upcast_comparisons

• invalid_upcast_comparisons gives false positive on u8 to i8 wrapping cast #886 (invalid_upcast_comparisons gives false positive on u8 to i8 wrapping cast)

items_after_statements

• also lint on items after statements in macros #578 (also lint on items after statements in macros)

large_enum_variant

• large_enum_variant triggered in error-chain macro has unhelpful help message #2121 (large_enum_variant triggered in error-chain macro has unhelpful help message)
• New lint: large Err(E) variant, as compared with Ok(T), for Result<T, E> #3884 (New lint: large Err(E) variant, as compared with Ok(T), for Result<T, E>)

len_without_is_empty

• len_without_is_empty lints if len and is_empty are in different impl blocks #1562 (len_without_is_empty lints if len and is_empty are in different impl blocks)

len_zero

• (Preliminary) Results of building rust with clippy #278 ((Preliminary) Results of building rust with clippy)
• len_zero with Range suggests code cannot compile #3807 (len_zero with Range suggests code cannot compile)

let_and_return

• Restrict let_and_return if the let binding is large #420 (Restrict let_and_return if the let binding is large)
• Potential false positive for let_and_return #1322 (Potential false positive for let_and_return)
• let_and_return mistake #1524 (let_and_return mistake)
• let_and_return : false positive #1642 (let_and_return : false positive)
• let_and_return false positive #1669 (let_and_return false positive)
• Possible false positive with let_and_return #3324 (Possible false positive with let_and_return)
• let_and_return false positive #3792 (let_and_return false positive)
• let_and_return "known problems" #4182 (let_and_return "known problems")

let_underscore_must_use

• let-underscore-must-use is triggered when Debug is derived #4980 (let-underscore-must-use is triggered when Debug is derived)

let_unit_value

• Findings from running Clippy on Servo #164 (Findings from running Clippy on Servo)
• Let_unit_value false positive when return type is type parameter #1502 (Let_unit_value false positive when return type is type parameter)

linkedlist

• linkedlist false positive #1800 (linkedlist false positive)

logic_bug

• Rename logic_bug #1916 (Rename logic_bug)

manual_mul_add

• manual_mul_add suggests broken code #4726 (manual_mul_add suggests broken code)
• mul_add struggling with long expressions #4735 (mul_add struggling with long expressions)

many_single_char_names

• many_single_char_names incorrectly triggered if 'single-char-binding-names-threshold = 0' #4086 (many_single_char_names incorrectly triggered if 'single-char-binding-names-threshold = 0')

map_entry

• map_entry false positive when returning before inserting #4664 (map_entry false positive when returning before inserting)
• map_entry false positive when map needs to be used while still borrowed by the entry #4674 (map_entry false positive when map needs to be used while still borrowed by the entry)

match_bool

• Perhaps this match_bool case could be considered idiomatic? #3713 (Perhaps this match_bool case could be considered idiomatic?)

match_ref_pats

• Bikesheds to be done when RfCing clippy #533 (Bikesheds to be done when RfCing clippy)
• Possible suggestion improvements on match_ref_pats #849 (Possible suggestion improvements on match_ref_pats)
• bad match_ref_pats suggestion. #4834 (bad match_ref_pats suggestion.)

match_same_arms

• False positive on match_same_arms #860 (False positive on match_same_arms)
• match_same_arms: suppress when reordering arms? #1140 (match_same_arms: suppress when reordering arms?)
• Another false positive: match_same_arms vs. &Any #1218 (Another false positive: match_same_arms vs. &Any)
• False positive with match_on_same_arms and macros #1390 (False positive with match_on_same_arms and macros)
• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• False positive with match_same_arms #2185 (False positive with match_same_arms)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)

match_wild_err_arm

• match_wild_err_arm: Err(_) is not wild #3688 (match_wild_err_arm: Err(_) is not wild)
• match_wild_err_arm triggers weirdly #5024 (match_wild_err_arm triggers weirdly)

min_max

• Use const_eval instead of constant for more lints? #461 (Use const_eval instead of constant for more lints?)

missing_const_for_fn

• Wrong suggestion of const fn if member of member implements Drop #4979 (Wrong suggestion of const fn if member of member implements Drop)

missing_docs_in_private_items

• missing_docs_in_private_items does not honor allow statements #1895 (missing_docs_in_private_items does not honor allow statements)

missing_inline_in_public_items

• missing_inline_in_public_items and #[wasm_bindgen(start)] #3934 (missing_inline_in_public_items and #[wasm_bindgen(start)])

mistyped_literal_suffixes

• BUG: Incorrect mistyped literal suffix on long floats. #4706 (BUG: Incorrect mistyped literal suffix on long floats.)

module_name_repetitions

• Warn if 'nonstandard Clone' used in vec! #4288 (Warn if 'nonstandard Clone' used in vec!)

modulo_one

• Merge some lints together #1078 (Merge some lints together)

multiple_inherent_impl

• Lint: Multiple inherent impls #414 (Lint: Multiple inherent impls)

must_use_candidate

• -A --allow should take precedence over -D --deny in CLI #4778 (-A --allow should take precedence over -D --deny in CLI)
• must_use_candidate is going mad (false positives?) #4779 (must_use_candidate is going mad (false positives?))

mut_from_ref

• Should the mut_from_ref lint apply to unsafe functions? #4281 (Should the mut_from_ref lint apply to unsafe functions?)

mut_mut

• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)

mutable_key_type

• False Positive? Mutable key type lint is emitted on HashSets containing associated types #5020 (False Positive? Mutable key type lint is emitted on HashSets containing associated types)

mutex_atomic

• mutex_atomic and CondVar #1516 (mutex_atomic and CondVar)
• Consider removing mutex_atomic #4295 (Consider removing mutex_atomic)

needless_bool

• needless_bool triggers on cfg! comparisons #3973 (needless_bool triggers on cfg! comparisons)

needless_borrow

• needless borrow does not trigger on block trailing expression #1726 (needless borrow does not trigger on block trailing expression)
• needless_borrow suggests bad code when reference-to-reference is required #2610 (needless_borrow suggests bad code when reference-to-reference is required)
• needless_borrow complains when a type alias with reference is used #2908 (needless_borrow complains when a type alias with reference is used)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)
• needless_borrow was temporarily moved to nursery in April 2018 #3742 (needless_borrow was temporarily moved to nursery in April 2018)

needless_continue

• Appveyor build is broken #2336 (Appveyor build is broken)
• Needless continue for match block #4077 (Needless continue for match block)

needless_doctest_main

• needless_doctest_main yields false positive with proc macros #4698 (needless_doctest_main yields false positive with proc macros)
• needless_doctest_main vs. question mark operator #4906 (needless_doctest_main vs. question mark operator)

needless_lifetimes

• Incorrect needless_lifetimes warning for impl Trait based code #2944 (Incorrect needless_lifetimes warning for impl Trait based code)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)
• False positive for needless_lifetimes (possibly due to async?) #4746 (False positive for needless_lifetimes (possibly due to async?))
• Give "corrected" code in examples #4829 (Give "corrected" code in examples)

needless_pass_by_value

• needless_pass_by_value and closures #2434 (needless_pass_by_value and closures)
• Is needless_pass_by_value behaving properly? #3031 (Is needless_pass_by_value behaving properly?)
• Unsized rvalues now making this lint inaccurate #3420 (Unsized rvalues now making this lint inaccurate)

needless_range_loop

• Weird warning for needless_range_loop #398 (Weird warning for needless_range_loop)
• Wrong hint about needless_range_loop #878 (Wrong hint about needless_range_loop)
• needless_range_loop suggests using iter on a value that do not have iter method #1014 (needless_range_loop suggests using iter on a value that do not have iter method)
• needless_range_loop could suggest using clone_from_slice in some cases #1831 (needless_range_loop could suggest using clone_from_slice in some cases)
• Improve suggestions for needless_range_loop #1864 (Improve suggestions for needless_range_loop)
• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• A problem with needless_range_loop #2072 (A problem with needless_range_loop)
• False Positive: needless_range_loop #2277 (False Positive: needless_range_loop)
• Structs with non-matching Index and Iter impls cause bad suggestions #2847 (Structs with non-matching Index and Iter impls cause bad suggestions)
• needless_range_loop disregards multiple indexed variables #3032 (needless_range_loop disregards multiple indexed variables)

needless_return

• Wrong needless_return suggestion with blocks #2472 (Wrong needless_return suggestion with blocks)
• cargo clippy --all-targets issues diagnostics for library crate twice #4092 (cargo clippy --all-targets issues diagnostics for library crate twice)

neg_multiply

• FN neg_multiply: x *= -1 ? #3037 (FN neg_multiply: x *= -1 ?)

new_ret_no_self

• False positive in new_ret_no_self if self type carries lifetime annotation? #734 (False positive in new_ret_no_self if self type carries lifetime annotation?)

new_without_default

• Merge some lints together #1078 (Merge some lints together)
• new-without-default-derive ignores existing derives #1410 (new-without-default-derive ignores existing derives)
• The useless attribute lint doesn't put the ! in the right place. #1522 (The useless attribute lint doesn't put the ! in the right place.)
• new_without_default_derive help is confusing #1579 (new_without_default_derive help is confusing)
• Meta issue for Rust API Guidelines #1798 (Meta issue for Rust API Guidelines)
• Why new_without_default is shown for structs with private fields? #1878 (Why new_without_default is shown for structs with private fields?)
• new_without_default_derive triggers on types which cannot #[derive(Default)] #1890 (new_without_default_derive triggers on types which cannot #[derive(Default)])
• When derive is already applied to struct, suggest extending it, not replacing it #3053 (When derive is already applied to struct, suggest extending it, not replacing it)
• clippy::new_without_default_derive triggers and shouldn't #3697 (clippy::new_without_default_derive triggers and shouldn't)

no_effect

• Lint suggestions based on MISRA 2004 #2227 (Lint suggestions based on MISRA 2004)
• no_effect lint should also lint calls to const_fn where the result is unused #2722 (no_effect lint should also lint calls to const_fn where the result is unused)

non_ascii_literal

• -A should override -W when it appears later on the command line #4091 (-A should override -W when it appears later on the command line)

nonminimal_bool

• Lint !any(==) and similar #1334 (Lint !any(==) and similar)
• nonminimal_bool lint for meta items #1893 (nonminimal_bool lint for meta items)
• nonminimal_bool can produce minimal but not human readable expressions #3141 (nonminimal_bool can produce minimal but not human readable expressions)

not_unsafe_ptr_arg_deref

• not_unsafe_ptr_arg_deref false positives #3045 (not_unsafe_ptr_arg_deref false positives)

op_ref

• op_ref false positive #2042 (op_ref false positive)
• op_ref false positive with deref coercions when comparing #2597 (op_ref false positive with deref coercions when comparing)
• clippy::drop_ref will trigger on &mut T as well as &T #4461 (clippy::drop_ref will trigger on &mut T as well as &T)

option_and_then_some

• Add result_and_then_ok lint #4412 (Add result_and_then_ok lint)

option_map_unit_fn

• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)

option_map_unwrap_or

• Merge some lints together #1078 (Merge some lints together)
• Why does Clippy not suggest removing an Option::map call with an "identity" #3236 (Why does Clippy not suggest removing an Option::map call with an "identity")

option_map_unwrap_or_else

• Merge some lints together #1078 (Merge some lints together)
• Why does Clippy not suggest removing an Option::map call with an "identity" #3236 (Why does Clippy not suggest removing an Option::map call with an "identity")

option_option

• #[allow(clippy::option_option)] not working when paired with #[serde(deserialize_with)] #4298 (#[allow(clippy::option_option)] not working when paired with #[serde(deserialize_with)])

option_unwrap_used

• Disable result_unwrap_used / option_unwrap_used in tests #1015 (Disable result_unwrap_used / option_unwrap_used in tests)
• Merge some lints together #1078 (Merge some lints together)

or_fun_call

• False positive for or_fun_call #1609 (False positive for or_fun_call)
• or_fun_call bad output with vec![] #1667 (or_fun_call bad output with vec![])
• Suggested code does not compile with or_fun_call #2186 (Suggested code does not compile with or_fun_call)
• Truncated message #2379 (Truncated message)

out_of_bounds_indexing

• out_of_bounds_indexing false positive #1668 (out_of_bounds_indexing false positive)
• empty_array.rs test removed because it ICEs on CI #4607 (empty_array.rs test removed because it ICEs on CI)

overflow_check_conditional

• false positive: a - b > b is not really an underflow check #2457 (false positive: a - b > b is not really an underflow check)

panic

• foo.unwrap_or(panic!(…)) #19 (foo.unwrap_or(panic!(…)))
• (Preliminary) Results of building rust with clippy #278 ((Preliminary) Results of building rust with clippy)
• Rust-dogme #632 (Rust-dogme)
• Suggest named parameters for complex/long format! calls #633 (Suggest named parameters for complex/long format! calls)
• lint panics (allow) #668 (lint panics (allow))
• Possible suggestion improvements on match_ref_pats #849 (Possible suggestion improvements on match_ref_pats)
• Will not run and panicks on multiple [[bin]] sections in Cargo.toml without --bin flag #932 (Will not run and panicks on multiple [[bin]] sections in Cargo.toml without --bin flag)
• "this could sometimes panic" lint #959 ("this could sometimes panic" lint)
• Lint for Unnecessary Map #1005 (Lint for Unnecessary Map)
• Documentation/Markdown Lints #1007 (Documentation/Markdown Lints)
• Lint std::panic::catch_unwind #1196 (Lint std::panic::catch_unwind)
• Clean up the error reporting in the cargo clippy code #1329 (Clean up the error reporting in the cargo clippy code)
• Figure out which Common Weakness Enumerations Rust or Clippy eliminates or mitgates #1456 (Figure out which Common Weakness Enumerations Rust or Clippy eliminates or mitgates)
• Panic when compiling redis-rs with clippy #1517 (Panic when compiling redis-rs with clippy)
• Lint unwrap in drop impls #1523 (Lint unwrap in drop impls)
• don't panic... #1630 (don't panic...)
• needless borrow does not trigger on block trailing expression #1726 (needless borrow does not trigger on block trailing expression)
• Rust API Guideline: Function docs include error conditions in "Errors" section #1790 (Rust API Guideline: Function docs include error conditions in "Errors" section)
• Rust API Guideline: Function docs include panic conditions in "Panics" section #1791 (Rust API Guideline: Function docs include panic conditions in "Panics" section)
• Meta issue for Rust API Guidelines #1798 (Meta issue for Rust API Guidelines)
• Optional lint for functions that panic without mentioning panics in rustdoc #1974 (Optional lint for functions that panic without mentioning panics in rustdoc)
• Lint usages of tcx.hir.body without accompaning tcx.body_tables #1976 (Lint usages of tcx.hir.body without accompaning tcx.body_tables)
• Attempting to run clippy on a single file causes it to crash #2001 (Attempting to run clippy on a single file causes it to crash)
• Clippy fails as subcommand on Windows when rustc installed via installer #2142 (Clippy fails as subcommand on Windows when rustc installed via installer)
• Add a lint for panic! being used #2297 (Add a lint for panic! being used)
• Panic in nightly-msvc (cddc4a62d 2017-12-26), "thread 'rustc' panicked at 'failed to create span for type arguments'," #2306 (Panic in nightly-msvc (cddc4a6 2017-12-26), "thread 'rustc' panicked at 'failed to create span for type arguments',")
• clippy fails on missing eh_personality although panic-strategy is defined in custom target #2621 (clippy fails on missing eh_personality although panic-strategy is defined in custom target)
• Improve indexing_slicing help message #2866 (Improve indexing_slicing help message)
• expect_fun_call recommends code which is not equivalent #2928 (expect_fun_call recommends code which is not equivalent)
• Any pitfalls #2988 (Any pitfalls)
• Lint calls to #[no_mangle] functions that don't have #[inline(never)] #3070 (Lint calls to #[no_mangle] functions that don't have #[inline(never)])
• lint assert!(true / false) #3575 (lint assert!(true / false))
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)
• Perhaps this match_bool case could be considered idiomatic? #3713 (Perhaps this match_bool case could be considered idiomatic?)
• Lint: empty_loop lint on no_std #3746 (Lint: empty_loop lint on no_std)
• crash ./ui/trivial-bounds/trivial-bounds-inconsistent.rs #3969 (crash ./ui/trivial-bounds/trivial-bounds-inconsistent.rs)
• Should the mut_from_ref lint apply to unsafe functions? #4281 (Should the mut_from_ref lint apply to unsafe functions?)
• New lint: dangerous use of vec.set_len() #4483 (New lint: dangerous use of vec.set_len())
• unit_cmp: special handling of assert_eq!(Option.unwrap(), ()); #4661 (unit_cmp: special handling of assert_eq!(Option.unwrap(), ());)
• RLS crashes on clippyusing rustc 1.39.0-nightly (eb48d6bde 2019-09-12) #4681 (RLS crashes on clippyusing rustc 1.39.0-nightly (eb48d6b 2019-09-12))
• Lint leaky Drop impls that do nothing but drop items in a loop #4899 (Lint leaky Drop impls that do nothing but drop items in a loop)
• Should pick up panic!(format!( #5013 (Should pick up panic!(format!()
• match_wild_err_arm triggers weirdly #5024 (match_wild_err_arm triggers weirdly)
• Extend invalid_atomic_ordering lint to memory fence calls #5026 (Extend invalid_atomic_ordering lint to memory fence calls)

partialeq_ne_impl

• partialeq_ne_impl lint documentation incorrect #2893 (partialeq_ne_impl lint documentation incorrect)

possible_missing_comma

• False positive in possible_missing_comma #4399 (False positive in possible_missing_comma)

precedence

• Lint suggestions based on MISRA 2004 #2227 (Lint suggestions based on MISRA 2004)
• "possibly missing a comma here" conflicts with rustfmt #3396 ("possibly missing a comma here" conflicts with rustfmt)
• Lint negation "followed" by method call #3903 (Lint negation "followed" by method call)
• -A --allow should take precedence over -D --deny in CLI #4778 (-A --allow should take precedence over -D --deny in CLI)
• precedence should not warn for unary minus before odd function #4892 (precedence should not warn for unary minus before odd function)

print_literal

• False literal with empty format string warning when printing two macros #2768 (False literal with empty format string warning when printing two macros)
• cargo clippy does not process build scripts #2802 (cargo clippy does not process build scripts)

print_with_newline

• Print with newline edge cases #2295 (Print with newline edge cases)

ptr_arg

• Create more than 2 lint groups #743 (Create more than 2 lint groups)
• Consequences of ptr_arg #846 (Consequences of ptr_arg)
• Rust API Guideline: Functions minimize assumptions about parameters by using generics #1794 (Rust API Guideline: Functions minimize assumptions about parameters by using generics)
• Typedefs and ptr_arg lint #1981 (Typedefs and ptr_arg lint)
• not_unsafe_ptr_arg_deref false positives #3045 (not_unsafe_ptr_arg_deref false positives)
• ptr_arg: clarify about original type when newtype is just a Vec<_> #3381 (ptr_arg: clarify about original type when newtype is just a Vec<_>)
• Option to disable trivially_copy_pass_by_ref in public functions #4504 (Option to disable trivially_copy_pass_by_ref in public functions)

question_mark

• Meta issue for Rust API Guidelines #1798 (Meta issue for Rust API Guidelines)
• needless_doctest_main vs. question mark operator #4906 (needless_doctest_main vs. question mark operator)

range_plus_one

• Do not suggest to use the closed interval syntax #2217 (Do not suggest to use the closed interval syntax)
• range_plus_one help suggestion should not remove braces #3103 (range_plus_one help suggestion should not remove braces)
• range_plus_one lint wrongly suggests using RangeInclusive when Range is required and the other way around #3307 (range_plus_one lint wrongly suggests using RangeInclusive when Range is required and the other way around)
• Do not lint range_plus_one inside implementations of Index<RangeInclusive<_>> #3583 (Do not lint range_plus_one inside implementations of Index<RangeInclusive<_>>)

redundant_clone

• redundant_clone in Rc context ? #4982 (redundant_clone in Rc context ?)

redundant_closure

• Add option to disable all linting in external macros #407 (Add option to disable all linting in external macros)
• Bikesheds to be done when RfCing clippy #533 (Bikesheds to be done when RfCing clippy)
• redundant_closure_call false positive in macros #1553 (redundant_closure_call false positive in macros)
• redundant_closure suggests wrong fix when the function being called is not Copy #1608 (redundant_closure suggests wrong fix when the function being called is not Copy)
• Redundant closure lint recommends invalid code #3071 (Redundant closure lint recommends invalid code)
• False redundant_closure_call for a closure that has multiple calls #3354 (False redundant_closure_call for a closure that has multiple calls)
• redundant_closure should be in the Perf group #3468 (redundant_closure should be in the Perf group)
• False positive with redundant_closure and Deref #3942 (False positive with redundant_closure and Deref)
• clippy::redundant_closure suggestion unnecessarily complicated #3974 (clippy::redundant_closure suggestion unnecessarily complicated)
• False positive in redundant_closure when closure value's lifetime is constrained #4002 (False positive in redundant_closure when closure value's lifetime is constrained)
• False positive with redundant_closure #4354 (False positive with redundant_closure)

redundant_closure_call

• redundant_closure_call false positive in macros #1553 (redundant_closure_call false positive in macros)
• False redundant_closure_call for a closure that has multiple calls #3354 (False redundant_closure_call for a closure that has multiple calls)

redundant_field_names

• FR: redundant_field_names should distinguish between all and some fields matching #3422 (FR: redundant_field_names should distinguish between all and some fields matching)

redundant_pattern

• Do not suggest replacing simple if let Some(_) / None with methods #2353 (Do not suggest replacing simple if let Some(_) / None with methods)
• redundant_pattern_matching fixit suggestion fails to apply #4344 (redundant_pattern_matching fixit suggestion fails to apply)

redundant_pattern_matching

• Do not suggest replacing simple if let Some(_) / None with methods #2353 (Do not suggest replacing simple if let Some(_) / None with methods)
• redundant_pattern_matching fixit suggestion fails to apply #4344 (redundant_pattern_matching fixit suggestion fails to apply)

redundant_static_lifetimes

• Clippy doesn't report error/warnings after cargo check #4612 (Clippy doesn't report error/warnings after cargo check)

regex_macro

• regex_macro false positive #2586 (regex_macro false positive)

replace_consts

• Why is replace_consts enabled by default? #2380 (Why is replace_consts enabled by default?)

result_map_unwrap_or_else

• result_map_unwrap_or_else suggestion masks error from result. #3730 (result_map_unwrap_or_else suggestion masks error from result.)

result_unwrap_used

• Disable result_unwrap_used / option_unwrap_used in tests #1015 (Disable result_unwrap_used / option_unwrap_used in tests)
• Merge some lints together #1078 (Merge some lints together)

reverse_range_loop

• Potential improvement to reversed_empty_ranges #2477 (Potential improvement to reverse_range_loop)

shadow_reuse

• Clippy doesn't honour #![allow(shadow_reuse)] #2745 (Clippy doesn't honour #![allow(shadow_reuse)])
• Lint dangerous uses of shadowing #3433 (Lint dangerous uses of shadowing)
• clippy does not warn me of shadowing #3979 (clippy does not warn me of shadowing)

shadow_same

• Lint dangerous uses of shadowing #3433 (Lint dangerous uses of shadowing)
• clippy does not warn me of shadowing #3979 (clippy does not warn me of shadowing)

shadow_unrelated

• Bikesheds to be done when RfCing clippy #533 (Bikesheds to be done when RfCing clippy)
• shadow_unrelated breaks when intermediary bindings are used #3200 (shadow_unrelated breaks when intermediary bindings are used)
• Tracking issue for RFC 2476, Clippy 1.0 #3343 (Tracking issue for RFC 2476, Clippy 1.0)
• Lint dangerous uses of shadowing #3433 (Lint dangerous uses of shadowing)
• Incorrect message in shadow_unrelated #3619 (Incorrect message in shadow_unrelated)
• clippy does not warn me of shadowing #3979 (clippy does not warn me of shadowing)

should_assert_eq

• Extensions to should_assert_eq #1810 (Extensions to should_assert_eq)

should_implement_trait

• should_implement_trait should include ToOwned, FromStr #1600 ( should_implement_trait should include ToOwned, FromStr)
• should_implement_trait should not be triggered by from_str with explicit type annotation #1731 (should_implement_trait should not be triggered by from_str with explicit type annotation)
• Meta issue for Rust API Guidelines #1798 (Meta issue for Rust API Guidelines)
• should_implement_trait should not warn async methods #4290 (should_implement_trait should not warn async methods)
• should_implement_trait triggers for next() where the return value has lifetimes #5004 (should_implement_trait triggers for next() where the return value has lifetimes)

similar_names

• Lint request: unnecessary pass-by-reference #1854 (Lint request: unnecessary pass-by-reference)

single_char_pattern

• Make SINGLE_CHAR_PATTERN check for bounds, not self type #871 (Make SINGLE_CHAR_PATTERN check for bounds, not self type)
• single_char_pattern doesn't recognize scape sequences #3075 (single_char_pattern doesn't recognize scape sequences)
• Slow suggestion of single_char_pattern #3813 (Slow suggestion of single_char_pattern)
• Clippy doesn't report error/warnings after cargo check #4612 (Clippy doesn't report error/warnings after cargo check)

single_match

• Findings from running Clippy on Servo #164 (Findings from running Clippy on Servo)
• single_match should suggest plain if when possible #173 (single_match should suggest plain if when possible)
• Invalid suggestion for single_match #810 (Invalid suggestion for single_match)
• Extend single_match to handle return #929 (Extend single_match to handle return)
• Wrong suggestion from single_match #1404 (Wrong suggestion from single_match)
• Lint if lets that could be better worded as equality #1716 (Lint if lets that could be better worded as equality)
• single_match: recongnize "Ok(_) => {}" or "Err(_bla) => {}" as "_ => {}"  #2567 (single_match: recongnize "Ok(_) => {}" or "Err(bla) => {}" as " => {}" )
• FN single_match_else #3489 (FN single_match_else)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)
• Lint idea: Bind if/else returning bool and then using that binding to conditionally do something #4311 (Lint idea: Bind if/else returning bool and then using that binding to conditionally do something)
• single_match_else false positive #4952 (single_match_else false positive)

single_match_else

• Lint if lets that could be better worded as equality #1716 (Lint if lets that could be better worded as equality)
• FN single_match_else #3489 (FN single_match_else)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)
• Lint idea: Bind if/else returning bool and then using that binding to conditionally do something #4311 (Lint idea: Bind if/else returning bool and then using that binding to conditionally do something)
• single_match_else false positive #4952 (single_match_else false positive)

str_to_string

• (Preliminary) Results of building rust with clippy #278 ((Preliminary) Results of building rust with clippy)
• idea: Combination of str_to_string and needless_closure #317 (idea: Combination of str_to_string and needless_closure)
• new lint for &str to String conversion #2824 (new lint for &str to String conversion)

string_add

• Merge some lints together #1078 (Merge some lints together)

string_add_assign

• Merge some lints together #1078 (Merge some lints together)

string_lit_as_bytes

• string_lit_as_bytes doesn't work correctly #1402 (string_lit_as_bytes doesn't work correctly)
• Incorrect suggestion of string_lit_as_bytes lint #4494 (Incorrect suggestion of string_lit_as_bytes lint)

string_to_string

• Lint unnecessary conversion of OsString or CString to String #2259 (Lint unnecessary conversion of OsString or CString to String)

suspicious_arithmetic_impl

• spurious suspicious_arithmetic_impl #3215 (spurious suspicious_arithmetic_impl)

suspicious_else_formatting

• allman style brace formatting triggers suspicious_else_formatting #3864 (allman style brace formatting triggers suspicious_else_formatting)

suspicious_map

• Improve documentation for suspicious_map #4793 (Improve documentation for suspicious_map)

temporary_cstring_as_ptr

• vec as_ptr/as_mut_ptr should have a deny lint #2637 (vec as_ptr/as_mut_ptr should have a deny lint)

todo

• Allow some way of marking lints as TODO #2158 (Allow some way of marking lints as TODO)
• Don't suggest eta-reducible replacements in UNNECESSARY_FOLD lint #2371 (Don't suggest eta-reducible replacements in UNNECESSARY_FOLD lint)
• Suggestion: Single if let instead of nested if let { if let #2521 (Suggestion: Single if let instead of nested if let { if let)

too_many_arguments

• too_many_arguments should ignore functions called new #1576 (too_many_arguments should ignore functions called new)
• Improve too_many_arguments: only highlight function arguments instead of entire function #2488 (Improve too_many_arguments: only highlight function arguments instead of entire function)

toplevel_ref_arg

• Suggest changing *x to x in toplevel_ref_arg #406 (Suggest changing *x to x in toplevel_ref_arg)
• Wrong code example for the "ref on an entire let pattern is discouraged" lint #1882 (Wrong code example for the "ref on an entire let pattern is discouraged" lint)
• Suggestions for toplevel_ref_arg should not move mut to the right-hand side #3110 (Suggestions for toplevel_ref_arg should not move mut to the right-hand side)

transmute_ptr_to_ptr

• False positives when using transmute() with raw trait object pointers to change trait object lifetimes #2906 (False positives when using transmute() with raw trait object pointers to change trait object lifetimes)

transmute_ptr_to_ref

• Suggestion: Don't lose trailing semicolons (and other context-relevant stuff) #1076 (Suggestion: Don't lose trailing semicolons (and other context-relevant stuff))
• transmute_ptr_to_ref suggestion doesn't with some outer expression types #1754 (transmute_ptr_to_ref suggestion doesn't with some outer expression types)
• extend transmute_ptr_to_ref to detect transmuting newtypes around ptrs #1966 (extend transmute_ptr_to_ref to detect transmuting newtypes around ptrs)
• False positives when using transmute() with raw trait object pointers to change trait object lifetimes #2906 (False positives when using transmute() with raw trait object pointers to change trait object lifetimes)

trivial_regex

• trivial_regex false positive and/or incorrect hint for replace? #1943 (trivial_regex false positive and/or incorrect hint for replace?)
• Incorrect hints from trivial_regex for bytes regexes  #3647 (Incorrect hints from trivial_regex for bytes regexes )

trivially_copy_pass_by_ref

• False positive with trivially_copy_pass_by_ref #2961 (False positive with trivially_copy_pass_by_ref)
• Option to disable trivially_copy_pass_by_ref in public functions #4504 (Option to disable trivially_copy_pass_by_ref in public functions)

type_complexity

• Stronger macro check for identity-op and type-complexity #301 (Stronger macro check for identity-op and type-complexity)
• Create more than 2 lint groups #743 (Create more than 2 lint groups)
• Type complexity should not be considered when defining an associated type #1013 (Type complexity should not be considered when defining an associated type)
• New lint: Unnecessarily complex types #4844 (New lint: Unnecessarily complex types)

type_repetition_in_bounds

• False positive with type_repetition_in_bounds and generics #4323 (False positive with type_repetition_in_bounds and generics)
• type_repetition_in_bounds should not trigger on macro-generated code #4326 (type_repetition_in_bounds should not trigger on macro-generated code)
• type_repetition_in_bounds not always helps #4380 (type_repetition_in_bounds not always helps)

unimplemented

• unnecessary .. binding in struct #638 (unnecessary .. binding in struct)
• lint assigning to fields of an uninitialized struct #1058 (lint assigning to fields of an uninitialized struct)
• Warn about Results only used in println!() #2529 (Warn about Results only used in println!())
• False positive with use_self and generics #3410 (False positive with use_self and generics)
• clippy::unimplemented doesn't detect unimplemented!() with message #3528 (clippy::unimplemented doesn't detect unimplemented!() with message)
• should_implement_trait should not warn async methods #4290 (should_implement_trait should not warn async methods)
• boxed_local false positive for ?Sized #4740 (boxed_local false positive for ?Sized)

uninit_assumed_init

• uninit_assumed_init lint does not recognize trivial misuse #4765 (uninit_assumed_init lint does not recognize trivial misuse)

unit_arg

• catch-22 with try block, clippy::unit_arg and clippy::unused_unit #3759 (catch-22 with try block, clippy::unit_arg and clippy::unused_unit)
• [cargo fix] unit_arg removes calls to functions with side-effects #4741 ([cargo fix] unit_arg removes calls to functions with side-effects)

unit_cmp

• unit_cmp: special handling of assert_eq!(Option.unwrap(), ()); #4661 (unit_cmp: special handling of assert_eq!(Option.unwrap(), ());)

unnecessary_filter_map

• False positive for unnecessary_filter_map #4433 (False positive for unnecessary_filter_map)

unnecessary_fold

• Don't suggest eta-reducible replacements in UNNECESSARY_FOLD lint #2371 (Don't suggest eta-reducible replacements in UNNECESSARY_FOLD lint)
• Suggest replacing simple loops with specialized folds #2401 (Suggest replacing simple loops with specialized folds)
• unnecessary_fold: .any and .all may not always be safe replacements of .fold #3351 (unnecessary_fold: .any and .all may not always be safe replacements of .fold)

unnecessary_mut_passed

• False positives selecting system allocator #2373 (False positives selecting system allocator)
• have different docs for nightly/beta/stable channels #3455 (have different docs for nightly/beta/stable channels)

unnecessary_unwrap

• unnecessary_unwrap: should not trigger if the is_some is just part of the conditional #4530 (unnecessary_unwrap: should not trigger if the is_some is just part of the conditional)

unneeded_field_pattern

• unneeded_field_pattern  #1741 (unneeded_field_pattern )

unreachable

• lint panics (allow) #668 (lint panics (allow))
• Lint for unconditional unreachable!() #1632 (Lint for unconditional unreachable!())
• Lint suggestions based on MISRA 2004 #2227 (Lint suggestions based on MISRA 2004)
• clippy::unimplemented doesn't detect unimplemented!() with message #3528 (clippy::unimplemented doesn't detect unimplemented!() with message)
• Suggest using !/Infallibe in trait implementations with a result type. #4644 (Suggest using !/Infallibe in trait implementations with a result type.)

unreadable_literal

• unreadable_literal is annoying for hex numbers #2842 (unreadable_literal is annoying for hex numbers)
• have different docs for nightly/beta/stable channels #3455 (have different docs for nightly/beta/stable channels)
• unreadable_literal for floating-point numbers #4176 (unreadable_literal for floating-point numbers)
• BUG: Incorrect mistyped literal suffix on long floats. #4706 (BUG: Incorrect mistyped literal suffix on long floats.)

unused_io_amount

• Clippy errors and says to use Read::read_exact inside implementations of Read::read_exact that don't directly use the output of Read::read #4836 (Clippy errors and says to use Read::read_exact inside implementations of Read::read_exact that don't directly use the output of Read::read)

unused_label

• Add automatically applicable suggestion to unused_label #1850 (Add automatically applicable suggestion to unused_label)

unused_self

• FP: unused_self triggers if only the lifetime of self is used #4928 (FP: unused_self triggers if only the lifetime of self is used)

unused_unit

• catch-22 with try block, clippy::unit_arg and clippy::unused_unit #3759 (catch-22 with try block, clippy::unit_arg and clippy::unused_unit)

use_debug

• Lint for Debug formatting in Display implementations #1713 (Lint for Debug formatting in Display implementations)
• use_debug lint should not trigger on debug!() log macro calls #2132 (use_debug lint should not trigger on debug!() log macro calls)

use_self

• Tracking Issue: Split up our UI-tests into smaller parts #2038 (Tracking Issue: Split up our UI-tests into smaller parts)
• False positive for use_self when using an associated type instead of the type itself. #2843 (False positive for use_self when using an associated type instead of the type itself.)
• False positive with use_self and generics #3410 (False positive with use_self and generics)
• New Lint: Unnameable type in public API #3618 (New Lint: Unnameable type in public API)
• use_self lint suggests changing code to use outer type parameters breaking build #3859 (use_self lint suggests changing code to use outer type parameters breaking build)
• use_self lint false positive in macros #3881 (use_self lint false positive in macros)
• use_self false positive on derive #3909 (use_self false positive on derive)
• Suggestion does not compile: use self with associated types #4140 (Suggestion does not compile: use self with associated types)
• Suggestion does not compile: use self with when implementing a trait for a generic type #4143 (Suggestion does not compile: use self with when implementing a trait for a generic type)
• Suggestion does not compile: use self with when implementing From conversion for the Box<dyn Trait>. #4305 (Suggestion does not compile: use self with when implementing From conversion for the Box<dyn Trait>.)
• False positive for use_self when using core::mem::transmute in From impl #4734 (False positive for use_self when using core::mem::transmute in From impl)
• use_self lint fires on code expanded from a macro #4887 (use_self lint fires on code expanded from a macro)

used_underscore_binding

• Fix used_underscore_binding #947 (Fix used_underscore_binding)
• "multiple matching crates for serde_derive" in test used_underscore_binding_macro #3643 ("multiple matching crates for serde_derive" in test used_underscore_binding_macro)

useless_attribute

• The useless attribute lint doesn't put the ! in the right place. #1522 (The useless attribute lint doesn't put the ! in the right place.)
• Incorrect suggestion in useless_attribute lint #4467 (Incorrect suggestion in useless_attribute lint)

useless_format

• FN: useless format: formatting PathBuf.display() #3021 (FN: useless format: formatting PathBuf.display())
• lint unused (clippy) allow attributes #3122 (lint unused (clippy) allow attributes)
• FN useless_format: write!(f,"{}",format!()) #3155 (FN useless_format: write!(f,"{}",format!()))
• FN useless format: struct with fmt::Display and format!() ?  #3156 (FN useless format: struct with fmt::Display and format!() ? )
• useless_format: .to_string() suggested where format! could be omitted #3361 (useless_format: .to_string() suggested where format! could be omitted)
• Extend useless_format to lint values other than &str and String #3753 (Extend useless_format to lint values other than &str and String)

useless_let_if_seq

• What about placeholders? #1081 (What about placeholders?)
• False positive on 'useless_let_if_seq' #2176 (False positive on 'useless_let_if_seq')
• useless_let_if_seq should not emit a warning if multiple assignments happen #2749 (useless_let_if_seq should not emit a warning if multiple assignments happen)
• Incorrect suggestion by useless_let_if_seq lint #2918 (Incorrect suggestion by useless_let_if_seq lint)
• Clippy suggests optimizing volatile operations away; Shoudln't do so? #3043 (Clippy suggests optimizing volatile operations away; Shoudln't do so?)
• useless_let_if_seq should not warn when variable is set from multiple places. #3769 (useless_let_if_seq should not warn when variable is set from multiple places.)
• Bad suggestion of useless_let_if_seq when having side effects. #4124 (Bad suggestion of useless_let_if_seq when having side effects.)
• Suggest binding to a tuple if possible in the useless_let_if_seq lint #4448 (Suggest binding to a tuple if possible in the useless_let_if_seq lint)

useless_transmute

• [lint idea] dangerous transmutes #546 ([lint idea] dangerous transmutes)
• useless_transmute being raised when it's doing multiple casts #1545 (useless_transmute being raised when it's doing multiple casts)
• False positives when using transmute() with raw trait object pointers to change trait object lifetimes #2906 (False positives when using transmute() with raw trait object pointers to change trait object lifetimes)
• False positive useless_transmute? #3340 (False positive useless_transmute?)

useless_vec

• useless_vec doesn't suggest a necessary & #2256 (useless_vec doesn't suggest a necessary &)

vec_box

• Make VEC_BOX lint configurable over the size of T #3547 (Make VEC_BOX lint configurable over the size of T)

while_immutable_condition

• while_immutable_condition false positive with mut pointers #3548 (while_immutable_condition false positive with mut pointers)

while_let_loop

• (Preliminary) Results of building rust with clippy #278 ((Preliminary) Results of building rust with clippy)
• while_let_loop fails to account for lifetimes #362 (while_let_loop fails to account for lifetimes)
• while_let_loop false positive #1693 (while_let_loop false positive)

while_let_on_iterator

• False positive on while_let_on_iterator with nested while let #600 (False positive on while_let_on_iterator with nested while let)
• Wrong suggestion on while_let_on_iterator #1033 (Wrong suggestion on while_let_on_iterator)
• while_let_on_iterator false positive #1654 (while_let_on_iterator false positive)
• incorrect suggestion for while_let_on_iterator #1924 (incorrect suggestion for while_let_on_iterator)
• Bad while_let_on_iterator suggestion when pattern is refutable #3780 (Bad while_let_on_iterator suggestion when pattern is refutable)

wrong_pub_self_convention

• Suggest using Cow on mixture of &'static str + Strings #320 (Suggest using Cow on mixture of &'static str + Strings)
• Create more than 2 lint groups #743 (Create more than 2 lint groups)

wrong_self_convention

• wrong_self_convention does not recognize this: Self #3414 (wrong_self_convention does not recognize this: Self)
• wrong_self_convention fails for libstd RawEntryBuilderMut::from_key #3858 (wrong_self_convention fails for libstd RawEntryBuilderMut::from_key)
• wrong_self_convention false positive for async fn into_* #4037 (wrong_self_convention false positive for async fn into_*)
• Pin<&mut self> triggers "wrong_self_convention" #4546 (Pin<&mut self> triggers "wrong_self_convention")

zero_prefixed_literal

• decimal constant error #1274 (decimal constant error)

zero_ptr

• zero_ptr lint detected for any lazy_static code #1580 (zero_ptr lint detected for any lazy_static code)
• Lint casting integers to pointers #2177 (Lint casting integers to pointers)
• False positives selecting system allocator #2373 (False positives selecting system allocator)

I'm pretty satisfied with the output. Some lint names that are too generic, like panic or exit, need some extra work though.

---

Usage:

Prints all issues where the specified lint is mentioned either in the title or in the description

USAGE:
    clippy_dev issues_for_lint [FLAGS] [OPTIONS] --name <name>

FLAGS:
        --all        Create a list for all lints
    -h, --help       Prints help information
    -V, --version    Prints version information

OPTIONS:
        --filter <filter>    Comma separated list of issue numbers, that should be filtered out
    -n, --name <name>        The name of the lint

---

Your thoughts about having such a tracking issue?

changelog: none

[apiraino]

how about also checking the issue labels? If at some point in the future issues are then properly labeled with a lint-*, that could make easier to sort them

[flip1995]

Hm, we would then need over 300 labels for all of the lints and the issues had to be labeled correctly. Labeling issues by hand wouldn't be feasible. Maybe we could write an automation for such a labeling. But as long, as we don't have such a system in place, I don't think adding this to this tool makes much sense.

But The lint-*/L-* label idea is definitely interesting! Maybe we could add the labels of the issues in the output of this tool 🤔

[apiraino]

Maybe we could add the labels of the issues in the output of this tool

that's a great idea imo 👍

As a positive side effect, people can easily start using the right label when reporting, decreasing in time the amount of "unlabeled" linting issues.

[apiraino]

Also, but I'm not sure it makes sense, as a starting point, I'd force feed the issueing ticketing system with all the labels with a quick cURL, so people can be instructed to use them immediately and we truncate immediately the input of "unlabeled" linting issues

[flip1995]

The thing is, that "normal" users can't label their issue by them self, but Collaborators/Members have to do this. There is also @rustbot, but we can't check this automatically. We'd could write a GitHub Actions Workflow, that scans a new issue for a lint name and labels it accordingly.

[jyn514]

You can have issue templates that have a default label. I have some examples here: https://github.com/jyn514/rcc/tree/master/.github/ISSUE_TEMPLATE

[apiraino]

Unless I'm wrong, for issue templates to be useful we need to have the user be able to automatically apply one label out of dozens hundreds and that would require having dozens hundreds of templates, therefore a scary list of templates when the user creates the issue :-)

[flip1995]

Since we're soon completely migrated to GHA, we could implement the labeler workflow for issues and PRs, that would do that. But the question, if we want to have hundreds of labels still stands.

[phansch]

If we can automate the label creation, I would not be against it personally but that's probably for another PR

[apiraino]

I agree. So, I'd add a check for the issue label here (because imo it's a sensible default) and then we find a way to manage the issue creation workflow.

[phansch]

Code looks good to me in general 👍 I think somewhere there should also be some instructions on how to generate the issue text. I assume it's cargo --feature issues dev issues_for_lint --name foobar?

[phansch]

Suggested change

	if let Some(links) = response.headers().get("Link").and_then(|l| l.to_str().ok()) {
	if let Some(links) = response.headers().get(reqwest::headers::LINK).and_then(|l| l.to_str().ok()) {

[phansch]

Huh, is there no way to do this without a regex?

[phansch]

Might be nice to give the user agent a slightly more descriptive name such as 'rust-clippy issue finder'

[phansch]

I think it's worth adding some unit tests for this function

[flip1995]

I think that we could really use automatic issue triage, but this probably won't lead to anything.