Full Code of rust-lang/rust-clippy for AI

gitextract_9vlv99pw/

├── .cargo/
│   └── config.toml
├── .editorconfig
├── .gitattributes
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── blank_issue.yml
│   │   ├── bug_report.yml
│   │   ├── config.yml
│   │   ├── false_negative.yml
│   │   ├── false_positive.yml
│   │   ├── ice.yml
│   │   └── new_lint.yml
│   ├── PULL_REQUEST_TEMPLATE.md
│   ├── deploy.sh
│   ├── driver.sh
│   └── workflows/
│       ├── clippy_changelog.yml
│       ├── clippy_dev.yml
│       ├── clippy_mq.yml
│       ├── clippy_pr.yml
│       ├── deploy.yml
│       ├── lintcheck.yml
│       ├── lintcheck_summary.yml
│       └── remark.yml
├── .gitignore
├── .remarkrc
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── COPYRIGHT
├── Cargo.toml
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── askama.toml
├── book/
│   ├── README.md
│   ├── book.toml
│   └── src/
│       ├── README.md
│       ├── SUMMARY.md
│       ├── attribs.md
│       ├── configuration.md
│       ├── continuous_integration/
│       │   ├── README.md
│       │   ├── github_actions.md
│       │   ├── gitlab.md
│       │   └── travis.md
│       ├── development/
│       │   ├── README.md
│       │   ├── adding_lints.md
│       │   ├── basics.md
│       │   ├── common_tools_writing_lints.md
│       │   ├── defining_lints.md
│       │   ├── emitting_lints.md
│       │   ├── infrastructure/
│       │   │   ├── README.md
│       │   │   ├── backport.md
│       │   │   ├── benchmarking.md
│       │   │   ├── book.md
│       │   │   ├── changelog_update.md
│       │   │   ├── release.md
│       │   │   └── sync.md
│       │   ├── lint_passes.md
│       │   ├── macro_expansions.md
│       │   ├── method_checking.md
│       │   ├── proposals/
│       │   │   ├── README.md
│       │   │   ├── roadmap-2021.md
│       │   │   └── syntax-tree-patterns.md
│       │   ├── speedtest.md
│       │   ├── the_team.md
│       │   ├── trait_checking.md
│       │   ├── type_checking.md
│       │   └── writing_tests.md
│       ├── installation.md
│       ├── lint_configuration.md
│       ├── lints.md
│       └── usage.md
├── build.rs
├── clippy.toml
├── clippy_config/
│   ├── Cargo.toml
│   └── src/
│       ├── conf.rs
│       ├── lib.rs
│       ├── metadata.rs
│       └── types.rs
├── clippy_dev/
│   ├── Cargo.toml
│   └── src/
│       ├── deprecate_lint.rs
│       ├── dogfood.rs
│       ├── edit_lints.rs
│       ├── fmt.rs
│       ├── generate.rs
│       ├── lib.rs
│       ├── lint.rs
│       ├── main.rs
│       ├── new_lint.rs
│       ├── parse/
│       │   └── cursor.rs
│       ├── parse.rs
│       ├── release.rs
│       ├── serve.rs
│       ├── setup/
│       │   ├── git_hook.rs
│       │   ├── intellij.rs
│       │   ├── mod.rs
│       │   ├── toolchain.rs
│       │   └── vscode.rs
│       ├── sync.rs
│       └── utils.rs
├── clippy_dummy/
│   ├── Cargo.toml
│   ├── PUBLISH.md
│   ├── build.rs
│   ├── crates-readme.md
│   └── src/
│       └── main.rs
├── clippy_lints/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── absolute_paths.rs
│       ├── almost_complete_range.rs
│       ├── approx_const.rs
│       ├── arbitrary_source_item_ordering.rs
│       ├── arc_with_non_send_sync.rs
│       ├── as_conversions.rs
│       ├── asm_syntax.rs
│       ├── assertions_on_constants.rs
│       ├── assertions_on_result_states.rs
│       ├── assigning_clones.rs
│       ├── async_yields_async.rs
│       ├── attrs/
│       │   ├── allow_attributes.rs
│       │   ├── allow_attributes_without_reason.rs
│       │   ├── blanket_clippy_restriction_lints.rs
│       │   ├── deprecated_cfg_attr.rs
│       │   ├── deprecated_semver.rs
│       │   ├── duplicated_attributes.rs
│       │   ├── inline_always.rs
│       │   ├── mixed_attributes_style.rs
│       │   ├── mod.rs
│       │   ├── non_minimal_cfg.rs
│       │   ├── repr_attributes.rs
│       │   ├── should_panic_without_expect.rs
│       │   ├── unnecessary_clippy_cfg.rs
│       │   ├── useless_attribute.rs
│       │   └── utils.rs
│       ├── await_holding_invalid.rs
│       ├── blocks_in_conditions.rs
│       ├── bool_assert_comparison.rs
│       ├── bool_comparison.rs
│       ├── bool_to_int_with_if.rs
│       ├── booleans.rs
│       ├── borrow_deref_ref.rs
│       ├── box_default.rs
│       ├── byte_char_slices.rs
│       ├── cargo/
│       │   ├── common_metadata.rs
│       │   ├── feature_name.rs
│       │   ├── lint_groups_priority.rs
│       │   ├── mod.rs
│       │   ├── multiple_crate_versions.rs
│       │   └── wildcard_dependencies.rs
│       ├── casts/
│       │   ├── as_pointer_underscore.rs
│       │   ├── as_ptr_cast_mut.rs
│       │   ├── as_underscore.rs
│       │   ├── borrow_as_ptr.rs
│       │   ├── cast_abs_to_unsigned.rs
│       │   ├── cast_enum_constructor.rs
│       │   ├── cast_lossless.rs
│       │   ├── cast_nan_to_int.rs
│       │   ├── cast_possible_truncation.rs
│       │   ├── cast_possible_wrap.rs
│       │   ├── cast_precision_loss.rs
│       │   ├── cast_ptr_alignment.rs
│       │   ├── cast_sign_loss.rs
│       │   ├── cast_slice_different_sizes.rs
│       │   ├── cast_slice_from_raw_parts.rs
│       │   ├── char_lit_as_u8.rs
│       │   ├── confusing_method_to_numeric_cast.rs
│       │   ├── fn_to_numeric_cast.rs
│       │   ├── fn_to_numeric_cast_any.rs
│       │   ├── fn_to_numeric_cast_with_truncation.rs
│       │   ├── manual_dangling_ptr.rs
│       │   ├── mod.rs
│       │   ├── needless_type_cast.rs
│       │   ├── ptr_as_ptr.rs
│       │   ├── ptr_cast_constness.rs
│       │   ├── ref_as_ptr.rs
│       │   ├── unnecessary_cast.rs
│       │   ├── utils.rs
│       │   └── zero_ptr.rs
│       ├── cfg_not_test.rs
│       ├── checked_conversions.rs
│       ├── cloned_ref_to_slice_refs.rs
│       ├── coerce_container_to_any.rs
│       ├── cognitive_complexity.rs
│       ├── collapsible_if.rs
│       ├── collection_is_never_read.rs
│       ├── comparison_chain.rs
│       ├── copy_iterator.rs
│       ├── crate_in_macro_def.rs
│       ├── create_dir.rs
│       ├── dbg_macro.rs
│       ├── declared_lints.rs
│       ├── default.rs
│       ├── default_constructed_unit_structs.rs
│       ├── default_instead_of_iter_empty.rs
│       ├── default_numeric_fallback.rs
│       ├── default_union_representation.rs
│       ├── deprecated_lints.rs
│       ├── dereference.rs
│       ├── derivable_impls.rs
│       ├── derive/
│       │   ├── derive_ord_xor_partial_ord.rs
│       │   ├── derive_partial_eq_without_eq.rs
│       │   ├── derived_hash_with_manual_eq.rs
│       │   ├── expl_impl_clone_on_copy.rs
│       │   ├── mod.rs
│       │   └── unsafe_derive_deserialize.rs
│       ├── disallowed_fields.rs
│       ├── disallowed_macros.rs
│       ├── disallowed_methods.rs
│       ├── disallowed_names.rs
│       ├── disallowed_script_idents.rs
│       ├── disallowed_types.rs
│       ├── doc/
│       │   ├── broken_link.rs
│       │   ├── doc_comment_double_space_linebreaks.rs
│       │   ├── doc_paragraphs_missing_punctuation.rs
│       │   ├── doc_suspicious_footnotes.rs
│       │   ├── include_in_doc_without_cfg.rs
│       │   ├── lazy_continuation.rs
│       │   ├── link_with_quotes.rs
│       │   ├── markdown.rs
│       │   ├── missing_headers.rs
│       │   ├── mod.rs
│       │   ├── needless_doctest_main.rs
│       │   ├── suspicious_doc_comments.rs
│       │   ├── test_attr_in_doctest.rs
│       │   └── too_long_first_doc_paragraph.rs
│       ├── double_parens.rs
│       ├── drop_forget_ref.rs
│       ├── duplicate_mod.rs
│       ├── duration_suboptimal_units.rs
│       ├── else_if_without_else.rs
│       ├── empty_drop.rs
│       ├── empty_enums.rs
│       ├── empty_line_after.rs
│       ├── empty_with_brackets.rs
│       ├── endian_bytes.rs
│       ├── entry.rs
│       ├── enum_clike.rs
│       ├── equatable_if_let.rs
│       ├── error_impl_error.rs
│       ├── escape.rs
│       ├── eta_reduction.rs
│       ├── excessive_bools.rs
│       ├── excessive_nesting.rs
│       ├── exhaustive_items.rs
│       ├── exit.rs
│       ├── explicit_write.rs
│       ├── extra_unused_type_parameters.rs
│       ├── fallible_impl_from.rs
│       ├── field_scoped_visibility_modifiers.rs
│       ├── float_literal.rs
│       ├── floating_point_arithmetic/
│       │   ├── custom_abs.rs
│       │   ├── expm1.rs
│       │   ├── hypot.rs
│       │   ├── lib.rs
│       │   ├── ln1p.rs
│       │   ├── log_base.rs
│       │   ├── log_division.rs
│       │   ├── mod.rs
│       │   ├── mul_add.rs
│       │   ├── powf.rs
│       │   ├── powi.rs
│       │   └── radians.rs
│       ├── format.rs
│       ├── format_args.rs
│       ├── format_impl.rs
│       ├── format_push_string.rs
│       ├── formatting.rs
│       ├── four_forward_slashes.rs
│       ├── from_over_into.rs
│       ├── from_raw_with_void_ptr.rs
│       ├── from_str_radix_10.rs
│       ├── functions/
│       │   ├── duplicate_underscore_argument.rs
│       │   ├── impl_trait_in_params.rs
│       │   ├── misnamed_getters.rs
│       │   ├── mod.rs
│       │   ├── must_use.rs
│       │   ├── not_unsafe_ptr_arg_deref.rs
│       │   ├── ref_option.rs
│       │   ├── renamed_function_params.rs
│       │   ├── result.rs
│       │   ├── too_many_arguments.rs
│       │   └── too_many_lines.rs
│       ├── future_not_send.rs
│       ├── if_let_mutex.rs
│       ├── if_not_else.rs
│       ├── if_then_some_else_none.rs
│       ├── ifs/
│       │   ├── branches_sharing_code.rs
│       │   ├── if_same_then_else.rs
│       │   ├── ifs_same_cond.rs
│       │   ├── mod.rs
│       │   └── same_functions_in_if_cond.rs
│       ├── ignored_unit_patterns.rs
│       ├── impl_hash_with_borrow_str_and_bytes.rs
│       ├── implicit_hasher.rs
│       ├── implicit_return.rs
│       ├── implicit_saturating_add.rs
│       ├── implicit_saturating_sub.rs
│       ├── implied_bounds_in_impls.rs
│       ├── incompatible_msrv.rs
│       ├── inconsistent_struct_constructor.rs
│       ├── index_refutable_slice.rs
│       ├── indexing_slicing.rs
│       ├── ineffective_open_options.rs
│       ├── infallible_try_from.rs
│       ├── infinite_iter.rs
│       ├── inherent_impl.rs
│       ├── inherent_to_string.rs
│       ├── init_numbered_fields.rs
│       ├── inline_fn_without_body.rs
│       ├── int_plus_one.rs
│       ├── item_name_repetitions.rs
│       ├── items_after_statements.rs
│       ├── items_after_test_module.rs
│       ├── iter_not_returning_iterator.rs
│       ├── iter_over_hash_type.rs
│       ├── iter_without_into_iter.rs
│       ├── large_const_arrays.rs
│       ├── large_enum_variant.rs
│       ├── large_futures.rs
│       ├── large_include_file.rs
│       ├── large_stack_arrays.rs
│       ├── large_stack_frames.rs
│       ├── legacy_numeric_constants.rs
│       ├── len_without_is_empty.rs
│       ├── len_zero.rs
│       ├── let_if_seq.rs
│       ├── let_underscore.rs
│       ├── let_with_type_underscore.rs
│       ├── lib.rs
│       ├── lifetimes.rs
│       ├── literal_representation.rs
│       ├── literal_string_with_formatting_args.rs
│       ├── loops/
│       │   ├── char_indices_as_byte_indices.rs
│       │   ├── empty_loop.rs
│       │   ├── explicit_counter_loop.rs
│       │   ├── explicit_into_iter_loop.rs
│       │   ├── explicit_iter_loop.rs
│       │   ├── for_kv_map.rs
│       │   ├── infinite_loop.rs
│       │   ├── iter_next_loop.rs
│       │   ├── manual_find.rs
│       │   ├── manual_flatten.rs
│       │   ├── manual_memcpy.rs
│       │   ├── manual_slice_fill.rs
│       │   ├── manual_while_let_some.rs
│       │   ├── missing_spin_loop.rs
│       │   ├── mod.rs
│       │   ├── mut_range_bound.rs
│       │   ├── needless_range_loop.rs
│       │   ├── never_loop.rs
│       │   ├── same_item_push.rs
│       │   ├── single_element_loop.rs
│       │   ├── unused_enumerate_index.rs
│       │   ├── utils.rs
│       │   ├── while_float.rs
│       │   ├── while_immutable_condition.rs
│       │   ├── while_let_loop.rs
│       │   └── while_let_on_iterator.rs
│       ├── macro_metavars_in_unsafe.rs
│       ├── macro_use.rs
│       ├── main_recursion.rs
│       ├── manual_abs_diff.rs
│       ├── manual_assert.rs
│       ├── manual_async_fn.rs
│       ├── manual_bits.rs
│       ├── manual_checked_ops.rs
│       ├── manual_clamp.rs
│       ├── manual_float_methods.rs
│       ├── manual_hash_one.rs
│       ├── manual_ignore_case_cmp.rs
│       ├── manual_ilog2.rs
│       ├── manual_is_ascii_check.rs
│       ├── manual_is_power_of_two.rs
│       ├── manual_let_else.rs
│       ├── manual_main_separator_str.rs
│       ├── manual_non_exhaustive.rs
│       ├── manual_option_as_slice.rs
│       ├── manual_pop_if.rs
│       ├── manual_range_patterns.rs
│       ├── manual_rem_euclid.rs
│       ├── manual_retain.rs
│       ├── manual_rotate.rs
│       ├── manual_slice_size_calculation.rs
│       ├── manual_string_new.rs
│       ├── manual_strip.rs
│       ├── manual_take.rs
│       ├── map_unit_fn.rs
│       ├── match_result_ok.rs
│       ├── matches/
│       │   ├── collapsible_match.rs
│       │   ├── infallible_destructuring_match.rs
│       │   ├── manual_filter.rs
│       │   ├── manual_map.rs
│       │   ├── manual_ok_err.rs
│       │   ├── manual_unwrap_or.rs
│       │   ├── manual_utils.rs
│       │   ├── match_as_ref.rs
│       │   ├── match_bool.rs
│       │   ├── match_like_matches.rs
│       │   ├── match_ref_pats.rs
│       │   ├── match_same_arms.rs
│       │   ├── match_single_binding.rs
│       │   ├── match_str_case_mismatch.rs
│       │   ├── match_wild_enum.rs
│       │   ├── match_wild_err_arm.rs
│       │   ├── mod.rs
│       │   ├── needless_match.rs
│       │   ├── overlapping_arms.rs
│       │   ├── redundant_guards.rs
│       │   ├── redundant_pattern_match.rs
│       │   ├── rest_pat_in_fully_bound_struct.rs
│       │   ├── significant_drop_in_scrutinee.rs
│       │   ├── single_match.rs
│       │   ├── try_err.rs
│       │   └── wild_in_or_pats.rs
│       ├── mem_replace.rs
│       ├── methods/
│       │   ├── bind_instead_of_map.rs
│       │   ├── bytecount.rs
│       │   ├── bytes_count_to_len.rs
│       │   ├── bytes_nth.rs
│       │   ├── case_sensitive_file_extension_comparisons.rs
│       │   ├── chars_cmp.rs
│       │   ├── chars_cmp_with_unwrap.rs
│       │   ├── chars_last_cmp.rs
│       │   ├── chars_last_cmp_with_unwrap.rs
│       │   ├── chars_next_cmp.rs
│       │   ├── chars_next_cmp_with_unwrap.rs
│       │   ├── clear_with_drain.rs
│       │   ├── clone_on_copy.rs
│       │   ├── clone_on_ref_ptr.rs
│       │   ├── cloned_instead_of_copied.rs
│       │   ├── collapsible_str_replace.rs
│       │   ├── double_ended_iterator_last.rs
│       │   ├── drain_collect.rs
│       │   ├── err_expect.rs
│       │   ├── expect_fun_call.rs
│       │   ├── extend_with_drain.rs
│       │   ├── filetype_is_file.rs
│       │   ├── filter_map.rs
│       │   ├── filter_map_bool_then.rs
│       │   ├── filter_map_identity.rs
│       │   ├── filter_map_next.rs
│       │   ├── filter_next.rs
│       │   ├── flat_map_identity.rs
│       │   ├── flat_map_option.rs
│       │   ├── format_collect.rs
│       │   ├── from_iter_instead_of_collect.rs
│       │   ├── get_first.rs
│       │   ├── get_last_with_len.rs
│       │   ├── get_unwrap.rs
│       │   ├── implicit_clone.rs
│       │   ├── inefficient_to_string.rs
│       │   ├── inspect_for_each.rs
│       │   ├── into_iter_on_ref.rs
│       │   ├── io_other_error.rs
│       │   ├── ip_constant.rs
│       │   ├── is_digit_ascii_radix.rs
│       │   ├── is_empty.rs
│       │   ├── iter_cloned_collect.rs
│       │   ├── iter_count.rs
│       │   ├── iter_filter.rs
│       │   ├── iter_kv_map.rs
│       │   ├── iter_next_slice.rs
│       │   ├── iter_nth.rs
│       │   ├── iter_nth_zero.rs
│       │   ├── iter_on_single_or_empty_collections.rs
│       │   ├── iter_out_of_bounds.rs
│       │   ├── iter_overeager_cloned.rs
│       │   ├── iter_skip_next.rs
│       │   ├── iter_skip_zero.rs
│       │   ├── iter_with_drain.rs
│       │   ├── iterator_step_by_zero.rs
│       │   ├── join_absolute_paths.rs
│       │   ├── lib.rs
│       │   ├── lines_filter_map_ok.rs
│       │   ├── manual_c_str_literals.rs
│       │   ├── manual_contains.rs
│       │   ├── manual_inspect.rs
│       │   ├── manual_is_variant_and.rs
│       │   ├── manual_next_back.rs
│       │   ├── manual_ok_or.rs
│       │   ├── manual_repeat_n.rs
│       │   ├── manual_saturating_arithmetic.rs
│       │   ├── manual_str_repeat.rs
│       │   ├── manual_try_fold.rs
│       │   ├── map_all_any_identity.rs
│       │   ├── map_clone.rs
│       │   ├── map_collect_result_unit.rs
│       │   ├── map_err_ignore.rs
│       │   ├── map_flatten.rs
│       │   ├── map_identity.rs
│       │   ├── map_unwrap_or.rs
│       │   ├── map_unwrap_or_else.rs
│       │   ├── map_with_unused_argument_over_ranges.rs
│       │   ├── mod.rs
│       │   ├── mut_mutex_lock.rs
│       │   ├── needless_as_bytes.rs
│       │   ├── needless_character_iteration.rs
│       │   ├── needless_collect.rs
│       │   ├── needless_option_as_deref.rs
│       │   ├── needless_option_take.rs
│       │   ├── new_ret_no_self.rs
│       │   ├── no_effect_replace.rs
│       │   ├── obfuscated_if_else.rs
│       │   ├── ok_expect.rs
│       │   ├── open_options.rs
│       │   ├── option_as_ref_cloned.rs
│       │   ├── option_as_ref_deref.rs
│       │   ├── option_map_or_none.rs
│       │   ├── or_fun_call.rs
│       │   ├── or_then_unwrap.rs
│       │   ├── path_buf_push_overwrite.rs
│       │   ├── path_ends_with_ext.rs
│       │   ├── ptr_offset_by_literal.rs
│       │   ├── ptr_offset_with_cast.rs
│       │   ├── range_zip_with_len.rs
│       │   ├── read_line_without_trim.rs
│       │   ├── readonly_write_lock.rs
│       │   ├── redundant_as_str.rs
│       │   ├── repeat_once.rs
│       │   ├── result_map_or_else_none.rs
│       │   ├── return_and_then.rs
│       │   ├── search_is_some.rs
│       │   ├── seek_from_current.rs
│       │   ├── seek_to_start_instead_of_rewind.rs
│       │   ├── should_implement_trait.rs
│       │   ├── single_char_add_str.rs
│       │   ├── skip_while_next.rs
│       │   ├── sliced_string_as_bytes.rs
│       │   ├── stable_sort_primitive.rs
│       │   ├── str_split.rs
│       │   ├── str_splitn.rs
│       │   ├── string_extend_chars.rs
│       │   ├── string_lit_chars_any.rs
│       │   ├── suspicious_command_arg_space.rs
│       │   ├── suspicious_map.rs
│       │   ├── suspicious_splitn.rs
│       │   ├── suspicious_to_owned.rs
│       │   ├── swap_with_temporary.rs
│       │   ├── type_id_on_box.rs
│       │   ├── unbuffered_bytes.rs
│       │   ├── uninit_assumed_init.rs
│       │   ├── unit_hash.rs
│       │   ├── unnecessary_fallible_conversions.rs
│       │   ├── unnecessary_filter_map.rs
│       │   ├── unnecessary_first_then_check.rs
│       │   ├── unnecessary_fold.rs
│       │   ├── unnecessary_get_then_check.rs
│       │   ├── unnecessary_iter_cloned.rs
│       │   ├── unnecessary_join.rs
│       │   ├── unnecessary_lazy_eval.rs
│       │   ├── unnecessary_literal_unwrap.rs
│       │   ├── unnecessary_map_or.rs
│       │   ├── unnecessary_map_or_else.rs
│       │   ├── unnecessary_min_or_max.rs
│       │   ├── unnecessary_sort_by.rs
│       │   ├── unnecessary_to_owned.rs
│       │   ├── unwrap_expect_used.rs
│       │   ├── useless_asref.rs
│       │   ├── useless_nonzero_new_unchecked.rs
│       │   ├── utils.rs
│       │   ├── vec_resize_to_zero.rs
│       │   ├── verbose_file_reads.rs
│       │   ├── waker_clone_wake.rs
│       │   ├── wrong_self_convention.rs
│       │   └── zst_offset.rs
│       ├── min_ident_chars.rs
│       ├── minmax.rs
│       ├── misc.rs
│       ├── misc_early/
│       │   ├── builtin_type_shadow.rs
│       │   ├── literal_suffix.rs
│       │   ├── mixed_case_hex_literals.rs
│       │   ├── mod.rs
│       │   ├── redundant_at_rest_pattern.rs
│       │   ├── redundant_pattern.rs
│       │   ├── unneeded_field_pattern.rs
│       │   ├── unneeded_wildcard_pattern.rs
│       │   └── zero_prefixed_literal.rs
│       ├── mismatching_type_param_order.rs
│       ├── missing_assert_message.rs
│       ├── missing_asserts_for_indexing.rs
│       ├── missing_const_for_fn.rs
│       ├── missing_const_for_thread_local.rs
│       ├── missing_doc.rs
│       ├── missing_enforced_import_rename.rs
│       ├── missing_fields_in_debug.rs
│       ├── missing_inline.rs
│       ├── missing_trait_methods.rs
│       ├── mixed_read_write_in_expression.rs
│       ├── module_style.rs
│       ├── multi_assignments.rs
│       ├── multiple_bound_locations.rs
│       ├── multiple_unsafe_ops_per_block.rs
│       ├── mut_key.rs
│       ├── mut_mut.rs
│       ├── mutable_debug_assertion.rs
│       ├── mutex_atomic.rs
│       ├── needless_arbitrary_self_type.rs
│       ├── needless_bool.rs
│       ├── needless_borrowed_ref.rs
│       ├── needless_borrows_for_generic_args.rs
│       ├── needless_continue.rs
│       ├── needless_else.rs
│       ├── needless_for_each.rs
│       ├── needless_ifs.rs
│       ├── needless_late_init.rs
│       ├── needless_maybe_sized.rs
│       ├── needless_parens_on_range_literals.rs
│       ├── needless_pass_by_ref_mut.rs
│       ├── needless_pass_by_value.rs
│       ├── needless_question_mark.rs
│       ├── needless_update.rs
│       ├── neg_cmp_op_on_partial_ord.rs
│       ├── neg_multiply.rs
│       ├── new_without_default.rs
│       ├── no_effect.rs
│       ├── no_mangle_with_rust_abi.rs
│       ├── non_canonical_impls.rs
│       ├── non_copy_const.rs
│       ├── non_expressive_names.rs
│       ├── non_octal_unix_permissions.rs
│       ├── non_send_fields_in_send_ty.rs
│       ├── non_std_lazy_statics.rs
│       ├── non_zero_suggestions.rs
│       ├── nonstandard_macro_braces.rs
│       ├── octal_escapes.rs
│       ├── only_used_in_recursion.rs
│       ├── operators/
│       │   ├── absurd_extreme_comparisons.rs
│       │   ├── arithmetic_side_effects.rs
│       │   ├── assign_op_pattern.rs
│       │   ├── bit_mask.rs
│       │   ├── cmp_owned.rs
│       │   ├── const_comparisons.rs
│       │   ├── decimal_bitwise_operands.rs
│       │   ├── double_comparison.rs
│       │   ├── duration_subsec.rs
│       │   ├── eq_op.rs
│       │   ├── erasing_op.rs
│       │   ├── float_cmp.rs
│       │   ├── float_equality_without_abs.rs
│       │   ├── identity_op.rs
│       │   ├── integer_division.rs
│       │   ├── integer_division_remainder_used.rs
│       │   ├── invalid_upcast_comparisons.rs
│       │   ├── manual_div_ceil.rs
│       │   ├── manual_is_multiple_of.rs
│       │   ├── manual_midpoint.rs
│       │   ├── misrefactored_assign_op.rs
│       │   ├── mod.rs
│       │   ├── modulo_arithmetic.rs
│       │   ├── modulo_one.rs
│       │   ├── needless_bitwise_bool.rs
│       │   ├── numeric_arithmetic.rs
│       │   ├── op_ref.rs
│       │   ├── self_assignment.rs
│       │   └── verbose_bit_mask.rs
│       ├── option_env_unwrap.rs
│       ├── option_if_let_else.rs
│       ├── panic_in_result_fn.rs
│       ├── panic_unimplemented.rs
│       ├── panicking_overflow_checks.rs
│       ├── partial_pub_fields.rs
│       ├── partialeq_ne_impl.rs
│       ├── partialeq_to_none.rs
│       ├── pass_by_ref_or_value.rs
│       ├── pathbuf_init_then_push.rs
│       ├── pattern_type_mismatch.rs
│       ├── permissions_set_readonly_false.rs
│       ├── pointers_in_nomem_asm_block.rs
│       ├── precedence.rs
│       ├── ptr/
│       │   ├── cmp_null.rs
│       │   ├── mod.rs
│       │   ├── mut_from_ref.rs
│       │   ├── ptr_arg.rs
│       │   └── ptr_eq.rs
│       ├── pub_underscore_fields.rs
│       ├── pub_use.rs
│       ├── question_mark.rs
│       ├── question_mark_used.rs
│       ├── ranges.rs
│       ├── raw_strings.rs
│       ├── rc_clone_in_vec_init.rs
│       ├── read_zero_byte_vec.rs
│       ├── redundant_async_block.rs
│       ├── redundant_clone.rs
│       ├── redundant_closure_call.rs
│       ├── redundant_else.rs
│       ├── redundant_field_names.rs
│       ├── redundant_locals.rs
│       ├── redundant_pub_crate.rs
│       ├── redundant_slicing.rs
│       ├── redundant_static_lifetimes.rs
│       ├── redundant_test_prefix.rs
│       ├── redundant_type_annotations.rs
│       ├── ref_option_ref.rs
│       ├── ref_patterns.rs
│       ├── reference.rs
│       ├── regex.rs
│       ├── repeat_vec_with_capacity.rs
│       ├── replace_box.rs
│       ├── reserve_after_initialization.rs
│       ├── return_self_not_must_use.rs
│       ├── returns/
│       │   ├── let_and_return.rs
│       │   ├── mod.rs
│       │   ├── needless_return.rs
│       │   └── needless_return_with_question_mark.rs
│       ├── same_length_and_capacity.rs
│       ├── same_name_method.rs
│       ├── self_named_constructors.rs
│       ├── semicolon_block.rs
│       ├── semicolon_if_nothing_returned.rs
│       ├── serde_api.rs
│       ├── set_contains_or_insert.rs
│       ├── shadow.rs
│       ├── significant_drop_tightening.rs
│       ├── single_call_fn.rs
│       ├── single_char_lifetime_names.rs
│       ├── single_component_path_imports.rs
│       ├── single_option_map.rs
│       ├── single_range_in_vec_init.rs
│       ├── size_of_in_element_count.rs
│       ├── size_of_ref.rs
│       ├── slow_vector_initialization.rs
│       ├── std_instead_of_core.rs
│       ├── string_patterns.rs
│       ├── strings.rs
│       ├── strlen_on_c_strings.rs
│       ├── suspicious_operation_groupings.rs
│       ├── suspicious_trait_impl.rs
│       ├── suspicious_xor_used_as_pow.rs
│       ├── swap.rs
│       ├── swap_ptr_to_ref.rs
│       ├── tabs_in_doc_comments.rs
│       ├── temporary_assignment.rs
│       ├── tests_outside_test_module.rs
│       ├── time_subtraction.rs
│       ├── to_digit_is_some.rs
│       ├── to_string_trait_impl.rs
│       ├── toplevel_ref_arg.rs
│       ├── trailing_empty_array.rs
│       ├── trait_bounds.rs
│       ├── transmute/
│       │   ├── crosspointer_transmute.rs
│       │   ├── eager_transmute.rs
│       │   ├── missing_transmute_annotations.rs
│       │   ├── mod.rs
│       │   ├── transmute_int_to_bool.rs
│       │   ├── transmute_int_to_non_zero.rs
│       │   ├── transmute_null_to_fn.rs
│       │   ├── transmute_ptr_to_ptr.rs
│       │   ├── transmute_ptr_to_ref.rs
│       │   ├── transmute_ref_to_ref.rs
│       │   ├── transmute_undefined_repr.rs
│       │   ├── transmutes_expressible_as_ptr_casts.rs
│       │   ├── transmuting_null.rs
│       │   ├── unsound_collection_transmute.rs
│       │   ├── useless_transmute.rs
│       │   ├── utils.rs
│       │   └── wrong_transmute.rs
│       ├── tuple_array_conversions.rs
│       ├── types/
│       │   ├── borrowed_box.rs
│       │   ├── box_collection.rs
│       │   ├── linked_list.rs
│       │   ├── mod.rs
│       │   ├── option_option.rs
│       │   ├── owned_cow.rs
│       │   ├── rc_buffer.rs
│       │   ├── rc_mutex.rs
│       │   ├── redundant_allocation.rs
│       │   ├── type_complexity.rs
│       │   ├── utils.rs
│       │   └── vec_box.rs
│       ├── unconditional_recursion.rs
│       ├── undocumented_unsafe_blocks.rs
│       ├── unicode.rs
│       ├── uninhabited_references.rs
│       ├── uninit_vec.rs
│       ├── unit_return_expecting_ord.rs
│       ├── unit_types/
│       │   ├── let_unit_value.rs
│       │   ├── mod.rs
│       │   ├── unit_arg.rs
│       │   ├── unit_cmp.rs
│       │   └── utils.rs
│       ├── unnecessary_box_returns.rs
│       ├── unnecessary_literal_bound.rs
│       ├── unnecessary_map_on_constructor.rs
│       ├── unnecessary_mut_passed.rs
│       ├── unnecessary_owned_empty_strings.rs
│       ├── unnecessary_self_imports.rs
│       ├── unnecessary_semicolon.rs
│       ├── unnecessary_struct_initialization.rs
│       ├── unnecessary_wraps.rs
│       ├── unneeded_struct_pattern.rs
│       ├── unnested_or_patterns.rs
│       ├── unsafe_removed_from_name.rs
│       ├── unused_async.rs
│       ├── unused_io_amount.rs
│       ├── unused_peekable.rs
│       ├── unused_result_ok.rs
│       ├── unused_rounding.rs
│       ├── unused_self.rs
│       ├── unused_trait_names.rs
│       ├── unused_unit.rs
│       ├── unwrap.rs
│       ├── unwrap_in_result.rs
│       ├── upper_case_acronyms.rs
│       ├── use_self.rs
│       ├── useless_concat.rs
│       ├── useless_conversion.rs
│       ├── useless_vec.rs
│       ├── utils/
│       │   ├── attr_collector.rs
│       │   ├── author.rs
│       │   ├── dump_hir.rs
│       │   ├── format_args_collector.rs
│       │   └── mod.rs
│       ├── vec_init_then_push.rs
│       ├── visibility.rs
│       ├── volatile_composites.rs
│       ├── wildcard_imports.rs
│       ├── write/
│       │   ├── empty_string.rs
│       │   ├── literal.rs
│       │   ├── mod.rs
│       │   ├── use_debug.rs
│       │   └── with_newline.rs
│       ├── zero_div_zero.rs
│       ├── zero_repeat_side_effects.rs
│       ├── zero_sized_map_values.rs
│       └── zombie_processes.rs
├── clippy_lints_internal/
│   ├── Cargo.toml
│   └── src/
│       ├── almost_standard_lint_formulation.rs
│       ├── collapsible_span_lint_calls.rs
│       ├── derive_deserialize_allowing_unknown.rs
│       ├── internal_paths.rs
│       ├── lib.rs
│       ├── lint_without_lint_pass.rs
│       ├── msrv_attr_impl.rs
│       ├── outer_expn_data_pass.rs
│       ├── produce_ice.rs
│       ├── repeated_is_diagnostic_item.rs
│       ├── symbols.rs
│       ├── unnecessary_def_path.rs
│       ├── unsorted_clippy_utils_paths.rs
│       └── unusual_names.rs
├── clippy_test_deps/
│   ├── Cargo.lock
│   ├── Cargo.toml
│   └── src/
│       └── main.rs
├── clippy_utils/
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       ├── ast_utils/
│       │   ├── ident_iter.rs
│       │   └── mod.rs
│       ├── attrs.rs
│       ├── check_proc_macro.rs
│       ├── comparisons.rs
│       ├── consts.rs
│       ├── diagnostics.rs
│       ├── eager_or_lazy.rs
│       ├── higher.rs
│       ├── hir_utils.rs
│       ├── lib.rs
│       ├── macros.rs
│       ├── mir/
│       │   ├── mod.rs
│       │   ├── possible_borrower.rs
│       │   ├── possible_origin.rs
│       │   └── transitive_relation.rs
│       ├── msrvs.rs
│       ├── numeric_literal.rs
│       ├── paths.rs
│       ├── qualify_min_const_fn.rs
│       ├── res.rs
│       ├── source.rs
│       ├── str_utils.rs
│       ├── sugg.rs
│       ├── sym.rs
│       ├── ty/
│       │   ├── mod.rs
│       │   └── type_certainty/
│       │       ├── certainty.rs
│       │       └── mod.rs
│       ├── usage.rs
│       └── visitors.rs
├── declare_clippy_lint/
│   ├── Cargo.toml
│   └── src/
│       └── lib.rs
├── etc/
│   └── relicense/
│       ├── RELICENSE_DOCUMENTATION.md
│       ├── contributors.txt
│       └── relicense_comments.txt
├── lintcheck/
│   ├── Cargo.toml
│   ├── README.md
│   ├── ci-config/
│   │   └── clippy.toml
│   ├── ci_crates.toml
│   ├── lintcheck_crates.toml
│   ├── src/
│   │   ├── config.rs
│   │   ├── driver.rs
│   │   ├── input.rs
│   │   ├── json.rs
│   │   ├── main.rs
│   │   ├── output.rs
│   │   ├── popular_crates.rs
│   │   └── recursive.rs
│   └── test_sources.toml
├── rust-toolchain.toml
├── rustc_tools_util/
│   ├── CHANGELOG.md
│   ├── Cargo.toml
│   ├── README.md
│   └── src/
│       └── lib.rs
├── rustfmt.toml
├── src/
│   ├── driver.rs
│   └── main.rs
├── tests/
│   ├── check-fmt.rs
│   ├── clippy.toml
│   ├── compile-test.rs
│   ├── config-consistency.rs
│   ├── config-metadata.rs
│   ├── dogfood.rs
│   ├── integration.rs
│   ├── lint_message_convention.rs
│   ├── missing-test-files.rs
│   ├── no-profile-in-cargo-toml.rs
│   ├── symbols-used.rs
│   ├── test_utils/
│   │   └── mod.rs
│   ├── ui/
│   │   ├── absurd-extreme-comparisons.rs
│   │   ├── absurd-extreme-comparisons.stderr
│   │   ├── allow_attributes.fixed
│   │   ├── allow_attributes.rs
│   │   ├── allow_attributes.stderr
│   │   ├── allow_attributes_without_reason.rs
│   │   ├── allow_attributes_without_reason.stderr
│   │   ├── almost_complete_range.fixed
│   │   ├── almost_complete_range.rs
│   │   ├── almost_complete_range.stderr
│   │   ├── approx_const.rs
│   │   ├── approx_const.stderr
│   │   ├── arc_with_non_send_sync.rs
│   │   ├── arc_with_non_send_sync.stderr
│   │   ├── arithmetic_side_effects.rs
│   │   ├── arithmetic_side_effects.stderr
│   │   ├── as_conversions.rs
│   │   ├── as_conversions.stderr
│   │   ├── as_pointer_underscore.fixed
│   │   ├── as_pointer_underscore.rs
│   │   ├── as_pointer_underscore.stderr
│   │   ├── as_ptr_cast_mut.fixed
│   │   ├── as_ptr_cast_mut.rs
│   │   ├── as_ptr_cast_mut.stderr
│   │   ├── as_ptr_cast_mut_unfixable.rs
│   │   ├── as_ptr_cast_mut_unfixable.stderr
│   │   ├── as_underscore.fixed
│   │   ├── as_underscore.rs
│   │   ├── as_underscore.stderr
│   │   ├── as_underscore_unfixable.rs
│   │   ├── as_underscore_unfixable.stderr
│   │   ├── asm_syntax_not_x86.rs
│   │   ├── asm_syntax_x86.i686.stderr
│   │   ├── asm_syntax_x86.rs
│   │   ├── asm_syntax_x86.stderr
│   │   ├── asm_syntax_x86.x86_64.stderr
│   │   ├── assertions_on_constants.rs
│   │   ├── assertions_on_constants.stderr
│   │   ├── assertions_on_result_states.fixed
│   │   ├── assertions_on_result_states.rs
│   │   ├── assertions_on_result_states.stderr
│   │   ├── assign_ops.fixed
│   │   ├── assign_ops.rs
│   │   ├── assign_ops.stderr
│   │   ├── assigning_clones.fixed
│   │   ├── assigning_clones.rs
│   │   ├── assigning_clones.stderr
│   │   ├── async_yields_async.fixed
│   │   ├── async_yields_async.rs
│   │   ├── async_yields_async.stderr
│   │   ├── attrs.rs
│   │   ├── attrs.stderr
│   │   ├── author/
│   │   │   ├── blocks.rs
│   │   │   ├── blocks.stdout
│   │   │   ├── call.rs
│   │   │   ├── call.stdout
│   │   │   ├── if.rs
│   │   │   ├── if.stdout
│   │   │   ├── issue_3849.rs
│   │   │   ├── issue_3849.stdout
│   │   │   ├── loop.rs
│   │   │   ├── loop.stdout
│   │   │   ├── macro_in_closure.rs
│   │   │   ├── macro_in_closure.stdout
│   │   │   ├── macro_in_loop.rs
│   │   │   ├── macro_in_loop.stdout
│   │   │   ├── matches.rs
│   │   │   ├── matches.stdout
│   │   │   ├── repeat.rs
│   │   │   ├── repeat.stdout
│   │   │   ├── struct.rs
│   │   │   └── struct.stdout
│   │   ├── author.rs
│   │   ├── author.stdout
│   │   ├── auxiliary/
│   │   │   ├── extern_fake_libc.rs
│   │   │   ├── external_consts.rs
│   │   │   ├── external_item.rs
│   │   │   ├── interior_mutable_const.rs
│   │   │   ├── macro_rules.rs
│   │   │   ├── macro_use_helper.rs
│   │   │   ├── non-exhaustive-enum.rs
│   │   │   ├── option_helpers.rs
│   │   │   ├── proc_macro_attr.rs
│   │   │   ├── proc_macro_derive.rs
│   │   │   ├── proc_macro_suspicious_else_formatting.rs
│   │   │   ├── proc_macro_unsafe.rs
│   │   │   ├── proc_macros.rs
│   │   │   ├── test_macro.rs
│   │   │   ├── use_self_macro.rs
│   │   │   └── wildcard_imports_helper.rs
│   │   ├── await_holding_lock.rs
│   │   ├── await_holding_lock.stderr
│   │   ├── await_holding_refcell_ref.rs
│   │   ├── await_holding_refcell_ref.stderr
│   │   ├── bind_instead_of_map.fixed
│   │   ├── bind_instead_of_map.rs
│   │   ├── bind_instead_of_map.stderr
│   │   ├── bind_instead_of_map_multipart.fixed
│   │   ├── bind_instead_of_map_multipart.rs
│   │   ├── bind_instead_of_map_multipart.stderr
│   │   ├── bit_masks.rs
│   │   ├── bit_masks.stderr
│   │   ├── blanket_clippy_restriction_lints.rs
│   │   ├── blanket_clippy_restriction_lints.stderr
│   │   ├── blocks_in_conditions.fixed
│   │   ├── blocks_in_conditions.rs
│   │   ├── blocks_in_conditions.stderr
│   │   ├── blocks_in_conditions_2021.fixed
│   │   ├── blocks_in_conditions_2021.rs
│   │   ├── blocks_in_conditions_2021.stderr
│   │   ├── bool_assert_comparison.fixed
│   │   ├── bool_assert_comparison.rs
│   │   ├── bool_assert_comparison.stderr
│   │   ├── bool_comparison.fixed
│   │   ├── bool_comparison.rs
│   │   ├── bool_comparison.stderr
│   │   ├── bool_to_int_with_if.fixed
│   │   ├── bool_to_int_with_if.rs
│   │   ├── bool_to_int_with_if.stderr
│   │   ├── borrow_and_ref_as_ptr.fixed
│   │   ├── borrow_and_ref_as_ptr.rs
│   │   ├── borrow_and_ref_as_ptr.stderr
│   │   ├── borrow_as_ptr.fixed
│   │   ├── borrow_as_ptr.rs
│   │   ├── borrow_as_ptr.stderr
│   │   ├── borrow_as_ptr_no_std.fixed
│   │   ├── borrow_as_ptr_no_std.rs
│   │   ├── borrow_as_ptr_no_std.stderr
│   │   ├── borrow_as_ptr_raw_ref.fixed
│   │   ├── borrow_as_ptr_raw_ref.rs
│   │   ├── borrow_as_ptr_raw_ref.stderr
│   │   ├── borrow_box.fixed
│   │   ├── borrow_box.rs
│   │   ├── borrow_box.stderr
│   │   ├── borrow_deref_ref.fixed
│   │   ├── borrow_deref_ref.rs
│   │   ├── borrow_deref_ref.stderr
│   │   ├── borrow_deref_ref_unfixable.rs
│   │   ├── borrow_deref_ref_unfixable.stderr
│   │   ├── borrow_interior_mutable_const.rs
│   │   ├── borrow_interior_mutable_const.stderr
│   │   ├── box_collection.rs
│   │   ├── box_collection.stderr
│   │   ├── box_default.fixed
│   │   ├── box_default.rs
│   │   ├── box_default.stderr
│   │   ├── box_default_no_std.rs
│   │   ├── boxed_local.rs
│   │   ├── boxed_local.stderr
│   │   ├── branches_sharing_code/
│   │   │   ├── false_positives.rs
│   │   │   ├── shared_at_bottom.rs
│   │   │   ├── shared_at_bottom.stderr
│   │   │   ├── shared_at_top.rs
│   │   │   ├── shared_at_top.stderr
│   │   │   ├── shared_at_top_and_bottom.rs
│   │   │   ├── shared_at_top_and_bottom.stderr
│   │   │   ├── valid_if_blocks.rs
│   │   │   └── valid_if_blocks.stderr
│   │   ├── builtin_type_shadow.rs
│   │   ├── builtin_type_shadow.stderr
│   │   ├── byte_char_slices.fixed
│   │   ├── byte_char_slices.rs
│   │   ├── byte_char_slices.stderr
│   │   ├── bytecount.rs
│   │   ├── bytecount.stderr
│   │   ├── bytes_count_to_len.fixed
│   │   ├── bytes_count_to_len.rs
│   │   ├── bytes_count_to_len.stderr
│   │   ├── bytes_nth.fixed
│   │   ├── bytes_nth.rs
│   │   ├── bytes_nth.stderr
│   │   ├── case_sensitive_file_extension_comparisons.fixed
│   │   ├── case_sensitive_file_extension_comparisons.rs
│   │   ├── case_sensitive_file_extension_comparisons.stderr
│   │   ├── cast.rs
│   │   ├── cast.stderr
│   │   ├── cast_abs_to_unsigned.fixed
│   │   ├── cast_abs_to_unsigned.rs
│   │   ├── cast_abs_to_unsigned.stderr
│   │   ├── cast_alignment.rs
│   │   ├── cast_alignment.stderr
│   │   ├── cast_enum_constructor.rs
│   │   ├── cast_enum_constructor.stderr
│   │   ├── cast_lossless_bool.fixed
│   │   ├── cast_lossless_bool.rs
│   │   ├── cast_lossless_bool.stderr
│   │   ├── cast_lossless_float.fixed
│   │   ├── cast_lossless_float.rs
│   │   ├── cast_lossless_float.stderr
│   │   ├── cast_lossless_integer.fixed
│   │   ├── cast_lossless_integer.rs
│   │   ├── cast_lossless_integer.stderr
│   │   ├── cast_lossless_integer_unfixable.rs
│   │   ├── cast_nan_to_int.rs
│   │   ├── cast_nan_to_int.stderr
│   │   ├── cast_raw_slice_pointer_cast.fixed
│   │   ├── cast_raw_slice_pointer_cast.rs
│   │   ├── cast_raw_slice_pointer_cast.stderr
│   │   ├── cast_raw_slice_pointer_cast_no_std.fixed
│   │   ├── cast_raw_slice_pointer_cast_no_std.rs
│   │   ├── cast_raw_slice_pointer_cast_no_std.stderr
│   │   ├── cast_size.r32bit.stderr
│   │   ├── cast_size.r64bit.stderr
│   │   ├── cast_size.rs
│   │   ├── cast_slice_different_sizes.rs
│   │   ├── cast_slice_different_sizes.stderr
│   │   ├── cfg_attr_cargo_clippy.fixed
│   │   ├── cfg_attr_cargo_clippy.rs
│   │   ├── cfg_attr_cargo_clippy.stderr
│   │   ├── cfg_attr_rustfmt.fixed
│   │   ├── cfg_attr_rustfmt.rs
│   │   ├── cfg_attr_rustfmt.stderr
│   │   ├── cfg_not_test.rs
│   │   ├── cfg_not_test.stderr
│   │   ├── char_indices_as_byte_indices.fixed
│   │   ├── char_indices_as_byte_indices.rs
│   │   ├── char_indices_as_byte_indices.stderr
│   │   ├── char_lit_as_u8.fixed
│   │   ├── char_lit_as_u8.rs
│   │   ├── char_lit_as_u8.stderr
│   │   ├── char_lit_as_u8_unfixable.rs
│   │   ├── char_lit_as_u8_unfixable.stderr
│   │   ├── checked_conversions.fixed
│   │   ├── checked_conversions.rs
│   │   ├── checked_conversions.stderr
│   │   ├── checked_unwrap/
│   │   │   ├── complex_conditionals.rs
│   │   │   ├── complex_conditionals.stderr
│   │   │   ├── complex_conditionals_nested.rs
│   │   │   ├── complex_conditionals_nested.stderr
│   │   │   ├── if_let_chains.rs
│   │   │   ├── if_let_chains.stderr
│   │   │   ├── simple_conditionals.rs
│   │   │   └── simple_conditionals.stderr
│   │   ├── clear_with_drain.fixed
│   │   ├── clear_with_drain.rs
│   │   ├── clear_with_drain.stderr
│   │   ├── clone_on_copy.fixed
│   │   ├── clone_on_copy.rs
│   │   ├── clone_on_copy.stderr
│   │   ├── clone_on_copy_impl.rs
│   │   ├── clone_on_ref_ptr.fixed
│   │   ├── clone_on_ref_ptr.rs
│   │   ├── clone_on_ref_ptr.stderr
│   │   ├── cloned_instead_of_copied.fixed
│   │   ├── cloned_instead_of_copied.rs
│   │   ├── cloned_instead_of_copied.stderr
│   │   ├── cloned_ref_to_slice_refs.fixed
│   │   ├── cloned_ref_to_slice_refs.rs
│   │   ├── cloned_ref_to_slice_refs.stderr
│   │   ├── cmp_null.fixed
│   │   ├── cmp_null.rs
│   │   ├── cmp_null.stderr
│   │   ├── cmp_owned/
│   │   │   ├── asymmetric_partial_eq.fixed
│   │   │   ├── asymmetric_partial_eq.rs
│   │   │   ├── asymmetric_partial_eq.stderr
│   │   │   ├── comparison_flip.fixed
│   │   │   ├── comparison_flip.rs
│   │   │   ├── comparison_flip.stderr
│   │   │   ├── with_suggestion.fixed
│   │   │   ├── with_suggestion.rs
│   │   │   ├── with_suggestion.stderr
│   │   │   ├── without_suggestion.rs
│   │   │   └── without_suggestion.stderr
│   │   ├── coerce_container_to_any.fixed
│   │   ├── coerce_container_to_any.rs
│   │   ├── coerce_container_to_any.stderr
│   │   ├── cognitive_complexity.rs
│   │   ├── cognitive_complexity.stderr
│   │   ├── cognitive_complexity_attr_used.rs
│   │   ├── cognitive_complexity_attr_used.stderr
│   │   ├── collapsible_else_if.fixed
│   │   ├── collapsible_else_if.rs
│   │   ├── collapsible_else_if.stderr
│   │   ├── collapsible_else_if_unfixable.rs
│   │   ├── collapsible_else_if_unfixable.stderr
│   │   ├── collapsible_if.fixed
│   │   ├── collapsible_if.rs
│   │   ├── collapsible_if.stderr
│   │   ├── collapsible_if_let_chains.edition2024.fixed
│   │   ├── collapsible_if_let_chains.edition2024.stderr
│   │   ├── collapsible_if_let_chains.rs
│   │   ├── collapsible_if_unfixable.rs
│   │   ├── collapsible_if_unfixable.stderr
│   │   ├── collapsible_match.rs
│   │   ├── collapsible_match.stderr
│   │   ├── collapsible_match2.rs
│   │   ├── collapsible_match2.stderr
│   │   ├── collapsible_match_fixable.fixed
│   │   ├── collapsible_match_fixable.rs
│   │   ├── collapsible_match_fixable.stderr
│   │   ├── collapsible_str_replace.fixed
│   │   ├── collapsible_str_replace.rs
│   │   ├── collapsible_str_replace.stderr
│   │   ├── collection_is_never_read.rs
│   │   ├── collection_is_never_read.stderr
│   │   ├── comparison_chain.rs
│   │   ├── comparison_chain.stderr
│   │   ├── comparison_to_empty.fixed
│   │   ├── comparison_to_empty.rs
│   │   ├── comparison_to_empty.stderr
│   │   ├── confusing_method_to_numeric_cast.fixed
│   │   ├── confusing_method_to_numeric_cast.rs
│   │   ├── confusing_method_to_numeric_cast.stderr
│   │   ├── const_comparisons.rs
│   │   ├── const_comparisons.stderr
│   │   ├── const_is_empty.rs
│   │   ├── const_is_empty.stderr
│   │   ├── copy_iterator.rs
│   │   ├── copy_iterator.stderr
│   │   ├── crashes/
│   │   │   ├── associated-constant-ice.rs
│   │   │   ├── auxiliary/
│   │   │   │   ├── ice-4727-aux.rs
│   │   │   │   ├── ice-7272-aux.rs
│   │   │   │   ├── ice-7868-aux.rs
│   │   │   │   ├── ice-7934-aux.rs
│   │   │   │   ├── ice-8681-aux.rs
│   │   │   │   ├── proc_macro_crash.rs
│   │   │   │   └── use_self_macro.rs
│   │   │   ├── cc_seme.rs
│   │   │   ├── elidable_lifetime_names_impl_trait.fixed
│   │   │   ├── elidable_lifetime_names_impl_trait.rs
│   │   │   ├── elidable_lifetime_names_impl_trait.stderr
│   │   │   ├── enum-glob-import-crate.rs
│   │   │   ├── ice-10148.rs
│   │   │   ├── ice-10148.stderr
│   │   │   ├── ice-10508a.rs
│   │   │   ├── ice-10508b.rs
│   │   │   ├── ice-10508c.rs
│   │   │   ├── ice-10912.rs
│   │   │   ├── ice-10912.stderr
│   │   │   ├── ice-11065.rs
│   │   │   ├── ice-11230.fixed
│   │   │   ├── ice-11230.rs
│   │   │   ├── ice-11230.stderr
│   │   │   ├── ice-11337.rs
│   │   │   ├── ice-11422.fixed
│   │   │   ├── ice-11422.rs
│   │   │   ├── ice-11422.stderr
│   │   │   ├── ice-11755.rs
│   │   │   ├── ice-11803.rs
│   │   │   ├── ice-11803.stderr
│   │   │   ├── ice-11939.rs
│   │   │   ├── ice-12253.rs
│   │   │   ├── ice-12491.fixed
│   │   │   ├── ice-12491.rs
│   │   │   ├── ice-12491.stderr
│   │   │   ├── ice-12585.rs
│   │   │   ├── ice-12616.fixed
│   │   │   ├── ice-12616.rs
│   │   │   ├── ice-12616.stderr
│   │   │   ├── ice-12979.1.fixed
│   │   │   ├── ice-12979.2.fixed
│   │   │   ├── ice-12979.rs
│   │   │   ├── ice-12979.stderr
│   │   │   ├── ice-13544-original.rs
│   │   │   ├── ice-13544-reduced.rs
│   │   │   ├── ice-13862.rs
│   │   │   ├── ice-14303.rs
│   │   │   ├── ice-14325.rs
│   │   │   ├── ice-14935.rs
│   │   │   ├── ice-15657.rs
│   │   │   ├── ice-15666.fixed
│   │   │   ├── ice-15666.rs
│   │   │   ├── ice-15666.stderr
│   │   │   ├── ice-15684.rs
│   │   │   ├── ice-15684.stderr
│   │   │   ├── ice-1588.rs
│   │   │   ├── ice-1782.rs
│   │   │   ├── ice-1969.rs
│   │   │   ├── ice-2499.rs
│   │   │   ├── ice-2594.rs
│   │   │   ├── ice-2727.rs
│   │   │   ├── ice-2760.rs
│   │   │   ├── ice-2774.fixed
│   │   │   ├── ice-2774.rs
│   │   │   ├── ice-2774.stderr
│   │   │   ├── ice-2862.rs
│   │   │   ├── ice-2865.rs
│   │   │   ├── ice-3151.rs
│   │   │   ├── ice-3462.rs
│   │   │   ├── ice-360.rs
│   │   │   ├── ice-360.stderr
│   │   │   ├── ice-3717.fixed
│   │   │   ├── ice-3717.rs
│   │   │   ├── ice-3717.stderr
│   │   │   ├── ice-3741.rs
│   │   │   ├── ice-3747.rs
│   │   │   ├── ice-3891.rs
│   │   │   ├── ice-3891.stderr
│   │   │   ├── ice-3969.rs
│   │   │   ├── ice-3969.stderr
│   │   │   ├── ice-4121.rs
│   │   │   ├── ice-4545.rs
│   │   │   ├── ice-4579.rs
│   │   │   ├── ice-4671.rs
│   │   │   ├── ice-4727.rs
│   │   │   ├── ice-4760.rs
│   │   │   ├── ice-4775.rs
│   │   │   ├── ice-4968.rs
│   │   │   ├── ice-5207.rs
│   │   │   ├── ice-5223.rs
│   │   │   ├── ice-5238.rs
│   │   │   ├── ice-5389.rs
│   │   │   ├── ice-5497.rs
│   │   │   ├── ice-5497.stderr
│   │   │   ├── ice-5579.rs
│   │   │   ├── ice-5835.1.fixed
│   │   │   ├── ice-5835.2.fixed
│   │   │   ├── ice-5835.fixed
│   │   │   ├── ice-5835.rs
│   │   │   ├── ice-5835.stderr
│   │   │   ├── ice-5872.fixed
│   │   │   ├── ice-5872.rs
│   │   │   ├── ice-5872.stderr
│   │   │   ├── ice-5944.rs
│   │   │   ├── ice-6139.rs
│   │   │   ├── ice-6153.rs
│   │   │   ├── ice-6179.rs
│   │   │   ├── ice-6250.fixed
│   │   │   ├── ice-6250.rs
│   │   │   ├── ice-6250.stderr
│   │   │   ├── ice-6251.rs
│   │   │   ├── ice-6251.stderr
│   │   │   ├── ice-6252.rs
│   │   │   ├── ice-6252.stderr
│   │   │   ├── ice-6254.rs
│   │   │   ├── ice-6255.rs
│   │   │   ├── ice-6255.stderr
│   │   │   ├── ice-6256.rs
│   │   │   ├── ice-6256.stderr
│   │   │   ├── ice-6332.rs
│   │   │   ├── ice-6539.rs
│   │   │   ├── ice-6792.rs
│   │   │   ├── ice-6793.rs
│   │   │   ├── ice-6840.rs
│   │   │   ├── ice-700.rs
│   │   │   ├── ice-7012.rs
│   │   │   ├── ice-7126.rs
│   │   │   ├── ice-7169.fixed
│   │   │   ├── ice-7169.rs
│   │   │   ├── ice-7169.stderr
│   │   │   ├── ice-7231.rs
│   │   │   ├── ice-7272.rs
│   │   │   ├── ice-7340.rs
│   │   │   ├── ice-7410.rs
│   │   │   ├── ice-7423.rs
│   │   │   ├── ice-7868.rs
│   │   │   ├── ice-7868.stderr
│   │   │   ├── ice-7869.rs
│   │   │   ├── ice-7869.stderr
│   │   │   ├── ice-7934.rs
│   │   │   ├── ice-8250.fixed
│   │   │   ├── ice-8250.rs
│   │   │   ├── ice-8250.stderr
│   │   │   ├── ice-8386.rs
│   │   │   ├── ice-8681.rs
│   │   │   ├── ice-8821.rs
│   │   │   ├── ice-8850.fixed
│   │   │   ├── ice-8850.rs
│   │   │   ├── ice-8850.stderr
│   │   │   ├── ice-9041.fixed
│   │   │   ├── ice-9041.rs
│   │   │   ├── ice-9041.stderr
│   │   │   ├── ice-9238.rs
│   │   │   ├── ice-9242.rs
│   │   │   ├── ice-9405.rs
│   │   │   ├── ice-9405.stderr
│   │   │   ├── ice-9414.rs
│   │   │   ├── ice-9459.rs
│   │   │   ├── ice-9463.rs
│   │   │   ├── ice-9625.rs
│   │   │   ├── ice-96721.fixed
│   │   │   ├── ice-96721.rs
│   │   │   ├── ice-96721.stderr
│   │   │   ├── ice-9746.rs
│   │   │   ├── ice-rust-107877.rs
│   │   │   ├── ice_exact_size.rs
│   │   │   ├── if_same_then_else.rs
│   │   │   ├── implements-trait.rs
│   │   │   ├── inherent_impl.rs
│   │   │   ├── issue-825.rs
│   │   │   ├── issues_loop_mut_cond.rs
│   │   │   ├── match_same_arms_const.rs
│   │   │   ├── mgca-16691.rs
│   │   │   ├── missing_const_for_fn_14774.fixed
│   │   │   ├── missing_const_for_fn_14774.rs
│   │   │   ├── missing_const_for_fn_14774.stderr
│   │   │   ├── needless_borrow_fp.rs
│   │   │   ├── needless_pass_by_value-w-late-bound.fixed
│   │   │   ├── needless_pass_by_value-w-late-bound.rs
│   │   │   ├── needless_pass_by_value-w-late-bound.stderr
│   │   │   ├── regressions.rs
│   │   │   ├── returns.rs
│   │   │   ├── shadow.rs
│   │   │   ├── single-match-else.rs
│   │   │   ├── third-party/
│   │   │   │   ├── clippy.toml
│   │   │   │   └── conf_allowlisted.rs
│   │   │   ├── trivial_bounds.rs
│   │   │   ├── unreachable-array-or-slice.rs
│   │   │   ├── unreachable-array-or-slice.stderr
│   │   │   └── used_underscore_binding_macro.rs
│   │   ├── crate_in_macro_def.fixed
│   │   ├── crate_in_macro_def.rs
│   │   ├── crate_in_macro_def.stderr
│   │   ├── crate_level_checks/
│   │   │   ├── entrypoint_recursion.rs
│   │   │   ├── entrypoint_recursion.stderr
│   │   │   ├── no_std_main_recursion.rs
│   │   │   ├── no_std_swap.fixed
│   │   │   ├── no_std_swap.rs
│   │   │   ├── no_std_swap.stderr
│   │   │   ├── std_main_recursion.rs
│   │   │   └── std_main_recursion.stderr
│   │   ├── create_dir.fixed
│   │   ├── create_dir.rs
│   │   ├── create_dir.stderr
│   │   ├── dbg_macro/
│   │   │   ├── auxiliary/
│   │   │   │   └── submodule.rs
│   │   │   ├── dbg_macro.fixed
│   │   │   ├── dbg_macro.rs
│   │   │   ├── dbg_macro.stderr
│   │   │   ├── dbg_macro_unfixable.rs
│   │   │   └── dbg_macro_unfixable.stderr
│   │   ├── debug_assert_with_mut_call.rs
│   │   ├── debug_assert_with_mut_call.stderr
│   │   ├── decimal_bitwise_operands.rs
│   │   ├── decimal_bitwise_operands.stderr
│   │   ├── decimal_literal_representation.fixed
│   │   ├── decimal_literal_representation.rs
│   │   ├── decimal_literal_representation.stderr
│   │   ├── declare_interior_mutable_const.rs
│   │   ├── declare_interior_mutable_const.stderr
│   │   ├── def_id_nocore.rs
│   │   ├── def_id_nocore.stderr
│   │   ├── default_constructed_unit_structs.fixed
│   │   ├── default_constructed_unit_structs.rs
│   │   ├── default_constructed_unit_structs.stderr
│   │   ├── default_instead_of_iter_empty.fixed
│   │   ├── default_instead_of_iter_empty.rs
│   │   ├── default_instead_of_iter_empty.stderr
│   │   ├── default_instead_of_iter_empty_no_std.fixed
│   │   ├── default_instead_of_iter_empty_no_std.rs
│   │   ├── default_instead_of_iter_empty_no_std.stderr
│   │   ├── default_numeric_fallback_f64.fixed
│   │   ├── default_numeric_fallback_f64.rs
│   │   ├── default_numeric_fallback_f64.stderr
│   │   ├── default_numeric_fallback_i32.fixed
│   │   ├── default_numeric_fallback_i32.rs
│   │   ├── default_numeric_fallback_i32.stderr
│   │   ├── default_trait_access.fixed
│   │   ├── default_trait_access.rs
│   │   ├── default_trait_access.stderr
│   │   ├── default_union_representation.rs
│   │   ├── default_union_representation.stderr
│   │   ├── deprecated.rs
│   │   ├── deprecated.stderr
│   │   ├── deref_addrof.fixed
│   │   ├── deref_addrof.rs
│   │   ├── deref_addrof.stderr
│   │   ├── deref_addrof_double_trigger.rs
│   │   ├── deref_addrof_double_trigger.stderr
│   │   ├── deref_addrof_macro.rs
│   │   ├── deref_by_slicing.fixed
│   │   ├── deref_by_slicing.rs
│   │   ├── deref_by_slicing.stderr
│   │   ├── derivable_impls.fixed
│   │   ├── derivable_impls.rs
│   │   ├── derivable_impls.stderr
│   │   ├── derivable_impls_derive_const.fixed
│   │   ├── derivable_impls_derive_const.rs
│   │   ├── derivable_impls_derive_const.stderr
│   │   ├── derive.rs
│   │   ├── derive.stderr
│   │   ├── derive_ord_xor_partial_ord.rs
│   │   ├── derive_ord_xor_partial_ord.stderr
│   │   ├── derive_partial_eq_without_eq.fixed
│   │   ├── derive_partial_eq_without_eq.rs
│   │   ├── derive_partial_eq_without_eq.stderr
│   │   ├── derived_hash_with_manual_eq.rs
│   │   ├── derived_hash_with_manual_eq.stderr
│   │   ├── disallowed_names.rs
│   │   ├── disallowed_names.stderr
│   │   ├── disallowed_script_idents.rs
│   │   ├── disallowed_script_idents.stderr
│   │   ├── diverging_sub_expression.rs
│   │   ├── diverging_sub_expression.stderr
│   │   ├── doc/
│   │   │   ├── doc-fixable.fixed
│   │   │   ├── doc-fixable.rs
│   │   │   ├── doc-fixable.stderr
│   │   │   ├── doc_comment_double_space_linebreaks.fixed
│   │   │   ├── doc_comment_double_space_linebreaks.rs
│   │   │   ├── doc_comment_double_space_linebreaks.stderr
│   │   │   ├── doc_include_without_cfg.fixed
│   │   │   ├── doc_include_without_cfg.rs
│   │   │   ├── doc_include_without_cfg.stderr
│   │   │   ├── doc_lazy_blockquote.fixed
│   │   │   ├── doc_lazy_blockquote.rs
│   │   │   ├── doc_lazy_blockquote.stderr
│   │   │   ├── doc_lazy_list.fixed
│   │   │   ├── doc_lazy_list.rs
│   │   │   ├── doc_lazy_list.stderr
│   │   │   ├── doc_markdown-issue_13097.fixed
│   │   │   ├── doc_markdown-issue_13097.rs
│   │   │   ├── doc_markdown-issue_13097.stderr
│   │   │   ├── doc_nested_refdef_blockquote.fixed
│   │   │   ├── doc_nested_refdef_blockquote.rs
│   │   │   ├── doc_nested_refdef_blockquote.stderr
│   │   │   ├── doc_nested_refdef_list_item.fixed
│   │   │   ├── doc_nested_refdef_list_item.rs
│   │   │   ├── doc_nested_refdef_list_item.stderr
│   │   │   ├── doc_overindented_list_items.fixed
│   │   │   ├── doc_overindented_list_items.rs
│   │   │   ├── doc_overindented_list_items.stderr
│   │   │   ├── doc_paragraphs_missing_punctuation.fixed
│   │   │   ├── doc_paragraphs_missing_punctuation.rs
│   │   │   ├── doc_paragraphs_missing_punctuation.stderr
│   │   │   ├── doc_paragraphs_missing_punctuation_emoji.rs
│   │   │   ├── doc_paragraphs_missing_punctuation_emoji.stderr
│   │   │   ├── doc_paragraphs_missing_punctuation_unfixable.rs
│   │   │   ├── doc_paragraphs_missing_punctuation_unfixable.stderr
│   │   │   ├── footnote_issue_13183.rs
│   │   │   ├── issue_10262.fixed
│   │   │   ├── issue_10262.rs
│   │   │   ├── issue_10262.stderr
│   │   │   ├── issue_12795.fixed
│   │   │   ├── issue_12795.rs
│   │   │   ├── issue_12795.stderr
│   │   │   ├── issue_1832.rs
│   │   │   ├── issue_902.rs
│   │   │   ├── issue_9473.fixed
│   │   │   ├── issue_9473.rs
│   │   │   ├── issue_9473.stderr
│   │   │   ├── link_adjacent.fixed
│   │   │   ├── link_adjacent.rs
│   │   │   ├── link_adjacent.stderr
│   │   │   ├── needless_doctest_main.rs
│   │   │   ├── needless_doctest_main.stderr
│   │   │   ├── unbalanced_ticks.rs
│   │   │   └── unbalanced_ticks.stderr
│   │   ├── doc_broken_link.rs
│   │   ├── doc_broken_link.stderr
│   │   ├── doc_errors.rs
│   │   ├── doc_errors.stderr
│   │   ├── doc_link_with_quotes.rs
│   │   ├── doc_link_with_quotes.stderr
│   │   ├── doc_suspicious_footnotes.fixed
│   │   ├── doc_suspicious_footnotes.rs
│   │   ├── doc_suspicious_footnotes.stderr
│   │   ├── doc_suspicious_footnotes_include.rs
│   │   ├── doc_suspicious_footnotes_include.stderr
│   │   ├── doc_suspicious_footnotes_include.txt
│   │   ├── doc_unsafe.rs
│   │   ├── doc_unsafe.stderr
│   │   ├── double_comparison.fixed
│   │   ├── double_comparison.rs
│   │   ├── double_comparison.stderr
│   │   ├── double_ended_iterator_last.fixed
│   │   ├── double_ended_iterator_last.rs
│   │   ├── double_ended_iterator_last.stderr
│   │   ├── double_must_use.rs
│   │   ├── double_must_use.stderr
│   │   ├── double_parens.fixed
│   │   ├── double_parens.rs
│   │   ├── double_parens.stderr
│   │   ├── drain_collect.fixed
│   │   ├── drain_collect.rs
│   │   ├── drain_collect.stderr
│   │   ├── drain_collect_nostd.fixed
│   │   ├── drain_collect_nostd.rs
│   │   ├── drain_collect_nostd.stderr
│   │   ├── drop_non_drop.rs
│   │   ├── drop_non_drop.stderr
│   │   ├── duplicate_underscore_argument.rs
│   │   ├── duplicate_underscore_argument.stderr
│   │   ├── duplicated_attributes.rs
│   │   ├── duplicated_attributes.stderr
│   │   ├── duration_suboptimal_units.fixed
│   │   ├── duration_suboptimal_units.rs
│   │   ├── duration_suboptimal_units.stderr
│   │   ├── duration_suboptimal_units_days_weeks.fixed
│   │   ├── duration_suboptimal_units_days_weeks.rs
│   │   ├── duration_suboptimal_units_days_weeks.stderr
│   │   ├── duration_subsec.fixed
│   │   ├── duration_subsec.rs
│   │   ├── duration_subsec.stderr
│   │   ├── eager_transmute.fixed
│   │   ├── eager_transmute.rs
│   │   ├── eager_transmute.stderr
│   │   ├── elidable_lifetime_names.fixed
│   │   ├── elidable_lifetime_names.rs
│   │   ├── elidable_lifetime_names.stderr
│   │   ├── else_if_without_else.rs
│   │   ├── else_if_without_else.stderr
│   │   ├── empty_docs.rs
│   │   ├── empty_docs.stderr
│   │   ├── empty_drop.fixed
│   │   ├── empty_drop.rs
│   │   ├── empty_drop.stderr
│   │   ├── empty_enum_variants_with_brackets.fixed
│   │   ├── empty_enum_variants_with_brackets.rs
│   │   ├── empty_enum_variants_with_brackets.stderr
│   │   ├── empty_enums.rs
│   │   ├── empty_enums.stderr
│   │   ├── empty_enums_without_never_type.rs
│   │   ├── empty_line_after/
│   │   │   ├── doc_comments.1.fixed
│   │   │   ├── doc_comments.2.fixed
│   │   │   ├── doc_comments.rs
│   │   │   ├── doc_comments.stderr
│   │   │   ├── outer_attribute.1.fixed
│   │   │   ├── outer_attribute.2.fixed
│   │   │   ├── outer_attribute.rs
│   │   │   └── outer_attribute.stderr
│   │   ├── empty_loop.rs
│   │   ├── empty_loop.stderr
│   │   ├── empty_loop_intrinsic.rs
│   │   ├── empty_loop_no_std.rs
│   │   ├── empty_loop_no_std.stderr
│   │   ├── empty_structs_with_brackets.fixed
│   │   ├── empty_structs_with_brackets.rs
│   │   ├── empty_structs_with_brackets.stderr
│   │   ├── endian_bytes.rs
│   │   ├── endian_bytes.stderr
│   │   ├── entry.fixed
│   │   ├── entry.rs
│   │   ├── entry.stderr
│   │   ├── entry_btree.fixed
│   │   ├── entry_btree.rs
│   │   ├── entry_btree.stderr
│   │   ├── entry_unfixable.rs
│   │   ├── entry_unfixable.stderr
│   │   ├── entry_with_else.fixed
│   │   ├── entry_with_else.rs
│   │   ├── entry_with_else.stderr
│   │   ├── enum_clike_unportable_variant.rs
│   │   ├── enum_clike_unportable_variant.stderr
│   │   ├── enum_glob_use.fixed
│   │   ├── enum_glob_use.rs
│   │   ├── enum_glob_use.stderr
│   │   ├── enum_variants.rs
│   │   ├── enum_variants.stderr
│   │   ├── eprint_with_newline.fixed
│   │   ├── eprint_with_newline.rs
│   │   ├── eprint_with_newline.stderr
│   │   ├── eq_op.rs
│   │   ├── eq_op.stderr
│   │   ├── eq_op_macros.rs
│   │   ├── eq_op_macros.stderr
│   │   ├── equatable_if_let.fixed
│   │   ├── equatable_if_let.rs
│   │   ├── equatable_if_let.stderr
│   │   ├── equatable_if_let_const_cmp.fixed
│   │   ├── equatable_if_let_const_cmp.rs
│   │   ├── equatable_if_let_const_cmp.stderr
│   │   ├── erasing_op.rs
│   │   ├── erasing_op.stderr
│   │   ├── err_expect.fixed
│   │   ├── err_expect.rs
│   │   ├── err_expect.stderr
│   │   ├── error_impl_error.rs
│   │   ├── error_impl_error.stderr
│   │   ├── eta.fixed
│   │   ├── eta.rs
│   │   ├── eta.stderr
│   │   ├── eta_nostd.fixed
│   │   ├── eta_nostd.rs
│   │   ├── eta_nostd.stderr
│   │   ├── excessive_precision.fixed
│   │   ├── excessive_precision.rs
│   │   ├── excessive_precision.stderr
│   │   ├── exhaustive_items.fixed
│   │   ├── exhaustive_items.rs
│   │   ├── exhaustive_items.stderr
│   │   ├── exit1.rs
│   │   ├── exit1.stderr
│   │   ├── exit1_compile_flag_test.rs
│   │   ├── exit1_compile_flag_test.stderr
│   │   ├── exit2.rs
│   │   ├── exit2.stderr
│   │   ├── exit2_compile_flag_test.rs
│   │   ├── exit2_compile_flag_test.stderr
│   │   ├── exit3.rs
│   │   ├── exit3_compile_flag_test.rs
│   │   ├── exit4.rs
│   │   ├── expect.rs
│   │   ├── expect.stderr
│   │   ├── expect_fun_call.fixed
│   │   ├── expect_fun_call.rs
│   │   ├── expect_fun_call.stderr
│   │   ├── expect_tool_lint_rfc_2383.rs
│   │   ├── expect_tool_lint_rfc_2383.stderr
│   │   ├── explicit_auto_deref.fixed
│   │   ├── explicit_auto_deref.rs
│   │   ├── explicit_auto_deref.stderr
│   │   ├── explicit_counter_loop.rs
│   │   ├── explicit_counter_loop.stderr
│   │   ├── explicit_deref_methods.fixed
│   │   ├── explicit_deref_methods.rs
│   │   ├── explicit_deref_methods.stderr
│   │   ├── explicit_into_iter_loop.fixed
│   │   ├── explicit_into_iter_loop.rs
│   │   ├── explicit_into_iter_loop.stderr
│   │   ├── explicit_iter_loop.fixed
│   │   ├── explicit_iter_loop.rs
│   │   ├── explicit_iter_loop.stderr
│   │   ├── explicit_write.fixed
│   │   ├── explicit_write.rs
│   │   ├── explicit_write.stderr
│   │   ├── explicit_write_in_test.rs
│   │   ├── extend_with_drain.fixed
│   │   ├── extend_with_drain.rs
│   │   ├── extend_with_drain.stderr
│   │   ├── extra_unused_lifetimes.rs
│   │   ├── extra_unused_lifetimes.stderr
│   │   ├── extra_unused_type_parameters.fixed
│   │   ├── extra_unused_type_parameters.rs
│   │   ├── extra_unused_type_parameters.stderr
│   │   ├── extra_unused_type_parameters_unfixable.rs
│   │   ├── extra_unused_type_parameters_unfixable.stderr
│   │   ├── fallible_impl_from.rs
│   │   ├── fallible_impl_from.stderr
│   │   ├── field_reassign_with_default.rs
│   │   ├── field_reassign_with_default.stderr
│   │   ├── field_scoped_visibility_modifiers.rs
│   │   ├── field_scoped_visibility_modifiers.stderr
│   │   ├── filetype_is_file.rs
│   │   ├── filetype_is_file.stderr
│   │   ├── filter_map_bool_then.fixed
│   │   ├── filter_map_bool_then.rs
│   │   ├── filter_map_bool_then.stderr
│   │   ├── filter_map_bool_then_unfixable.rs
│   │   ├── filter_map_bool_then_unfixable.stderr
│   │   ├── filter_map_identity.fixed
│   │   ├── filter_map_identity.rs
│   │   ├── filter_map_identity.stderr
│   │   ├── filter_map_next.rs
│   │   ├── filter_map_next.stderr
│   │   ├── filter_map_next_fixable.fixed
│   │   ├── filter_map_next_fixable.rs
│   │   ├── filter_map_next_fixable.stderr
│   │   ├── find_map.rs
│   │   ├── flat_map_identity.fixed
│   │   ├── flat_map_identity.rs
│   │   ├── flat_map_identity.stderr
│   │   ├── flat_map_option.fixed
│   │   ├── flat_map_option.rs
│   │   ├── flat_map_option.stderr
│   │   ├── float_arithmetic.rs
│   │   ├── float_arithmetic.stderr
│   │   ├── float_cmp.rs
│   │   ├── float_cmp.stderr
│   │   ├── float_cmp_const.rs
│   │   ├── float_cmp_const.stderr
│   │   ├── float_equality_without_abs.rs
│   │   ├── float_equality_without_abs.stderr
│   │   ├── floating_point_abs.fixed
│   │   ├── floating_point_abs.rs
│   │   ├── floating_point_abs.stderr
│   │   ├── floating_point_arithmetic_nostd.rs
│   │   ├── floating_point_exp.fixed
│   │   ├── floating_point_exp.rs
│   │   ├── floating_point_exp.stderr
│   │   ├── floating_point_hypot.fixed
│   │   ├── floating_point_hypot.rs
│   │   ├── floating_point_hypot.stderr
│   │   ├── floating_point_log.fixed
│   │   ├── floating_point_log.rs
│   │   ├── floating_point_log.stderr
│   │   ├── floating_point_logbase.fixed
│   │   ├── floating_point_logbase.rs
│   │   ├── floating_point_logbase.stderr
│   │   ├── floating_point_mul_add.fixed
│   │   ├── floating_point_mul_add.rs
│   │   ├── floating_point_mul_add.stderr
│   │   ├── floating_point_powf.fixed
│   │   ├── floating_point_powf.rs
│   │   ├── floating_point_powf.stderr
│   │   ├── floating_point_powi.fixed
│   │   ├── floating_point_powi.rs
│   │   ├── floating_point_powi.stderr
│   │   ├── floating_point_rad.fixed
│   │   ├── floating_point_rad.rs
│   │   ├── floating_point_rad.stderr
│   │   ├── fn_params_excessive_bools.rs
│   │   ├── fn_params_excessive_bools.stderr
│   │   ├── fn_to_numeric_cast.r32bit.stderr
│   │   ├── fn_to_numeric_cast.r64bit.stderr
│   │   ├── fn_to_numeric_cast.rs
│   │   ├── fn_to_numeric_cast_any.rs
│   │   ├── fn_to_numeric_cast_any.stderr
│   │   ├── for_kv_map.fixed
│   │   ├── for_kv_map.rs
│   │   ├── for_kv_map.stderr
│   │   ├── forget_non_drop.rs
│   │   ├── forget_non_drop.stderr
│   │   ├── format.fixed
│   │   ├── format.rs
│   │   ├── format.stderr
│   │   ├── format_args.fixed
│   │   ├── format_args.rs
│   │   ├── format_args.stderr
│   │   ├── format_args_unfixable.rs
│   │   ├── format_args_unfixable.stderr
│   │   ├── format_collect.rs
│   │   ├── format_collect.stderr
│   │   ├── format_push_string.fixed
│   │   ├── format_push_string.rs
│   │   ├── format_push_string.stderr
│   │   ├── format_push_string_no_core.rs
│   │   ├── format_push_string_no_std.fixed
│   │   ├── format_push_string_no_std.rs
│   │   ├── format_push_string_no_std.stderr
│   │   ├── format_push_string_no_std_unfixable.rs
│   │   ├── format_push_string_no_std_unfixable.stderr
│   │   ├── format_push_string_unfixable.rs
│   │   ├── format_push_string_unfixable.stderr
│   │   ├── formatting.rs
│   │   ├── formatting.stderr
│   │   ├── four_forward_slashes.fixed
│   │   ├── four_forward_slashes.rs
│   │   ├── four_forward_slashes.stderr
│   │   ├── four_forward_slashes_bare_cr.rs
│   │   ├── four_forward_slashes_bare_cr.stderr
│   │   ├── four_forward_slashes_first_line.fixed
│   │   ├── four_forward_slashes_first_line.rs
│   │   ├── four_forward_slashes_first_line.stderr
│   │   ├── from_iter_instead_of_collect.fixed
│   │   ├── from_iter_instead_of_collect.rs
│   │   ├── from_iter_instead_of_collect.stderr
│   │   ├── from_over_into.fixed
│   │   ├── from_over_into.rs
│   │   ├── from_over_into.stderr
│   │   ├── from_over_into_unfixable.rs
│   │   ├── from_over_into_unfixable.stderr
│   │   ├── from_raw_with_void_ptr.rs
│   │   ├── from_raw_with_void_ptr.stderr
│   │   ├── from_str_radix_10.fixed
│   │   ├── from_str_radix_10.rs
│   │   ├── from_str_radix_10.stderr
│   │   ├── functions.rs
│   │   ├── functions.stderr
│   │   ├── functions_maxlines.rs
│   │   ├── functions_maxlines.stderr
│   │   ├── future_not_send.rs
│   │   ├── future_not_send.stderr
│   │   ├── get_first.fixed
│   │   ├── get_first.rs
│   │   ├── get_first.stderr
│   │   ├── get_last_with_len.fixed
│   │   ├── get_last_with_len.rs
│   │   ├── get_last_with_len.stderr
│   │   ├── get_unwrap.fixed
│   │   ├── get_unwrap.rs
│   │   ├── get_unwrap.stderr
│   │   ├── identity_op.fixed
│   │   ├── identity_op.rs
│   │   ├── identity_op.stderr
│   │   ├── if_let_mutex.edition2021.stderr
│   │   ├── if_let_mutex.rs
│   │   ├── if_not_else.fixed
│   │   ├── if_not_else.rs
│   │   ├── if_not_else.stderr
│   │   ├── if_not_else_bittest.rs
│   │   ├── if_same_then_else.rs
│   │   ├── if_same_then_else.stderr
│   │   ├── if_same_then_else2.rs
│   │   ├── if_same_then_else2.stderr
│   │   ├── if_then_some_else_none.fixed
│   │   ├── if_then_some_else_none.rs
│   │   ├── if_then_some_else_none.stderr
│   │   ├── if_then_some_else_none_unfixable.rs
│   │   ├── if_then_some_else_none_unfixable.stderr
│   │   ├── ifs_same_cond.rs
│   │   ├── ifs_same_cond.stderr
│   │   ├── ignore_without_reason.rs
│   │   ├── ignore_without_reason.stderr
│   │   ├── ignored_unit_patterns.fixed
│   │   ├── ignored_unit_patterns.rs
│   │   ├── ignored_unit_patterns.stderr
│   │   ├── impl.rs
│   │   ├── impl.stderr
│   │   ├── impl_hash_with_borrow_str_and_bytes.rs
│   │   ├── impl_hash_with_borrow_str_and_bytes.stderr
│   │   ├── impl_trait_in_params.rs
│   │   ├── impl_trait_in_params.stderr
│   │   ├── implicit_clone.fixed
│   │   ├── implicit_clone.rs
│   │   ├── implicit_clone.stderr
│   │   ├── implicit_hasher.fixed
│   │   ├── implicit_hasher.rs
│   │   ├── implicit_hasher.stderr
│   │   ├── implicit_return.fixed
│   │   ├── implicit_return.rs
│   │   ├── implicit_return.stderr
│   │   ├── implicit_saturating_add.fixed
│   │   ├── implicit_saturating_add.rs
│   │   ├── implicit_saturating_add.stderr
│   │   ├── implicit_saturating_sub.fixed
│   │   ├── implicit_saturating_sub.rs
│   │   ├── implicit_saturating_sub.stderr
│   │   ├── implied_bounds_in_impls.fixed
│   │   ├── implied_bounds_in_impls.rs
│   │   ├── implied_bounds_in_impls.stderr
│   │   ├── incompatible_msrv.rs
│   │   ├── incompatible_msrv.stderr
│   │   ├── inconsistent_digit_grouping.fixed
│   │   ├── inconsistent_digit_grouping.rs
│   │   ├── inconsistent_digit_grouping.stderr
│   │   ├── inconsistent_struct_constructor.fixed
│   │   ├── inconsistent_struct_constructor.rs
│   │   ├── inconsistent_struct_constructor.stderr
│   │   ├── index_refutable_slice/
│   │   │   ├── if_let_slice_binding.fixed
│   │   │   ├── if_let_slice_binding.rs
│   │   │   ├── if_let_slice_binding.stderr
│   │   │   ├── slice_indexing_in_macro.fixed
│   │   │   ├── slice_indexing_in_macro.rs
│   │   │   └── slice_indexing_in_macro.stderr
│   │   ├── indexing_slicing_index.rs
│   │   ├── indexing_slicing_index.stderr
│   │   ├── indexing_slicing_slice.rs
│   │   ├── indexing_slicing_slice.stderr
│   │   ├── ineffective_open_options.fixed
│   │   ├── ineffective_open_options.rs
│   │   ├── ineffective_open_options.stderr
│   │   ├── inefficient_to_string.fixed
│   │   ├── inefficient_to_string.rs
│   │   ├── inefficient_to_string.stderr
│   │   ├── infallible_destructuring_match.fixed
│   │   ├── infallible_destructuring_match.rs
│   │   ├── infallible_destructuring_match.stderr
│   │   ├── infallible_try_from.rs
│   │   ├── infallible_try_from.stderr
│   │   ├── infinite_iter.rs
│   │   ├── infinite_iter.stderr
│   │   ├── infinite_loops.rs
│   │   ├── infinite_loops.stderr
│   │   ├── inherent_to_string.rs
│   │   ├── inherent_to_string.stderr
│   │   ├── init_numbered_fields.fixed
│   │   ├── init_numbered_fields.rs
│   │   ├── init_numbered_fields.stderr
│   │   ├── inline_fn_without_body.fixed
│   │   ├── inline_fn_without_body.rs
│   │   ├── inline_fn_without_body.stderr
│   │   ├── inspect_for_each.rs
│   │   ├── inspect_for_each.stderr
│   │   ├── int_plus_one.fixed
│   │   ├── int_plus_one.rs
│   │   ├── int_plus_one.stderr
│   │   ├── integer_division.rs
│   │   ├── integer_division.stderr
│   │   ├── integer_division_remainder_used.rs
│   │   ├── integer_division_remainder_used.stderr
│   │   ├── into_iter_on_ref.fixed
│   │   ├── into_iter_on_ref.rs
│   │   ├── into_iter_on_ref.stderr
│   │   ├── into_iter_without_iter.rs
│   │   ├── into_iter_without_iter.stderr
│   │   ├── invalid_upcast_comparisons.rs
│   │   ├── invalid_upcast_comparisons.stderr
│   │   ├── io_other_error.fixed
│   │   ├── io_other_error.rs
│   │   ├── io_other_error.stderr
│   │   ├── ip_constant.fixed
│   │   ├── ip_constant.rs
│   │   ├── ip_constant.stderr
│   │   ├── ip_constant_from_external.rs
│   │   ├── ip_constant_from_external.stderr
│   │   ├── is_digit_ascii_radix.fixed
│   │   ├── is_digit_ascii_radix.rs
│   │   ├── is_digit_ascii_radix.stderr
│   │   ├── issue-111399.rs
│   │   ├── issue-3145.rs
│   │   ├── issue-3145.stderr
│   │   ├── issue-7447.rs
│   │   ├── issue-7447.stderr
│   │   ├── issue_2356.fixed
│   │   ├── issue_2356.rs
│   │   ├── issue_2356.stderr
│   │   ├── issue_4266.rs
│   │   ├── issue_4266.stderr
│   │   ├── items_after_statement.rs
│   │   ├── items_after_statement.stderr
│   │   ├── items_after_test_module/
│   │   │   ├── after_proc_macros.rs
│   │   │   ├── auxiliary/
│   │   │   │   ├── submodule.rs
│   │   │   │   └── tests.rs
│   │   │   ├── imported_module.rs
│   │   │   ├── in_submodule.rs
│   │   │   ├── in_submodule.stderr
│   │   │   ├── multiple_modules.rs
│   │   │   ├── root_module.fixed
│   │   │   ├── root_module.rs
│   │   │   └── root_module.stderr
│   │   ├── iter_cloned_collect.fixed
│   │   ├── iter_cloned_collect.rs
│   │   ├── iter_cloned_collect.stderr
│   │   ├── iter_count.fixed
│   │   ├── iter_count.rs
│   │   ├── iter_count.stderr
│   │   ├── iter_filter_is_ok.fixed
│   │   ├── iter_filter_is_ok.rs
│   │   ├── iter_filter_is_ok.stderr
│   │   ├── iter_filter_is_some.fixed
│   │   ├── iter_filter_is_some.rs
│   │   ├── iter_filter_is_some.stderr
│   │   ├── iter_kv_map.fixed
│   │   ├── iter_kv_map.rs
│   │   ├── iter_kv_map.stderr
│   │   ├── iter_next_loop.rs
│   │   ├── iter_next_loop.stderr
│   │   ├── iter_next_slice.fixed
│   │   ├── iter_next_slice.rs
│   │   ├── iter_next_slice.stderr
│   │   ├── iter_not_returning_iterator.rs
│   │   ├── iter_not_returning_iterator.stderr
│   │   ├── iter_nth.fixed
│   │   ├── iter_nth.rs
│   │   ├── iter_nth.stderr
│   │   ├── iter_nth_zero.fixed
│   │   ├── iter_nth_zero.rs
│   │   ├── iter_nth_zero.stderr
│   │   ├── iter_on_empty_collections.fixed
│   │   ├── iter_on_empty_collections.rs
│   │   ├── iter_on_empty_collections.stderr
│   │   ├── iter_on_single_items.fixed
│   │   ├── iter_on_single_items.rs
│   │   ├── iter_on_single_items.stderr
│   │   ├── iter_out_of_bounds.rs
│   │   ├── iter_out_of_bounds.stderr
│   │   ├── iter_over_hash_type.rs
│   │   ├── iter_over_hash_type.stderr
│   │   ├── iter_overeager_cloned.fixed
│   │   ├── iter_overeager_cloned.rs
│   │   ├── iter_overeager_cloned.stderr
│   │   ├── iter_skip_next.fixed
│   │   ├── iter_skip_next.rs
│   │   ├── iter_skip_next.stderr
│   │   ├── iter_skip_next_unfixable.rs
│   │   ├── iter_skip_next_unfixable.stderr
│   │   ├── iter_skip_zero.fixed
│   │   ├── iter_skip_zero.rs
│   │   ├── iter_skip_zero.stderr
│   │   ├── iter_with_drain.fixed
│   │   ├── iter_with_drain.rs
│   │   ├── iter_with_drain.stderr
│   │   ├── iter_without_into_iter.rs
│   │   ├── iter_without_into_iter.stderr
│   │   ├── iterator_step_by_zero.rs
│   │   ├── iterator_step_by_zero.stderr
│   │   ├── join_absolute_paths.1.fixed
│   │   ├── join_absolute_paths.2.fixed
│   │   ├── join_absolute_paths.rs
│   │   ├── join_absolute_paths.stderr
│   │   ├── large_const_arrays.fixed
│   │   ├── large_const_arrays.rs
│   │   ├── large_const_arrays.stderr
│   │   ├── large_digit_groups.fixed
│   │   ├── large_digit_groups.rs
│   │   ├── large_digit_groups.stderr
│   │   ├── large_enum_variant.r32bit.stderr
│   │   ├── large_enum_variant.r64bit.stderr
│   │   ├── large_enum_variant.rs
│   │   ├── large_enum_variant_no_std.rs
│   │   ├── large_enum_variant_no_std.stderr
│   │   ├── large_futures.fixed
│   │   ├── large_futures.rs
│   │   ├── large_futures.stderr
│   │   ├── large_stack_arrays.rs
│   │   ├── large_stack_arrays.stderr
│   │   ├── large_stack_frames.rs
│   │   ├── large_stack_frames.stderr
│   │   ├── large_types_passed_by_value.rs
│   │   ├── large_types_passed_by_value.stderr
│   │   ├── legacy_numeric_constants.fixed
│   │   ├── legacy_numeric_constants.rs
│   │   ├── legacy_numeric_constants.stderr
│   │   ├── legacy_numeric_constants_unfixable.rs
│   │   ├── legacy_numeric_constants_unfixable.stderr
│   │   ├── len_without_is_empty.rs
│   │   ├── len_without_is_empty.stderr
│   │   ├── len_without_is_empty_expect.rs
│   │   ├── len_without_is_empty_expect.stderr
│   │   ├── len_zero.fixed
│   │   ├── len_zero.rs
│   │   ├── len_zero.stderr
│   │   ├── len_zero_ranges.fixed
│   │   ├── len_zero_ranges.rs
│   │   ├── len_zero_ranges.stderr
│   │   ├── len_zero_unstable.fixed
│   │   ├── len_zero_unstable.rs
│   │   ├── len_zero_unstable.stderr
│   │   ├── let_and_return.edition2021.fixed
│   │   ├── let_and_return.edition2021.stderr
│   │   ├── let_and_return.edition2024.fixed
│   │   ├── let_and_return.edition2024.stderr
│   │   ├── let_and_return.fixed
│   │   ├── let_and_return.rs
│   │   ├── let_and_return.stderr
│   │   ├── let_if_seq.rs
│   │   ├── let_if_seq.stderr
│   │   ├── let_underscore_future.rs
│   │   ├── let_underscore_future.stderr
│   │   ├── let_underscore_lock.rs
│   │   ├── let_underscore_lock.stderr
│   │   ├── let_underscore_must_use.rs
│   │   ├── let_underscore_must_use.stderr
│   │   ├── let_underscore_untyped.rs
│   │   ├── let_underscore_untyped.stderr
│   │   ├── let_unit.fixed
│   │   ├── let_unit.rs
│   │   ├── let_unit.stderr
│   │   ├── let_with_type_underscore.fixed
│   │   ├── let_with_type_underscore.rs
│   │   ├── let_with_type_underscore.stderr
│   │   ├── lines_filter_map_ok.fixed
│   │   ├── lines_filter_map_ok.rs
│   │   ├── lines_filter_map_ok.stderr
│   │   ├── linkedlist.rs
│   │   ├── linkedlist.stderr
│   │   ├── literal_string_with_formatting_arg.rs
│   │   ├── literal_string_with_formatting_arg.stderr
│   │   ├── literals.rs
│   │   ├── literals.stderr
│   │   ├── localhost.txt
│   │   ├── lossy_float_literal.fixed
│   │   ├── lossy_float_literal.rs
│   │   ├── lossy_float_literal.stderr
│   │   ├── macro_use_imports.fixed
│   │   ├── macro_use_imports.rs
│   │   ├── macro_use_imports.stderr
│   │   ├── macro_use_imports_expect.rs
│   │   ├── manual_abs_diff.fixed
│   │   ├── manual_abs_diff.rs
│   │   ├── manual_abs_diff.stderr
│   │   ├── manual_arithmetic_check-2.rs
│   │   ├── manual_arithmetic_check-2.stderr
│   │   ├── manual_arithmetic_check.fixed
│   │   ├── manual_arithmetic_check.rs
│   │   ├── manual_arithmetic_check.stderr
│   │   ├── manual_assert.edition2018.fixed
│   │   ├── manual_assert.edition2018.stderr
│   │   ├── manual_assert.edition2021.fixed
│   │   ├── manual_assert.edition2021.stderr
│   │   ├── manual_assert.rs
│   │   ├── manual_async_fn.fixed
│   │   ├── manual_async_fn.rs
│   │   ├── manual_async_fn.stderr
│   │   ├── manual_bits.fixed
│   │   ├── manual_bits.rs
│   │   ├── manual_bits.stderr
│   │   ├── manual_c_str_literals.edition2021.fixed
│   │   ├── manual_c_str_literals.edition2021.stderr
│   │   ├── manual_c_str_literals.rs
│   │   ├── manual_checked_ops.rs
│   │   ├── manual_checked_ops.stderr
│   │   ├── manual_clamp.fixed
│   │   ├── manual_clamp.rs
│   │   ├── manual_clamp.stderr
│   │   ├── manual_contains.fixed
│   │   ├── manual_contains.rs
│   │   ├── manual_contains.stderr
│   │   ├── manual_dangling_ptr.fixed
│   │   ├── manual_dangling_ptr.rs
│   │   ├── manual_dangling_ptr.stderr
│   │   ├── manual_div_ceil.fixed
│   │   ├── manual_div_ceil.rs
│   │   ├── manual_div_ceil.stderr
│   │   ├── manual_div_ceil_with_feature.fixed
│   │   ├── manual_div_ceil_with_feature.rs
│   │   ├── manual_div_ceil_with_feature.stderr
│   │   ├── manual_filter.fixed
│   │   ├── manual_filter.rs
│   │   ├── manual_filter.stderr
│   │   ├── manual_filter_map.fixed
│   │   ├── manual_filter_map.rs
│   │   ├── manual_filter_map.stderr
│   │   ├── manual_find.rs
│   │   ├── manual_find.stderr
│   │   ├── manual_find_fixable.fixed
│   │   ├── manual_find_fixable.rs
│   │   ├── manual_find_fixable.stderr
│   │   ├── manual_find_map.fixed
│   │   ├── manual_find_map.rs
│   │   ├── manual_find_map.stderr
│   │   ├── manual_flatten.fixed
│   │   ├── manual_flatten.rs
│   │   ├── manual_flatten.stderr
│   │   ├── manual_float_methods.rs
│   │   ├── manual_float_methods.stderr
│   │   ├── manual_hash_one.fixed
│   │   ├── manual_hash_one.rs
│   │   ├── manual_hash_one.stderr
│   │   ├── manual_ignore_case_cmp.fixed
│   │   ├── manual_ignore_case_cmp.rs
│   │   ├── manual_ignore_case_cmp.stderr
│   │   ├── manual_ilog2.fixed
│   │   ├── manual_ilog2.rs
│   │   ├── manual_ilog2.stderr
│   │   ├── manual_inspect.fixed
│   │   ├── manual_inspect.rs
│   │   ├── manual_inspect.stderr
│   │   ├── manual_instant_elapsed.fixed
│   │   ├── manual_instant_elapsed.rs
│   │   ├── manual_instant_elapsed.stderr
│   │   ├── manual_is_ascii_check.fixed
│   │   ├── manual_is_ascii_check.rs
│   │   ├── manual_is_ascii_check.stderr
│   │   ├── manual_is_multiple_of.fixed
│   │   ├── manual_is_multiple_of.rs
│   │   ├── manual_is_multiple_of.stderr
│   │   ├── manual_is_power_of_two.fixed
│   │   ├── manual_is_power_of_two.rs
│   │   ├── manual_is_power_of_two.stderr
│   │   ├── manual_is_variant_and.fixed
│   │   ├── manual_is_variant_and.rs
│   │   ├── manual_is_variant_and.stderr
│   │   ├── manual_let_else.rs
│   │   ├── manual_let_else.stderr
│   │   ├── manual_let_else_match.fixed
│   │   ├── manual_let_else_match.rs
│   │   ├── manual_let_else_match.stderr
│   │   ├── manual_let_else_question_mark.fixed
│   │   ├── manual_let_else_question_mark.rs
│   │   ├── manual_let_else_question_mark.stderr
│   │   ├── manual_main_separator_str.fixed
│   │   ├── manual_main_separator_str.rs
│   │   ├── manual_main_separator_str.stderr
│   │   ├── manual_map_option.fixed
│   │   ├── manual_map_option.rs
│   │   ├── manual_map_option.stderr
│   │   ├── manual_map_option_2.fixed
│   │   ├── manual_map_option_2.rs
│   │   ├── manual_map_option_2.stderr
│   │   ├── manual_memcpy/
│   │   │   ├── with_loop_counters.fixed
│   │   │   ├── with_loop_counters.rs
│   │   │   ├── with_loop_counters.stderr
│   │   │   ├── without_loop_counters.fixed
│   │   │   ├── without_loop_counters.rs
│   │   │   └── without_loop_counters.stderr
│   │   ├── manual_midpoint.fixed
│   │   ├── manual_midpoint.rs
│   │   ├── manual_midpoint.stderr
│   │   ├── manual_next_back.fixed
│   │   ├── manual_next_back.rs
│   │   ├── manual_next_back.stderr
│   │   ├── manual_non_exhaustive_enum.rs
│   │   ├── manual_non_exhaustive_enum.stderr
│   │   ├── manual_non_exhaustive_struct.rs
│   │   ├── manual_non_exhaustive_struct.stderr
│   │   ├── manual_ok_err.fixed
│   │   ├── manual_ok_err.rs
│   │   ├── manual_ok_err.stderr
│   │   ├── manual_ok_or.fixed
│   │   ├── manual_ok_or.rs
│   │   ├── manual_ok_or.stderr
│   │   ├── manual_option_as_slice.fixed
│   │   ├── manual_option_as_slice.rs
│   │   ├── manual_option_as_slice.stderr
│   │   ├── manual_pattern_char_comparison.fixed
│   │   ├── manual_pattern_char_comparison.rs
│   │   ├── manual_pattern_char_comparison.stderr
│   │   ├── manual_pop_if.fixed
│   │   ├── manual_pop_if.rs
│   │   ├── manual_pop_if.stderr
│   │   ├── manual_range_patterns.fixed
│   │   ├── manual_range_patterns.rs
│   │   ├── manual_range_patterns.stderr
│   │   ├── manual_rem_euclid.fixed
│   │   ├── manual_rem_euclid.rs
│   │   ├── manual_rem_euclid.stderr
│   │   ├── manual_repeat_n.fixed
│   │   ├── manual_repeat_n.rs
│   │   ├── manual_repeat_n.stderr
│   │   ├── manual_retain.fixed
│   │   ├── manual_retain.rs
│   │   ├── manual_retain.stderr
│   │   ├── manual_rotate.fixed
│   │   ├── manual_rotate.rs
│   │   ├── manual_rotate.stderr
│   │   ├── manual_saturating_arithmetic.fixed
│   │   ├── manual_saturating_arithmetic.rs
│   │   ├── manual_saturating_arithmetic.stderr
│   │   ├── manual_slice_fill.fixed
│   │   ├── manual_slice_fill.rs
│   │   ├── manual_slice_fill.stderr
│   │   ├── manual_slice_size_calculation.fixed
│   │   ├── manual_slice_size_calculation.rs
│   │   ├── manual_slice_size_calculation.stderr
│   │   ├── manual_split_once.fixed
│   │   ├── manual_split_once.rs
│   │   ├── manual_split_once.stderr
│   │   ├── manual_str_repeat.fixed
│   │   ├── manual_str_repeat.rs
│   │   ├── manual_str_repeat.stderr
│   │   ├── manual_string_new.fixed
│   │   ├── manual_string_new.rs
│   │   ├── manual_string_new.stderr
│   │   ├── manual_strip.rs
│   │   ├── manual_strip.stderr
│   │   ├── manual_strip_fixable.fixed
│   │   ├── manual_strip_fixable.rs
│   │   ├── manual_strip_fixable.stderr
│   │   ├── manual_swap_auto_fix.fixed
│   │   ├── manual_swap_auto_fix.rs
│   │   ├── manual_swap_auto_fix.stderr
│   │   ├── manual_take.fixed
│   │   ├── manual_take.rs
│   │   ├── manual_take.stderr
│   │   ├── manual_take_nocore.rs
│   │   ├── manual_take_nostd.fixed
│   │   ├── manual_take_nostd.rs
│   │   ├── manual_take_nostd.stderr
│   │   ├── manual_try_fold.rs
│   │   ├── manual_try_fold.stderr
│   │   ├── manual_unwrap_or.fixed
│   │   ├── manual_unwrap_or.rs
│   │   ├── manual_unwrap_or.stderr
│   │   ├── manual_unwrap_or_default.fixed
│   │   ├── manual_unwrap_or_default.rs
│   │   ├── manual_unwrap_or_default.stderr
│   │   ├── manual_unwrap_or_default_unfixable.rs
│   │   ├── manual_unwrap_or_default_unfixable.stderr
│   │   ├── manual_while_let_some.fixed
│   │   ├── manual_while_let_some.rs
│   │   ├── manual_while_let_some.stderr
│   │   ├── many_single_char_names.rs
│   │   ├── many_single_char_names.stderr
│   │   ├── map_all_any_identity.fixed
│   │   ├── map_all_any_identity.rs
│   │   ├── map_all_any_identity.stderr
│   │   ├── map_clone.fixed
│   │   ├── map_clone.rs
│   │   ├── map_clone.stderr
│   │   ├── map_collect_result_unit.fixed
│   │   ├── map_collect_result_unit.rs
│   │   ├── map_collect_result_unit.stderr
│   │   ├── map_err.rs
│   │   ├── map_err.stderr
│   │   ├── map_flatten.fixed
│   │   ├── map_flatten.rs
│   │   ├── map_flatten.stderr
│   │   ├── map_flatten_fixable.fixed
│   │   ├── map_flatten_fixable.rs
│   │   ├── map_flatten_fixable.stderr
│   │   ├── map_identity.fixed
│   │   ├── map_identity.rs
│   │   ├── map_identity.stderr
│   │   ├── map_unit_fn.rs
│   │   ├── map_unwrap_or.rs
│   │   ├── map_unwrap_or.stderr
│   │   ├── map_unwrap_or_fixable.fixed
│   │   ├── map_unwrap_or_fixable.rs
│   │   ├── map_unwrap_or_fixable.stderr
│   │   ├── map_with_unused_argument_over_ranges.fixed
│   │   ├── map_with_unused_argument_over_ranges.rs
│   │   ├── map_with_unused_argument_over_ranges.stderr
│   │   ├── map_with_unused_argument_over_ranges_nostd.fixed
│   │   ├── map_with_unused_argument_over_ranges_nostd.rs
│   │   ├── map_with_unused_argument_over_ranges_nostd.stderr
│   │   ├── match_as_ref.fixed
│   │   ├── match_as_ref.rs
│   │   ├── match_as_ref.stderr
│   │   ├── match_bool.fixed
│   │   ├── match_bool.rs
│   │   ├── match_bool.stderr
│   │   ├── match_like_matches_macro.fixed
│   │   ├── match_like_matches_macro.rs
│   │   ├── match_like_matches_macro.stderr
│   │   ├── match_like_matches_macro_if_let_guard.rs
│   │   ├── match_overlapping_arm.rs
│   │   ├── match_overlapping_arm.stderr
│   │   ├── match_ref_pats.fixed
│   │   ├── match_ref_pats.rs
│   │   ├── match_ref_pats.stderr
│   │   ├── match_result_ok.fixed
│   │   ├── match_result_ok.rs
│   │   ├── match_result_ok.stderr
│   │   ├── match_same_arms.fixed
│   │   ├── match_same_arms.rs
│   │   ├── match_same_arms.stderr
│   │   ├── match_same_arms2.fixed
│   │   ├── match_same_arms2.rs
│   │   ├── match_same_arms2.stderr
│   │   ├── match_same_arms_non_exhaustive.fixed
│   │   ├── match_same_arms_non_exhaustive.rs
│   │   ├── match_same_arms_non_exhaustive.stderr
│   │   ├── match_single_binding.fixed
│   │   ├── match_single_binding.rs
│   │   ├── match_single_binding.stderr
│   │   ├── match_single_binding2.fixed
│   │   ├── match_single_binding2.rs
│   │   ├── match_single_binding2.stderr
│   │   ├── match_str_case_mismatch.fixed
│   │   ├── match_str_case_mismatch.rs
│   │   ├── match_str_case_mismatch.stderr
│   │   ├── match_wild_err_arm.rs
│   │   ├── match_wild_err_arm.stderr
│   │   ├── match_wildcard_for_single_variants.fixed
│   │   ├── match_wildcard_for_single_variants.rs
│   │   ├── match_wildcard_for_single_variants.stderr
│   │   ├── mem_forget.rs
│   │   ├── mem_forget.stderr
│   │   ├── mem_replace.fixed
│   │   ├── mem_replace.rs
│   │   ├── mem_replace.stderr
│   │   ├── mem_replace_macro.rs
│   │   ├── mem_replace_macro.stderr
│   │   ├── mem_replace_no_std.fixed
│   │   ├── mem_replace_no_std.rs
│   │   ├── mem_replace_no_std.stderr
│   │   ├── methods.rs
│   │   ├── methods.stderr
│   │   ├── methods_fixable.fixed
│   │   ├── methods_fixable.rs
│   │   ├── methods_fixable.stderr
│   │   ├── methods_unfixable.rs
│   │   ├── methods_unfixable.stderr
│   │   ├── min_ident_chars.rs
│   │   ├── min_ident_chars.stderr
│   │   ├── min_max.rs
│   │   ├── min_max.stderr
│   │   ├── min_rust_version_attr.rs
│   │   ├── min_rust_version_attr.stderr
│   │   ├── min_rust_version_invalid_attr.rs
│   │   ├── min_rust_version_invalid_attr.stderr
│   │   ├── mismatching_type_param_order.rs
│   │   ├── mismatching_type_param_order.stderr
│   │   ├── misnamed_getters.fixed
│   │   ├── misnamed_getters.rs
│   │   ├── misnamed_getters.stderr
│   │   ├── misnamed_getters_2021.fixed
│   │   ├── misnamed_getters_2021.rs
│   │   ├── misnamed_getters_2021.stderr
│   │   ├── misrefactored_assign_op.1.fixed
│   │   ├── misrefactored_assign_op.2.fixed
│   │   ├── misrefactored_assign_op.rs
│   │   ├── misrefactored_assign_op.stderr
│   │   ├── missing_assert_message.edition2015.stderr
│   │   ├── missing_assert_message.edition2021.stderr
│   │   ├── missing_assert_message.rs
│   │   ├── missing_asserts_for_indexing.fixed
│   │   ├── missing_asserts_for_indexing.rs
│   │   ├── missing_asserts_for_indexing.stderr
│   │   ├── missing_asserts_for_indexing_unfixable.rs
│   │   ├── missing_asserts_for_indexing_unfixable.stderr
│   │   ├── missing_const_for_fn/
│   │   │   ├── auxiliary/
│   │   │   │   └── helper.rs
│   │   │   ├── cant_be_const.rs
│   │   │   ├── const_trait.fixed
│   │   │   ├── const_trait.rs
│   │   │   ├── const_trait.stderr
│   │   │   ├── could_be_const.fixed
│   │   │   ├── could_be_const.rs
│   │   │   └── could_be_const.stderr
│   │   ├── missing_const_for_thread_local.fixed
│   │   ├── missing_const_for_thread_local.rs
│   │   ├── missing_const_for_thread_local.stderr
│   │   ├── missing_fields_in_debug.rs
│   │   ├── missing_fields_in_debug.stderr
│   │   ├── missing_inline.rs
│   │   ├── missing_inline.stderr
│   │   ├── missing_inline_executable.rs
│   │   ├── missing_inline_executable.stderr
│   │   ├── missing_inline_proc_macro.rs
│   │   ├── missing_inline_test_crate.rs
│   │   ├── missing_panics_doc.rs
│   │   ├── missing_panics_doc.stderr
│   │   ├── missing_spin_loop.fixed
│   │   ├── missing_spin_loop.rs
│   │   ├── missing_spin_loop.stderr
│   │   ├── missing_spin_loop_no_std.fixed
│   │   ├── missing_spin_loop_no_std.rs
│   │   ├── missing_spin_loop_no_std.stderr
│   │   ├── missing_trait_methods.rs
│   │   ├── missing_trait_methods.stderr
│   │   ├── missing_transmute_annotations.fixed
│   │   ├── missing_transmute_annotations.rs
│   │   ├── missing_transmute_annotations.stderr
│   │   ├── missing_transmute_annotations_unfixable.rs
│   │   ├── missing_transmute_annotations_unfixable.stderr
│   │   ├── mistyped_literal_suffix.fixed
│   │   ├── mistyped_literal_suffix.rs
│   │   ├── mistyped_literal_suffix.stderr
│   │   ├── mixed_attributes_style/
│   │   │   ├── auxiliary/
│   │   │   │   └── submodule.rs
│   │   │   ├── global_allow.rs
│   │   │   ├── mod_declaration.rs
│   │   │   └── mod_declaration.stderr
│   │   ├── mixed_attributes_style.rs
│   │   ├── mixed_attributes_style.stderr
│   │   ├── mixed_read_write_in_expression.rs
│   │   ├── mixed_read_write_in_expression.stderr
│   │   ├── module_inception.rs
│   │   ├── module_inception.stderr
│   │   ├── module_name_repetitions.rs
│   │   ├── module_name_repetitions.stderr
│   │   ├── modulo_arithmetic_float.rs
│   │   ├── modulo_arithmetic_float.stderr
│   │   ├── modulo_arithmetic_integral.rs
│   │   ├── modulo_arithmetic_integral.stderr
│   │   ├── modulo_arithmetic_integral_const.rs
│   │   ├── modulo_arithmetic_integral_const.stderr
│   │   ├── modulo_one.rs
│   │   ├── modulo_one.stderr
│   │   ├── msrv_attributes_without_early_lints.rs
│   │   ├── multi_assignments.rs
│   │   ├── multi_assignments.stderr
│   │   ├── multiple_bound_locations.rs
│   │   ├── multiple_bound_locations.stderr
│   │   ├── multiple_inherent_impl_cfg.normal.stderr
│   │   ├── multiple_inherent_impl_cfg.rs
│   │   ├── multiple_inherent_impl_cfg.stderr
│   │   ├── multiple_inherent_impl_cfg.withtest.stderr
│   │   ├── multiple_unsafe_ops_per_block.rs
│   │   ├── multiple_unsafe_ops_per_block.stderr
│   │   ├── must_use_candidates.fixed
│   │   ├── must_use_candidates.rs
│   │   ├── must_use_candidates.stderr
│   │   ├── must_use_unit.fixed
│   │   ├── must_use_unit.rs
│   │   ├── must_use_unit.stderr
│   │   ├── must_use_unit_unfixable.rs
│   │   ├── must_use_unit_unfixable.stderr
│   │   ├── mut_from_ref.rs
│   │   ├── mut_from_ref.stderr
│   │   ├── mut_key.rs
│   │   ├── mut_key.stderr
│   │   ├── mut_mut.fixed
│   │   ├── mut_mut.rs
│   │   ├── mut_mut.stderr
│   │   ├── mut_mut_unfixable.rs
│   │   ├── mut_mut_unfixable.stderr
│   │   ├── mut_mutex_lock.fixed
│   │   ├── mut_mutex_lock.rs
│   │   ├── mut_mutex_lock.stderr
│   │   ├── mut_range_bound.rs
│   │   ├── mut_range_bound.stderr
│   │   ├── mutex_atomic.fixed
│   │   ├── mutex_atomic.rs
│   │   ├── mutex_atomic.stderr
│   │   ├── mutex_atomic_unfixable.rs
│   │   ├── mutex_atomic_unfixable.stderr
│   │   ├── needless_arbitrary_self_type.fixed
│   │   ├── needless_arbitrary_self_type.rs
│   │   ├── needless_arbitrary_self_type.stderr
│   │   ├── needless_arbitrary_self_type_unfixable.fixed
│   │   ├── needless_arbitrary_self_type_unfixable.rs
│   │   ├── needless_arbitrary_self_type_unfixable.stderr
│   │   ├── needless_as_bytes.fixed
│   │   ├── needless_as_bytes.rs
│   │   ├── needless_as_bytes.stderr
│   │   ├── needless_bitwise_bool.fixed
│   │   ├── needless_bitwise_bool.rs
│   │   ├── needless_bitwise_bool.stderr
│   │   ├── needless_bool/
│   │   │   ├── fixable.fixed
│   │   │   ├── fixable.rs
│   │   │   ├── fixable.stderr
│   │   │   ├── simple.rs
│   │   │   └── simple.stderr
│   │   ├── needless_bool_assign.fixed
│   │   ├── needless_bool_assign.rs
│   │   ├── needless_bool_assign.stderr
│   │   ├── needless_borrow.fixed
│   │   ├── needless_borrow.rs
│   │   ├── needless_borrow.stderr
│   │   ├── needless_borrow_pat.fixed
│   │   ├── needless_borrow_pat.rs
│   │   ├── needless_borrow_pat.stderr
│   │   ├── needless_borrowed_ref.fixed
│   │   ├── needless_borrowed_ref.rs
│   │   ├── needless_borrowed_ref.stderr
│   │   ├── needless_borrows_for_generic_args.fixed
│   │   ├── needless_borrows_for_generic_args.rs
│   │   ├── needless_borrows_for_generic_args.stderr
│   │   ├── needless_character_iteration.fixed
│   │   ├── needless_character_iteration.rs
│   │   ├── needless_character_iteration.stderr
│   │   ├── needless_collect.fixed
│   │   ├── needless_collect.rs
│   │   ├── needless_collect.stderr
│   │   ├── needless_collect_indirect.fixed
│   │   ├── needless_collect_indirect.rs
│   │   ├── needless_collect_indirect.stderr
│   │   ├── needless_continue.rs
│   │   ├── needless_continue.stderr
│   │   ├── needless_doc_main.rs
│   │   ├── needless_doc_main.stderr
│   │   ├── needless_else.fixed
│   │   ├── needless_else.rs
│   │   ├── needless_else.stderr
│   │   ├── needless_for_each_fixable.fixed
│   │   ├── needless_for_each_fixable.rs
│   │   ├── needless_for_each_fixable.stderr
│   │   ├── needless_for_each_unfixable.rs
│   │   ├── needless_for_each_unfixable.stderr
│   │   ├── needless_ifs.fixed
│   │   ├── needless_ifs.rs
│   │   ├── needless_ifs.stderr
│   │   ├── needless_late_init.fixed
│   │   ├── needless_late_init.rs
│   │   ├── needless_late_init.stderr
│   │   ├── needless_lifetimes.fixed
│   │   ├── needless_lifetimes.rs
│   │   ├── needless_lifetimes.stderr
│   │   ├── needless_match.fixed
│   │   ├── needless_match.rs
│   │   ├── needless_match.stderr
│   │   ├── needless_maybe_sized.fixed
│   │   ├── needless_maybe_sized.rs
│   │   ├── needless_maybe_sized.stderr
│   │   ├── needless_option_as_deref.fixed
│   │   ├── needless_option_as_deref.rs
│   │   ├── needless_option_as_deref.stderr
│   │   ├── needless_option_take.fixed
│   │   ├── needless_option_take.rs
│   │   ├── needless_option_take.stderr
│   │   ├── needless_parens_on_range_literals.fixed
│   │   ├── needless_parens_on_range_literals.rs
│   │   ├── needless_parens_on_range_literals.stderr
│   │   ├── needless_pass_by_ref_mut.rs
│   │   ├── needless_pass_by_ref_mut.stderr
│   │   ├── needless_pass_by_ref_mut2.fixed
│   │   ├── needless_pass_by_ref_mut2.rs
│   │   ├── needless_pass_by_ref_mut2.stderr
│   │   ├── needless_pass_by_ref_mut_2021.rs
│   │   ├── needless_pass_by_value.rs
│   │   ├── needless_pass_by_value.stderr
│   │   ├── needless_pass_by_value_proc_macro.rs
│   │   ├── needless_pub_self.fixed
│   │   ├── needless_pub_self.rs
│   │   ├── needless_pub_self.stderr
│   │   ├── needless_question_mark.fixed
│   │   ├── needless_question_mark.rs
│   │   ├── needless_question_mark.stderr
│   │   ├── needless_range_loop.rs
│   │   ├── needless_range_loop.stderr
│   │   ├── needless_range_loop2.rs
│   │   ├── needless_range_loop2.stderr
│   │   ├── needless_raw_string.fixed
│   │   ├── needless_raw_string.rs
│   │   ├── needless_raw_string.stderr
│   │   ├── needless_raw_string_hashes.fixed
│   │   ├── needless_raw_string_hashes.rs
│   │   ├── needless_raw_string_hashes.stderr
│   │   ├── needless_return.fixed
│   │   ├── needless_return.rs
│   │   ├── needless_return.stderr
│   │   ├── needless_return_with_question_mark.fixed
│   │   ├── needless_return_with_question_mark.rs
│   │   ├── needless_return_with_question_mark.stderr
│   │   ├── needless_splitn.fixed
│   │   ├── needless_splitn.rs
│   │   ├── needless_splitn.stderr
│   │   ├── needless_type_cast.fixed
│   │   ├── needless_type_cast.rs
│   │   ├── needless_type_cast.stderr
│   │   ├── needless_type_cast_unfixable.rs
│   │   ├── needless_type_cast_unfixable.stderr
│   │   ├── needless_update.rs
│   │   ├── needless_update.stderr
│   │   ├── neg_cmp_op_on_partial_ord.rs
│   │   ├── neg_cmp_op_on_partial_ord.stderr
│   │   ├── neg_multiply.fixed
│   │   ├── neg_multiply.rs
│   │   ├── neg_multiply.stderr
│   │   ├── never_loop.rs
│   │   ├── never_loop.stderr
│   │   ├── never_loop_fixable.fixed
│   │   ├── never_loop_fixable.rs
│   │   ├── never_loop_fixable.stderr
│   │   ├── never_loop_iterator_reduction.rs
│   │   ├── never_loop_iterator_reduction.stderr
│   │   ├── new_ret_no_self.rs
│   │   ├── new_ret_no_self.stderr
│   │   ├── new_ret_no_self_overflow.rs
│   │   ├── new_ret_no_self_overflow.stderr
│   │   ├── new_without_default.fixed
│   │   ├── new_without_default.rs
│   │   ├── new_without_default.stderr
│   │   ├── no_effect.rs
│   │   ├── no_effect.stderr
│   │   ├── no_effect_async_fn.rs
│   │   ├── no_effect_async_fn.stderr
│   │   ├── no_effect_replace.rs
│   │   ├── no_effect_replace.stderr
│   │   ├── no_effect_return.rs
│   │   ├── no_effect_return.stderr
│   │   ├── no_mangle_with_rust_abi.rs
│   │   ├── no_mangle_with_rust_abi.stderr
│   │   ├── no_mangle_with_rust_abi_2021.rs
│   │   ├── no_mangle_with_rust_abi_2021.stderr
│   │   ├── non_canonical_clone_impl.fixed
│   │   ├── non_canonical_clone_impl.rs
│   │   ├── non_canonical_clone_impl.stderr
│   │   ├── non_canonical_partial_ord_impl.fixed
│   │   ├── non_canonical_partial_ord_impl.rs
│   │   ├── non_canonical_partial_ord_impl.stderr
│   │   ├── non_canonical_partial_ord_impl_fully_qual.rs
│   │   ├── non_canonical_partial_ord_impl_fully_qual.stderr
│   │   ├── non_expressive_names.rs
│   │   ├── non_expressive_names.stderr
│   │   ├── non_expressive_names_error_recovery.fixed
│   │   ├── non_expressive_names_error_recovery.rs
│   │   ├── non_expressive_names_error_recovery.stderr
│   │   ├── non_minimal_cfg.fixed
│   │   ├── non_minimal_cfg.rs
│   │   ├── non_minimal_cfg.stderr
│   │   ├── non_minimal_cfg2.rs
│   │   ├── non_minimal_cfg2.stderr
│   │   ├── non_octal_unix_permissions.fixed
│   │   ├── non_octal_unix_permissions.rs
│   │   ├── non_octal_unix_permissions.stderr
│   │   ├── non_send_fields_in_send_ty.rs
│   │   ├── non_send_fields_in_send_ty.stderr
│   │   ├── non_std_lazy_static/
│   │   │   ├── auxiliary/
│   │   │   │   ├── lazy_static.rs
│   │   │   │   └── once_cell.rs
│   │   │   ├── non_std_lazy_static_fixable.fixed
│   │   │   ├── non_std_lazy_static_fixable.rs
│   │   │   ├── non_std_lazy_static_fixable.stderr
│   │   │   ├── non_std_lazy_static_no_std.rs
│   │   │   ├── non_std_lazy_static_other_once_cell.rs
│   │   │   ├── non_std_lazy_static_unfixable.rs
│   │   │   └── non_std_lazy_static_unfixable.stderr
│   │   ├── non_zero_suggestions.fixed
│   │   ├── non_zero_suggestions.rs
│   │   ├── non_zero_suggestions.stderr
│   │   ├── non_zero_suggestions_unfixable.rs
│   │   ├── non_zero_suggestions_unfixable.stderr
│   │   ├── nonminimal_bool.rs
│   │   ├── nonminimal_bool.stderr
│   │   ├── nonminimal_bool_methods.fixed
│   │   ├── nonminimal_bool_methods.rs
│   │   ├── nonminimal_bool_methods.stderr
│   │   ├── nonminimal_bool_methods_unfixable.rs
│   │   ├── nonminimal_bool_methods_unfixable.stderr
│   │   ├── obfuscated_if_else.fixed
│   │   ├── obfuscated_if_else.rs
│   │   ├── obfuscated_if_else.stderr
│   │   ├── octal_escapes.rs
│   │   ├── octal_escapes.stderr
│   │   ├── ok_expect.fixed
│   │   ├── ok_expect.rs
│   │   ├── ok_expect.stderr
│   │   ├── only_used_in_recursion.rs
│   │   ├── only_used_in_recursion.stderr
│   │   ├── only_used_in_recursion2.rs
│   │   ├── only_used_in_recursion2.stderr
│   │   ├── op_ref.fixed
│   │   ├── op_ref.rs
│   │   ├── op_ref.stderr
│   │   ├── open_options.rs
│   │   ├── open_options.stderr
│   │   ├── open_options_fixable.fixed
│   │   ├── open_options_fixable.rs
│   │   ├── open_options_fixable.stderr
│   │   ├── option_as_ref_cloned.fixed
│   │   ├── option_as_ref_cloned.rs
│   │   ├── option_as_ref_cloned.stderr
│   │   ├── option_as_ref_deref.fixed
│   │   ├── option_as_ref_deref.rs
│   │   ├── option_as_ref_deref.stderr
│   │   ├── option_env_unwrap.rs
│   │   ├── option_env_unwrap.stderr
│   │   ├── option_filter_map.fixed
│   │   ├── option_filter_map.rs
│   │   ├── option_filter_map.stderr
│   │   ├── option_if_let_else.fixed
│   │   ├── option_if_let_else.rs
│   │   ├── option_if_let_else.stderr
│   │   ├── option_map_or_none.fixed
│   │   ├── option_map_or_none.rs
│   │   ├── option_map_or_none.stderr
│   │   ├── option_map_unit_fn_fixable.fixed
│   │   ├── option_map_unit_fn_fixable.rs
│   │   ├── option_map_unit_fn_fixable.stderr
│   │   ├── option_map_unit_fn_unfixable.rs
│   │   ├── option_map_unit_fn_unfixable.stderr
│   │   ├── option_option.rs
│   │   ├── option_option.stderr
│   │   ├── or_fun_call.fixed
│   │   ├── or_fun_call.rs
│   │   ├── or_fun_call.stderr
│   │   ├── or_then_unwrap.fixed
│   │   ├── or_then_unwrap.rs
│   │   ├── or_then_unwrap.stderr
│   │   ├── out_of_bounds_indexing/
│   │   │   ├── issue-3102.rs
│   │   │   ├── issue-3102.stderr
│   │   │   ├── simple.rs
│   │   │   └── simple.stderr
│   │   ├── overly_complex_bool_expr.fixed
│   │   ├── overly_complex_bool_expr.rs
│   │   ├── overly_complex_bool_expr.stderr
│   │   ├── owned_cow.fixed
│   │   ├── owned_cow.rs
│   │   ├── owned_cow.stderr
│   │   ├── panic_in_result_fn.rs
│   │   ├── panic_in_result_fn.stderr
│   │   ├── panic_in_result_fn_assertions.rs
│   │   ├── panic_in_result_fn_assertions.stderr
│   │   ├── panic_in_result_fn_debug_assertions.rs
│   │   ├── panicking_macros.rs
│   │   ├── panicking_macros.stderr
│   │   ├── panicking_overflow_checks.rs
│   │   ├── panicking_overflow_checks.stderr
│   │   ├── partial_pub_fields.rs
│   │   ├── partial_pub_fields.stderr
│   │   ├── partialeq_ne_impl.rs
│   │   ├── partialeq_ne_impl.stderr
│   │   ├── partialeq_to_none.fixed
│   │   ├── partialeq_to_none.rs
│   │   ├── partialeq_to_none.stderr
│   │   ├── path_buf_push_overwrite.fixed
│   │   ├── path_buf_push_overwrite.rs
│   │   ├── path_buf_push_overwrite.stderr
│   │   ├── path_ends_with_ext.fixed
│   │   ├── path_ends_with_ext.rs
│   │   ├── path_ends_with_ext.stderr
│   │   ├── pathbuf_init_then_push.fixed
│   │   ├── pathbuf_init_then_push.rs
│   │   ├── pathbuf_init_then_push.stderr
│   │   ├── pattern_type_mismatch/
│   │   │   ├── auxiliary/
│   │   │   │   └── external.rs
│   │   │   ├── mutability.rs
│   │   │   ├── mutability.stderr
│   │   │   ├── pattern_alternatives.rs
│   │   │   ├── pattern_alternatives.stderr
│   │   │   ├── pattern_structs.rs
│   │   │   ├── pattern_structs.stderr
│   │   │   ├── pattern_tuples.rs
│   │   │   ├── pattern_tuples.stderr
│   │   │   ├── syntax.rs
│   │   │   └── syntax.stderr
│   │   ├── patterns.fixed
│   │   ├── patterns.rs
│   │   ├── patterns.stderr
│   │   ├── permissions_set_readonly_false.rs
│   │   ├── permissions_set_readonly_false.stderr
│   │   ├── pointer_format.rs
│   │   ├── pointer_format.stderr
│   │   ├── pointers_in_nomem_asm_block.rs
│   │   ├── pointers_in_nomem_asm_block.stderr
│   │   ├── precedence.fixed
│   │   ├── precedence.rs
│   │   ├── precedence.stderr
│   │   ├── precedence_bits.fixed
│   │   ├── precedence_bits.rs
│   │   ├── precedence_bits.stderr
│   │   ├── print_in_format_impl.rs
│   │   ├── print_in_format_impl.stderr
│   │   ├── print_literal.fixed
│   │   ├── print_literal.rs
│   │   ├── print_literal.stderr
│   │   ├── print_stderr.rs
│   │   ├── print_stderr.stderr
│   │   ├── print_stdout.rs
│   │   ├── print_stdout.stderr
│   │   ├── print_stdout_build_script.rs
│   │   ├── print_with_newline.fixed
│   │   ├── print_with_newline.rs
│   │   ├── print_with_newline.stderr
│   │   ├── println_empty_string.fixed
│   │   ├── println_empty_string.rs
│   │   ├── println_empty_string.stderr
│   │   ├── println_empty_string_unfixable.rs
│   │   ├── println_empty_string_unfixable.stderr
│   │   ├── proc_macro.rs
│   │   ├── proc_macro.stderr
│   │   ├── ptr_arg.rs
│   │   ├── ptr_arg.stderr
│   │   ├── ptr_as_ptr.fixed
│   │   ├── ptr_as_ptr.rs
│   │   ├── ptr_as_ptr.stderr
│   │   ├── ptr_cast_constness.fixed
│   │   ├── ptr_cast_constness.rs
│   │   ├── ptr_cast_constness.stderr
│   │   ├── ptr_eq.fixed
│   │   ├── ptr_eq.rs
│   │   ├── ptr_eq.stderr
│   │   ├── ptr_eq_no_std.fixed
│   │   ├── ptr_eq_no_std.rs
│   │   ├── ptr_eq_no_std.stderr
│   │   ├── ptr_offset_by_literal.fixed
│   │   ├── ptr_offset_by_literal.rs
│   │   ├── ptr_offset_by_literal.stderr
│   │   ├── ptr_offset_with_cast.fixed
│   │   ├── ptr_offset_with_cast.rs
│   │   ├── ptr_offset_with_cast.stderr
│   │   ├── pub_use.rs
│   │   ├── pub_use.stderr
│   │   ├── pub_with_shorthand.fixed
│   │   ├── pub_with_shorthand.rs
│   │   ├── pub_with_shorthand.stderr
│   │   ├── pub_without_shorthand.fixed
│   │   ├── pub_without_shorthand.rs
│   │   ├── pub_without_shorthand.stderr
│   │   ├── question_mark.fixed
│   │   ├── question_mark.rs
│   │   ├── question_mark.stderr
│   │   ├── question_mark_used.rs
│   │   ├── question_mark_used.stderr
│   │   ├── range.fixed
│   │   ├── range.rs
│   │   ├── range.stderr
│   │   ├── range_contains.fixed
│   │   ├── range_contains.rs
│   │   ├── range_contains.stderr
│   │   ├── range_plus_minus_one.fixed
│   │   ├── range_plus_minus_one.rs
│   │   ├── range_plus_minus_one.stderr
│   │   ├── range_unfixable.rs
│   │   ├── range_unfixable.stderr
│   │   ├── rc_buffer.fixed
│   │   ├── rc_buffer.rs
│   │   ├── rc_buffer.stderr
│   │   ├── rc_buffer_arc.fixed
│   │   ├── rc_buffer_arc.rs
│   │   ├── rc_buffer_arc.stderr
│   │   ├── rc_buffer_redefined_string.rs
│   │   ├── rc_clone_in_vec_init/
│   │   │   ├── arc.rs
│   │   │   ├── arc.stderr
│   │   │   ├── rc.rs
│   │   │   ├── rc.stderr
│   │   │   ├── weak.rs
│   │   │   └── weak.stderr
│   │   ├── rc_mutex.rs
│   │   ├── rc_mutex.stderr
│   │   ├── read_line_without_trim.fixed
│   │   ├── read_line_without_trim.rs
│   │   ├── read_line_without_trim.stderr
│   │   ├── read_zero_byte_vec.rs
│   │   ├── read_zero_byte_vec.stderr
│   │   ├── readonly_write_lock.fixed
│   │   ├── readonly_write_lock.rs
│   │   ├── readonly_write_lock.stderr
│   │   ├── recursive_format_impl.rs
│   │   ├── recursive_format_impl.stderr
│   │   ├── redundant_allocation.rs
│   │   ├── redundant_allocation.stderr
│   │   ├── redundant_allocation_fixable.fixed
│   │   ├── redundant_allocation_fixable.rs
│   │   ├── redundant_allocation_fixable.stderr
│   │   ├── redundant_as_str.fixed
│   │   ├── redundant_as_str.rs
│   │   ├── redundant_as_str.stderr
│   │   ├── redundant_async_block.fixed
│   │   ├── redundant_async_block.rs
│   │   ├── redundant_async_block.stderr
│   │   ├── redundant_at_rest_pattern.fixed
│   │   ├── redundant_at_rest_pattern.rs
│   │   ├── redundant_at_rest_pattern.stderr
│   │   ├── redundant_clone.fixed
│   │   ├── redundant_clone.rs
│   │   ├── redundant_clone.stderr
│   │   ├── redundant_closure_call_early.rs
│   │   ├── redundant_closure_call_early.stderr
│   │   ├── redundant_closure_call_fixable.fixed
│   │   ├── redundant_closure_call_fixable.rs
│   │   ├── redundant_closure_call_fixable.stderr
│   │   ├── redundant_closure_call_late.rs
│   │   ├── redundant_closure_call_late.stderr
│   │   ├── redundant_else.fixed
│   │   ├── redundant_else.rs
│   │   ├── redundant_else.stderr
│   │   ├── redundant_field_names.fixed
│   │   ├── redundant_field_names.rs
│   │   ├── redundant_field_names.stderr
│   │   ├── redundant_guards.fixed
│   │   ├── redundant_guards.rs
│   │   ├── redundant_guards.stderr
│   │   ├── redundant_locals.rs
│   │   ├── redundant_locals.stderr
│   │   ├── redundant_pattern_matching_drop_order.fixed
│   │   ├── redundant_pattern_matching_drop_order.rs
│   │   ├── redundant_pattern_matching_drop_order.stderr
│   │   ├── redundant_pattern_matching_if_let_true.fixed
│   │   ├── redundant_pattern_matching_if_let_true.rs
│   │   ├── redundant_pattern_matching_if_let_true.stderr
│   │   ├── redundant_pattern_matching_ipaddr.fixed
│   │   ├── redundant_pattern_matching_ipaddr.rs
│   │   ├── redundant_pattern_matching_ipaddr.stderr
│   │   ├── redundant_pattern_matching_option.fixed
│   │   ├── redundant_pattern_matching_option.rs
│   │   ├── redundant_pattern_matching_option.stderr
│   │   ├── redundant_pattern_matching_poll.fixed
│   │   ├── redundant_pattern_matching_poll.rs
│   │   ├── redundant_pattern_matching_poll.stderr
│   │   ├── redundant_pattern_matching_result.fixed
│   │   ├── redundant_pattern_matching_result.rs
│   │   ├── redundant_pattern_matching_result.stderr
│   │   ├── redundant_pub_crate.fixed
│   │   ├── redundant_pub_crate.rs
│   │   ├── redundant_pub_crate.stderr
│   │   ├── redundant_slicing.fixed
│   │   ├── redundant_slicing.rs
│   │   ├── redundant_slicing.stderr
│   │   ├── redundant_static_lifetimes.fixed
│   │   ├── redundant_static_lifetimes.rs
│   │   ├── redundant_static_lifetimes.stderr
│   │   ├── redundant_static_lifetimes_multiple.rs
│   │   ├── redundant_static_lifetimes_multiple.stderr
│   │   ├── redundant_test_prefix.fixed
│   │   ├── redundant_test_prefix.rs
│   │   ├── redundant_test_prefix.stderr
│   │   ├── redundant_test_prefix_noautofix.rs
│   │   ├── redundant_test_prefix_noautofix.stderr
│   │   ├── redundant_type_annotations.rs
│   │   ├── redundant_type_annotations.stderr
│   │   ├── ref_as_ptr.fixed
│   │   ├── ref_as_ptr.rs
│   │   ├── ref_as_ptr.stderr
│   │   ├── ref_binding_to_reference.rs
│   │   ├── ref_binding_to_reference.stderr
│   │   ├── ref_option_ref.rs
│   │   ├── ref_option_ref.stderr
│   │   ├── ref_patterns.rs
│   │   ├── ref_patterns.stderr
│   │   ├── regex.rs
│   │   ├── regex.stderr
│   │   ├── rename.fixed
│   │   ├── rename.rs
│   │   ├── rename.stderr
│   │   ├── renamed_builtin_attr.fixed
│   │   ├── renamed_builtin_attr.rs
│   │   ├── renamed_builtin_attr.stderr
│   │   ├── repeat_once.fixed
│   │   ├── repeat_once.rs
│   │   ├── repeat_once.stderr
│   │   ├── repeat_vec_with_capacity.fixed
│   │   ├── repeat_vec_with_capacity.rs
│   │   ├── repeat_vec_with_capacity.stderr
│   │   ├── repeat_vec_with_capacity_nostd.fixed
│   │   ├── repeat_vec_with_capacity_nostd.rs
│   │   ├── repeat_vec_with_capacity_nostd.stderr
│   │   ├── repl_uninit.rs
│   │   ├── repl_uninit.stderr
│   │   ├── replace_box.fixed
│   │   ├── replace_box.rs
│   │   ├── replace_box.stderr
│   │   ├── repr_packed_without_abi.rs
│   │   ├── repr_packed_without_abi.stderr
│   │   ├── reserve_after_initialization.fixed
│   │   ├── reserve_after_initialization.rs
│   │   ├── reserve_after_initialization.stderr
│   │   ├── rest_pat_in_fully_bound_structs.fixed
│   │   ├── rest_pat_in_fully_bound_structs.rs
│   │   ├── rest_pat_in_fully_bound_structs.stderr
│   │   ├── result_filter_map.fixed
│   │   ├── result_filter_map.rs
│   │   ├── result_filter_map.stderr
│   │   ├── result_large_err.rs
│   │   ├── result_large_err.stderr
│   │   ├── result_map_or_into_option.fixed
│   │   ├── result_map_or_into_option.rs
│   │   ├── result_map_or_into_option.stderr
│   │   ├── result_map_unit_fn_fixable.fixed
│   │   ├── result_map_unit_fn_fixable.rs
│   │   ├── result_map_unit_fn_fixable.stderr
│   │   ├── result_map_unit_fn_unfixable.rs
│   │   ├── result_map_unit_fn_unfixable.stderr
│   │   ├── result_unit_error.rs
│   │   ├── result_unit_error.stderr
│   │   ├── result_unit_error_no_std.rs
│   │   ├── result_unit_error_no_std.stderr
│   │   ├── return_and_then.fixed
│   │   ├── return_and_then.rs
│   │   ├── return_and_then.stderr
│   │   ├── return_self_not_must_use.rs
│   │   ├── return_self_not_must_use.stderr
│   │   ├── reversed_empty_ranges_fixable.fixed
│   │   ├── reversed_empty_ranges_fixable.rs
│   │   ├── reversed_empty_ranges_fixable.stderr
│   │   ├── reversed_empty_ranges_loops_fixable.fixed
│   │   ├── reversed_empty_ranges_loops_fixable.rs
│   │   ├── reversed_empty_ranges_loops_fixable.stderr
│   │   ├── reversed_empty_ranges_loops_unfixable.rs
│   │   ├── reversed_empty_ranges_loops_unfixable.stderr
│   │   ├── reversed_empty_ranges_unfixable.rs
│   │   ├── reversed_empty_ranges_unfixable.stderr
│   │   ├── same_functions_in_if_condition.rs
│   │   ├── same_functions_in_if_condition.stderr
│   │   ├── same_item_push.rs
│   │   ├── same_item_push.stderr
│   │   ├── same_length_and_capacity.rs
│   │   ├── same_length_and_capacity.stderr
│   │   ├── same_name_method.rs
│   │   ├── same_name_method.stderr
│   │   ├── search_is_some.rs
│   │   ├── search_is_some.stderr
│   │   ├── search_is_some_fixable_none.fixed
│   │   ├── search_is_some_fixable_none.rs
│   │   ├── search_is_some_fixable_none.stderr
│   │   ├── search_is_some_fixable_none_2021.fixed
│   │   ├── search_is_some_fixable_none_2021.rs
│   │   ├── search_is_some_fixable_none_2021.stderr
│   │   ├── search_is_some_fixable_some.fixed
│   │   ├── search_is_some_fixable_some.rs
│   │   ├── search_is_some_fixable_some.stderr
│   │   ├── search_is_some_fixable_some_2021.fixed
│   │   ├── search_is_some_fixable_some_2021.rs
│   │   ├── search_is_some_fixable_some_2021.stderr
│   │   ├── seek_from_current.fixed
│   │   ├── seek_from_current.rs
│   │   ├── seek_from_current.stderr
│   │   ├── seek_to_start_instead_of_rewind.fixed
│   │   ├── seek_to_start_instead_of_rewind.rs
│   │   ├── seek_to_start_instead_of_rewind.stderr
│   │   ├── self_assignment.rs
│   │   ├── self_assignment.stderr
│   │   ├── self_named_constructors.rs
│   │   ├── self_named_constructors.stderr
│   │   ├── semicolon_if_nothing_returned.fixed
│   │   ├── semicolon_if_nothing_returned.rs
│   │   ├── semicolon_if_nothing_returned.stderr
│   │   ├── semicolon_inside_block.fixed
│   │   ├── semicolon_inside_block.rs
│   │   ├── semicolon_inside_block.stderr
│   │   ├── semicolon_inside_block_stmt_expr_attrs.fixed
│   │   ├── semicolon_inside_block_stmt_expr_attrs.rs
│   │   ├── semicolon_inside_block_stmt_expr_attrs.stderr
│   │   ├── semicolon_outside_block.fixed
│   │   ├── semicolon_outside_block.rs
│   │   ├── semicolon_outside_block.stderr
│   │   ├── serde.rs
│   │   ├── serde.stderr
│   │   ├── set_contains_or_insert.rs
│   │   ├── set_contains_or_insert.stderr
│   │   ├── shadow.rs
│   │   ├── shadow.stderr
│   │   ├── short_circuit_statement.fixed
│   │   ├── short_circuit_statement.rs
│   │   ├── short_circuit_statement.stderr
│   │   ├── should_impl_trait/
│   │   │   ├── corner_cases.rs
│   │   │   ├── method_list_1.edition2015.stderr
│   │   │   ├── method_list_1.edition2021.stderr
│   │   │   ├── method_list_1.rs
│   │   │   ├── method_list_2.edition2015.stderr
│   │   │   ├── method_list_2.edition2021.stderr
│   │   │   ├── method_list_2.rs
│   │   │   └── method_list_2.stderr
│   │   ├── should_panic_without_expect.rs
│   │   ├── should_panic_without_expect.stderr
│   │   ├── significant_drop_in_scrutinee.rs
│   │   ├── significant_drop_in_scrutinee.stderr
│   │   ├── significant_drop_tightening.fixed
│   │   ├── significant_drop_tightening.rs
│   │   ├── significant_drop_tightening.stderr
│   │   ├── similar_names.rs
│   │   ├── similar_names.stderr
│   │   ├── single_call_fn.rs
│   │   ├── single_call_fn.stderr
│   │   ├── single_char_add_str.fixed
│   │   ├── single_char_add_str.rs
│   │   ├── single_char_add_str.stderr
│   │   ├── single_char_lifetime_names.rs
│   │   ├── single_char_lifetime_names.stderr
│   │   ├── single_char_pattern.fixed
│   │   ├── single_char_pattern.rs
│   │   ├── single_char_pattern.stderr
│   │   ├── single_component_path_imports.fixed
│   │   ├── single_component_path_imports.rs
│   │   ├── single_component_path_imports.stderr
│   │   ├── single_component_path_imports_macro.rs
│   │   ├── single_component_path_imports_nested_first.rs
│   │   ├── single_component_path_imports_nested_first.stderr
│   │   ├── single_component_path_imports_self_after.rs
│   │   ├── single_component_path_imports_self_before.rs
│   │   ├── single_element_loop.fixed
│   │   ├── single_element_loop.rs
│   │   ├── single_element_loop.stderr
│   │   ├── single_match.fixed
│   │   ├── single_match.rs
│   │   ├── single_match.stderr
│   │   ├── single_match_else.fixed
│   │   ├── single_match_else.rs
│   │   ├── single_match_else.stderr
│   │   ├── single_match_else_deref_patterns.fixed
│   │   ├── single_match_else_deref_patterns.rs
│   │   ├── single_match_else_deref_patterns.stderr
│   │   ├── single_option_map.rs
│   │   ├── single_option_map.stderr
│   │   ├── single_range_in_vec_init.1.fixed
│   │   ├── single_range_in_vec_init.2.fixed
│   │   ├── single_range_in_vec_init.rs
│   │   ├── single_range_in_vec_init.stderr
│   │   ├── single_range_in_vec_init_unfixable.rs
│   │   ├── single_range_in_vec_init_unfixable.stderr
│   │   ├── size_of_in_element_count/
│   │   │   ├── expressions.rs
│   │   │   ├── expressions.stderr
│   │   │   ├── functions.rs
│   │   │   └── functions.stderr
│   │   ├── size_of_ref.rs
│   │   ├── size_of_ref.stderr
│   │   ├── skip_while_next.rs
│   │   ├── skip_while_next.stderr
│   │   ├── sliced_string_as_bytes.fixed
│   │   ├── sliced_string_as_bytes.rs
│   │   ├── sliced_string_as_bytes.stderr
│   │   ├── slow_vector_initialization.fixed
│   │   ├── slow_vector_initialization.rs
│   │   ├── slow_vector_initialization.stderr
│   │   ├── stable_sort_primitive.fixed
│   │   ├── stable_sort_primitive.rs
│   │   ├── stable_sort_primitive.stderr
│   │   ├── starts_ends_with.fixed
│   │   ├── starts_ends_with.rs
│   │   ├── starts_ends_with.stderr
│   │   ├── std_instead_of_core.fixed
│   │   ├── std_instead_of_core.rs
│   │   ├── std_instead_of_core.stderr
│   │   ├── std_instead_of_core_unfixable.rs
│   │   ├── std_instead_of_core_unfixable.stderr
│   │   ├── str_split.fixed
│   │   ├── str_split.rs
│   │   ├── str_split.stderr
│   │   ├── str_to_string.fixed
│   │   ├── str_to_string.rs
│   │   ├── str_to_string.stderr
│   │   ├── string_add.rs
│   │   ├── string_add.stderr
│   │   ├── string_add_assign.fixed
│   │   ├── string_add_assign.rs
│   │   ├── string_add_assign.stderr
│   │   ├── string_extend.fixed
│   │   ├── string_extend.rs
│   │   ├── string_extend.stderr
│   │   ├── string_from_utf8_as_bytes.fixed
│   │   ├── string_from_utf8_as_bytes.rs
│   │   ├── string_from_utf8_as_bytes.stderr
│   │   ├── string_lit_as_bytes.fixed
│   │   ├── string_lit_as_bytes.rs
│   │   ├── string_lit_as_bytes.stderr
│   │   ├── string_lit_chars_any.fixed
│   │   ├── string_lit_chars_any.rs
│   │   ├── string_lit_chars_any.stderr
│   │   ├── string_slice.rs
│   │   ├── string_slice.stderr
│   │   ├── strlen_on_c_strings.fixed
│   │   ├── strlen_on_c_strings.rs
│   │   ├── strlen_on_c_strings.stderr
│   │   ├── struct_excessive_bools.rs
│   │   ├── struct_excessive_bools.stderr
│   │   ├── struct_fields.rs
│   │   ├── struct_fields.stderr
│   │   ├── suspicious_arithmetic_impl.rs
│   │   ├── suspicious_arithmetic_impl.stderr
│   │   ├── suspicious_command_arg_space.fixed
│   │   ├── suspicious_command_arg_space.rs
│   │   ├── suspicious_command_arg_space.stderr
│   │   ├── suspicious_doc_comments.fixed
│   │   ├── suspicious_doc_comments.rs
│   │   ├── suspicious_doc_comments.stderr
│   │   ├── suspicious_doc_comments_unfixable.rs
│   │   ├── suspicious_doc_comments_unfixable.stderr
│   │   ├── suspicious_else_formatting.rs
│   │   ├── suspicious_else_formatting.stderr
│   │   ├── suspicious_map.rs
│   │   ├── suspicious_map.stderr
│   │   ├── suspicious_operation_groupings.fixed
│   │   ├── suspicious_operation_groupings.rs
│   │   ├── suspicious_operation_groupings.stderr
│   │   ├── suspicious_splitn.rs
│   │   ├── suspicious_splitn.stderr
│   │   ├── suspicious_to_owned.1.fixed
│   │   ├── suspicious_to_owned.2.fixed
│   │   ├── suspicious_to_owned.rs
│   │   ├── suspicious_to_owned.stderr
│   │   ├── suspicious_unary_op_formatting.rs
│   │   ├── suspicious_unary_op_formatting.stderr
│   │   ├── suspicious_xor_used_as_pow.rs
│   │   ├── suspicious_xor_used_as_pow.stderr
│   │   ├── swap.fixed
│   │   ├── swap.rs
│   │   ├── swap.stderr
│   │   ├── swap_ptr_to_ref.fixed
│   │   ├── swap_ptr_to_ref.rs
│   │   ├── swap_ptr_to_ref.stderr
│   │   ├── swap_ptr_to_ref_unfixable.rs
│   │   ├── swap_ptr_to_ref_unfixable.stderr
│   │   ├── swap_with_temporary.fixed
│   │   ├── swap_with_temporary.rs
│   │   ├── swap_with_temporary.stderr
│   │   ├── swap_with_temporary_unfixable.rs
│   │   ├── swap_with_temporary_unfixable.stderr
│   │   ├── tabs_in_doc_comments.fixed
│   │   ├── tabs_in_doc_comments.rs
│   │   ├── tabs_in_doc_comments.stderr
│   │   ├── temporary_assignment.rs
│   │   ├── temporary_assignment.stderr
│   │   ├── test_attr_in_doctest.rs
│   │   ├── test_attr_in_doctest.stderr
│   │   ├── tests_outside_test_module.rs
│   │   ├── tests_outside_test_module.stderr
│   │   ├── to_digit_is_some.fixed
│   │   ├── to_digit_is_some.rs
│   │   ├── to_digit_is_some.stderr
│   │   ├── to_string_trait_impl.rs
│   │   ├── to_string_trait_impl.stderr
│   │   ├── too_long_first_doc_paragraph-fix.fixed
│   │   ├── too_long_first_doc_paragraph-fix.rs
│   │   ├── too_long_first_doc_paragraph-fix.stderr
│   │   ├── too_long_first_doc_paragraph.rs
│   │   ├── too_long_first_doc_paragraph.stderr
│   │   ├── toplevel_ref_arg.fixed
│   │   ├── toplevel_ref_arg.rs
│   │   ├── toplevel_ref_arg.stderr
│   │   ├── toplevel_ref_arg_non_rustfix.rs
│   │   ├── toplevel_ref_arg_non_rustfix.stderr
│   │   ├── track-diagnostics-clippy.fixed
│   │   ├── track-diagnostics-clippy.rs
│   │   ├── track-diagnostics-clippy.stderr
│   │   ├── track-diagnostics.rs
│   │   ├── track-diagnostics.stderr
│   │   ├── trailing_empty_array.rs
│   │   ├── trailing_empty_array.stderr
│   │   ├── trailing_zeros.fixed
│   │   ├── trailing_zeros.rs
│   │   ├── trailing_zeros.stderr
│   │   ├── trait_duplication_in_bounds.fixed
│   │   ├── trait_duplication_in_bounds.rs
│   │   ├── trait_duplication_in_bounds.stderr
│   │   ├── trait_duplication_in_bounds_assoc_const_eq.fixed
│   │   ├── trait_duplication_in_bounds_assoc_const_eq.rs
│   │   ├── trait_duplication_in_bounds_assoc_const_eq.stderr
│   │   ├── trait_duplication_in_bounds_unfixable.rs
│   │   ├── trait_duplication_in_bounds_unfixable.stderr
│   │   ├── transmute.rs
│   │   ├── transmute.stderr
│   │   ├── transmute_32bit.rs
│   │   ├── transmute_32bit.stderr
│   │   ├── transmute_64bit.rs
│   │   ├── transmute_64bit.stderr
│   │   ├── transmute_collection.rs
│   │   ├── transmute_collection.stderr
│   │   ├── transmute_int_to_non_zero.fixed
│   │   ├── transmute_int_to_non_zero.rs
│   │   ├── transmute_int_to_non_zero.stderr
│   │   ├── transmute_null_to_fn.rs
│   │   ├── transmute_null_to_fn.stderr
│   │   ├── transmute_ptr_to_ptr.fixed
│   │   ├── transmute_ptr_to_ptr.rs
│   │   ├── transmute_ptr_to_ptr.stderr
│   │   ├── transmute_ptr_to_ref.fixed
│   │   ├── transmute_ptr_to_ref.rs
│   │   ├── transmute_ptr_to_ref.stderr
│   │   ├── transmute_ref_to_ref.fixed
│   │   ├── transmute_ref_to_ref.rs
│   │   ├── transmute_ref_to_ref.stderr
│   │   ├── transmute_ref_to_ref_no_std.fixed
│   │   ├── transmute_ref_to_ref_no_std.rs
│   │   ├── transmute_ref_to_ref_no_std.stderr
│   │   ├── transmute_undefined_repr.rs
│   │   ├── transmute_undefined_repr.stderr
│   │   ├── transmutes_expressible_as_ptr_casts.fixed
│   │   ├── transmutes_expressible_as_ptr_casts.rs
│   │   ├── transmutes_expressible_as_ptr_casts.stderr
│   │   ├── transmuting_null.rs
│   │   ├── transmuting_null.stderr
│   │   ├── trim_split_whitespace.fixed
│   │   ├── trim_split_whitespace.rs
│   │   ├── trim_split_whitespace.stderr
│   │   ├── trivially_copy_pass_by_ref.fixed
│   │   ├── trivially_copy_pass_by_ref.rs
│   │   ├── trivially_copy_pass_by_ref.stderr
│   │   ├── try_err.fixed
│   │   ├── try_err.rs
│   │   ├── try_err.stderr
│   │   ├── tuple_array_conversions.rs
│   │   ├── tuple_array_conversions.stderr
│   │   ├── ty_fn_sig.rs
│   │   ├── type_complexity.rs
│   │   ├── type_complexity.stderr
│   │   ├── type_id_on_box.fixed
│   │   ├── type_id_on_box.rs
│   │   ├── type_id_on_box.stderr
│   │   ├── type_id_on_box_unfixable.rs
│   │   ├── type_id_on_box_unfixable.stderr
│   │   ├── type_repetition_in_bounds.rs
│   │   ├── type_repetition_in_bounds.stderr
│   │   ├── unbuffered_bytes.rs
│   │   ├── unbuffered_bytes.stderr
│   │   ├── unchecked_time_subtraction.fixed
│   │   ├── unchecked_time_subtraction.rs
│   │   ├── unchecked_time_subtraction.stderr
│   │   ├── unchecked_time_subtraction_unfixable.rs
│   │   ├── unchecked_time_subtraction_unfixable.stderr
│   │   ├── unconditional_recursion.rs
│   │   ├── unconditional_recursion.stderr
│   │   ├── unicode.fixed
│   │   ├── unicode.rs
│   │   ├── unicode.stderr
│   │   ├── uninhabited_references.rs
│   │   ├── uninhabited_references.stderr
│   │   ├── uninit.rs
│   │   ├── uninit.stderr
│   │   ├── uninit_vec.rs
│   │   ├── uninit_vec.stderr
│   │   ├── uninlined_format_args.fixed
│   │   ├── uninlined_format_args.rs
│   │   ├── uninlined_format_args.stderr
│   │   ├── uninlined_format_args_panic.edition2018.fixed
│   │   ├── uninlined_format_args_panic.edition2018.stderr
│   │   ├── uninlined_format_args_panic.edition2021.fixed
│   │   ├── uninlined_format_args_panic.edition2021.stderr
│   │   ├── uninlined_format_args_panic.edition2024.fixed
│   │   ├── uninlined_format_args_panic.edition2024.stderr
│   │   ├── uninlined_format_args_panic.rs
│   │   ├── unit_arg.rs
│   │   ├── unit_arg.stderr
│   │   ├── unit_arg_fixable.fixed
│   │   ├── unit_arg_fixable.rs
│   │   ├── unit_arg_fixable.stderr
│   │   ├── unit_cmp.rs
│   │   ├── unit_cmp.stderr
│   │   ├── unit_hash.fixed
│   │   ├── unit_hash.rs
│   │   ├── unit_hash.stderr
│   │   ├── unit_return_expecting_ord.rs
│   │   ├── unit_return_expecting_ord.stderr
│   │   ├── unknown_attribute.rs
│   │   ├── unknown_attribute.stderr
│   │   ├── unknown_clippy_lints.fixed
│   │   ├── unknown_clippy_lints.rs
│   │   ├── unknown_clippy_lints.stderr
│   │   ├── unnecessary_box_returns.rs
│   │   ├── unnecessary_box_returns.stderr
│   │   ├── unnecessary_cast.fixed
│   │   ├── unnecessary_cast.rs
│   │   ├── unnecessary_cast.stderr
│   │   ├── unnecessary_cast_unfixable.rs
│   │   ├── unnecessary_cast_unfixable.stderr
│   │   ├── unnecessary_clippy_cfg.rs
│   │   ├── unnecessary_clippy_cfg.stderr
│   │   ├── unnecessary_fallible_conversions.fixed
│   │   ├── unnecessary_fallible_conversions.rs
│   │   ├── unnecessary_fallible_conversions.stderr
│   │   ├── unnecessary_fallible_conversions_unfixable.rs
│   │   ├── unnecessary_fallible_conversions_unfixable.stderr
│   │   ├── unnecessary_filter_map.rs
│   │   ├── unnecessary_filter_map.stderr
│   │   ├── unnecessary_find_map.rs
│   │   ├── unnecessary_find_map.stderr
│   │   ├── unnecessary_first_then_check.fixed
│   │   ├── unnecessary_first_then_check.rs
│   │   ├── unnecessary_first_then_check.stderr
│   │   ├── unnecessary_fold.fixed
│   │   ├── unnecessary_fold.rs
│   │   ├── unnecessary_fold.stderr
│   │   ├── unnecessary_get_then_check.fixed
│   │   ├── unnecessary_get_then_check.rs
│   │   ├── unnecessary_get_then_check.stderr
│   │   ├── unnecessary_iter_cloned.fixed
│   │   ├── unnecessary_iter_cloned.rs
│   │   ├── unnecessary_iter_cloned.stderr
│   │   ├── unnecessary_join.fixed
│   │   ├── unnecessary_join.rs
│   │   ├── unnecessary_join.stderr
│   │   ├── unnecessary_lazy_eval.fixed
│   │   ├── unnecessary_lazy_eval.rs
│   │   ├── unnecessary_lazy_eval.stderr
│   │   ├── unnecessary_lazy_eval_unfixable.rs
│   │   ├── unnecessary_lazy_eval_unfixable.stderr
│   │   ├── unnecessary_literal_bound.fixed
│   │   ├── unnecessary_literal_bound.rs
│   │   ├── unnecessary_literal_bound.stderr
│   │   ├── unnecessary_literal_unwrap.fixed
│   │   ├── unnecessary_literal_unwrap.rs
│   │   ├── unnecessary_literal_unwrap.stderr
│   │   ├── unnecessary_literal_unwrap_unfixable.rs
│   │   ├── unnecessary_literal_unwrap_unfixable.stderr
│   │   ├── unnecessary_map_on_constructor.fixed
│   │   ├── unnecessary_map_on_constructor.rs
│   │   ├── unnecessary_map_on_constructor.stderr
│   │   ├── unnecessary_map_or.fixed
│   │   ├── unnecessary_map_or.rs
│   │   ├── unnecessary_map_or.stderr
│   │   ├── unnecessary_min_or_max.fixed
│   │   ├── unnecessary_min_or_max.rs
│   │   ├── unnecessary_min_or_max.stderr
│   │   ├── unnecessary_mut_passed.fixed
│   │   ├── unnecessary_mut_passed.rs
│   │   ├── unnecessary_mut_passed.stderr
│   │   ├── unnecessary_operation.fixed
│   │   ├── unnecessary_operation.rs
│   │   ├── unnecessary_operation.stderr
│   │   ├── unnecessary_option_map_or_else.fixed
│   │   ├── unnecessary_option_map_or_else.rs
│   │   ├── unnecessary_option_map_or_else.stderr
│   │   ├── unnecessary_os_str_debug_formatting.rs
│   │   ├── unnecessary_os_str_debug_formatting.stderr
│   │   ├── unnecessary_owned_empty_strings.fixed
│   │   ├── unnecessary_owned_empty_strings.rs
│   │   ├── unnecessary_owned_empty_strings.stderr
│   │   ├── unnecessary_path_debug_formatting.rs
│   │   ├── unnecessary_path_debug_formatting.stderr
│   │   ├── unnecessary_result_map_or_else.fixed
│   │   ├── unnecessary_result_map_or_else.rs
│   │   ├── unnecessary_result_map_or_else.stderr
│   │   ├── unnecessary_safety_comment.rs
│   │   ├── unnecessary_safety_comment.stderr
│   │   ├── unnecessary_self_imports.fixed
│   │   ├── unnecessary_self_imports.rs
│   │   ├── unnecessary_self_imports.stderr
│   │   ├── unnecessary_semicolon.edition2021.fixed
│   │   ├── unnecessary_semicolon.edition2021.stderr
│   │   ├── unnecessary_semicolon.edition2024.fixed
│   │   ├── unnecessary_semicolon.edition2024.stderr
│   │   ├── unnecessary_semicolon.fixed
│   │   ├── unnecessary_semicolon.rs
│   │   ├── unnecessary_semicolon.stderr
│   │   ├── unnecessary_semicolon_feature_stmt_expr_attributes.fixed
│   │   ├── unnecessary_semicolon_feature_stmt_expr_attributes.rs
│   │   ├── unnecessary_semicolon_feature_stmt_expr_attributes.stderr
│   │   ├── unnecessary_sort_by.fixed
│   │   ├── unnecessary_sort_by.rs
│   │   ├── unnecessary_sort_by.stderr
│   │   ├── unnecessary_sort_by_no_core.rs
│   │   ├── unnecessary_sort_by_no_std.fixed
│   │   ├── unnecessary_sort_by_no_std.rs
│   │   ├── unnecessary_sort_by_no_std.stderr
│   │   ├── unnecessary_struct_initialization.fixed
│   │   ├── unnecessary_struct_initialization.rs
│   │   ├── unnecessary_struct_initialization.stderr
│   │   ├── unnecessary_to_owned.fixed
│   │   ├── unnecessary_to_owned.rs
│   │   ├── unnecessary_to_owned.stderr
│   │   ├── unnecessary_to_owned_on_split.fixed
│   │   ├── unnecessary_to_owned_on_split.rs
│   │   ├── unnecessary_to_owned_on_split.stderr
│   │   ├── unnecessary_trailing_comma.fixed
│   │   ├── unnecessary_trailing_comma.rs
│   │   ├── unnecessary_trailing_comma.stderr
│   │   ├── unnecessary_unsafety_doc.rs
│   │   ├── unnecessary_unsafety_doc.stderr
│   │   ├── unnecessary_wraps.rs
│   │   ├── unnecessary_wraps.stderr
│   │   ├── unneeded_field_pattern.rs
│   │   ├── unneeded_field_pattern.stderr
│   │   ├── unneeded_struct_pattern.fixed
│   │   ├── unneeded_struct_pattern.rs
│   │   ├── unneeded_struct_pattern.stderr
│   │   ├── unneeded_wildcard_pattern.fixed
│   │   ├── unneeded_wildcard_pattern.rs
│   │   ├── unneeded_wildcard_pattern.stderr
│   │   ├── unnested_or_patterns.fixed
│   │   ├── unnested_or_patterns.rs
│   │   ├── unnested_or_patterns.stderr
│   │   ├── unnested_or_patterns2.fixed
│   │   ├── unnested_or_patterns2.rs
│   │   ├── unnested_or_patterns2.stderr
│   │   ├── unreadable_literal.fixed
│   │   ├── unreadable_literal.rs
│   │   ├── unreadable_literal.stderr
│   │   ├── unsafe_derive_deserialize.rs
│   │   ├── unsafe_derive_deserialize.stderr
│   │   ├── unsafe_removed_from_name.rs
│   │   ├── unsafe_removed_from_name.stderr
│   │   ├── unseparated_prefix_literals.fixed
│   │   ├── unseparated_prefix_literals.rs
│   │   ├── unseparated_prefix_literals.stderr
│   │   ├── unused_async.rs
│   │   ├── unused_async.stderr
│   │   ├── unused_enumerate_index.fixed
│   │   ├── unused_enumerate_index.rs
│   │   ├── unused_enumerate_index.stderr
│   │   ├── unused_format_specs.1.fixed
│   │   ├── unused_format_specs.2.fixed
│   │   ├── unused_format_specs.rs
│   │   ├── unused_format_specs.stderr
│   │   ├── unused_io_amount.rs
│   │   ├── unused_io_amount.stderr
│   │   ├── unused_peekable.rs
│   │   ├── unused_peekable.stderr
│   │   ├── unused_result_ok.fixed
│   │   ├── unused_result_ok.rs
│   │   ├── unused_result_ok.stderr
│   │   ├── unused_rounding.fixed
│   │   ├── unused_rounding.rs
│   │   ├── unused_rounding.stderr
│   │   ├── unused_self.rs
│   │   ├── unused_self.stderr
│   │   ├── unused_trait_names.fixed
│   │   ├── unused_trait_names.rs
│   │   ├── unused_trait_names.stderr
│   │   ├── unused_unit.edition2021.fixed
│   │   ├── unused_unit.edition2021.stderr
│   │   ├── unused_unit.edition2024.fixed
│   │   ├── unused_unit.edition2024.stderr
│   │   ├── unused_unit.fixed
│   │   ├── unused_unit.rs
│   │   ├── unused_unit.stderr
│   │   ├── unwrap_expect_used.rs
│   │   ├── unwrap_expect_used.stderr
│   │   ├── unwrap_in_result.rs
│   │   ├── unwrap_in_result.stderr
│   │   ├── unwrap_or.fixed
│   │   ├── unwrap_or.rs
│   │   ├── unwrap_or.stderr
│   │   ├── unwrap_or_else_default.fixed
│   │   ├── unwrap_or_else_default.rs
│   │   ├── unwrap_or_else_default.stderr
│   │   ├── update-all-references.sh
│   │   ├── upper_case_acronyms.fixed
│   │   ├── upper_case_acronyms.rs
│   │   ├── upper_case_acronyms.stderr
│   │   ├── use_debug.rs
│   │   ├── use_debug.stderr
│   │   ├── use_self.fixed
│   │   ├── use_self.rs
│   │   ├── use_self.stderr
│   │   ├── use_self_structs.fixed
│   │   ├── use_self_structs.rs
│   │   ├── use_self_structs.stderr
│   │   ├── use_self_trait.fixed
│   │   ├── use_self_trait.rs
│   │   ├── use_self_trait.stderr
│   │   ├── used_underscore_binding.rs
│   │   ├── used_underscore_binding.stderr
│   │   ├── used_underscore_items.rs
│   │   ├── used_underscore_items.stderr
│   │   ├── useful_asref.rs
│   │   ├── useless_asref.fixed
│   │   ├── useless_asref.rs
│   │   ├── useless_asref.stderr
│   │   ├── useless_attribute.fixed
│   │   ├── useless_attribute.rs
│   │   ├── useless_attribute.stderr
│   │   ├── useless_concat.fixed
│   │   ├── useless_concat.rs
│   │   ├── useless_concat.stderr
│   │   ├── useless_conversion.fixed
│   │   ├── useless_conversion.rs
│   │   ├── useless_conversion.stderr
│   │   ├── useless_conversion_try.rs
│   │   ├── useless_conversion_try.stderr
│   │   ├── useless_nonzero_new_unchecked.fixed
│   │   ├── useless_nonzero_new_unchecked.rs
│   │   ├── useless_nonzero_new_unchecked.stderr
│   │   ├── useless_vec.fixed
│   │   ├── useless_vec.rs
│   │   ├── useless_vec.stderr
│   │   ├── useless_vec_unfixable.rs
│   │   ├── useless_vec_unfixable.stderr
│   │   ├── vec_box_sized.rs
│   │   ├── vec_box_sized.stderr
│   │   ├── vec_init_then_push.rs
│   │   ├── vec_init_then_push.stderr
│   │   ├── vec_resize_to_zero.fixed
│   │   ├── vec_resize_to_zero.rs
│   │   ├── vec_resize_to_zero.stderr
│   │   ├── verbose_file_reads.rs
│   │   ├── verbose_file_reads.stderr
│   │   ├── volatile_composites.rs
│   │   ├── volatile_composites.stderr
│   │   ├── waker_clone_wake.fixed
│   │   ├── waker_clone_wake.rs
│   │   ├── waker_clone_wake.stderr
│   │   ├── while_float.rs
│   │   ├── while_float.stderr
│   │   ├── while_immutable_condition.rs
│   │   ├── while_immutable_condition.stderr
│   │   ├── while_let_loop.rs
│   │   ├── while_let_loop.stderr
│   │   ├── while_let_on_iterator.fixed
│   │   ├── while_let_on_iterator.rs
│   │   ├── while_let_on_iterator.stderr
│   │   ├── wild_in_or_pats.rs
│   │   ├── wild_in_or_pats.stderr
│   │   ├── wildcard_enum_match_arm.fixed
│   │   ├── wildcard_enum_match_arm.rs
│   │   ├── wildcard_enum_match_arm.stderr
│   │   ├── wildcard_imports.fixed
│   │   ├── wildcard_imports.rs
│   │   ├── wildcard_imports.stderr
│   │   ├── wildcard_imports_2021.edition2018.fixed
│   │   ├── wildcard_imports_2021.edition2018.stderr
│   │   ├── wildcard_imports_2021.edition2021.fixed
│   │   ├── wildcard_imports_2021.edition2021.stderr
│   │   ├── wildcard_imports_2021.rs
│   │   ├── wildcard_imports_cfgtest.rs
│   │   ├── write_literal.fixed
│   │   ├── write_literal.rs
│   │   ├── write_literal.stderr
│   │   ├── write_literal_unfixable.rs
│   │   ├── write_literal_unfixable.stderr
│   │   ├── write_with_newline.fixed
│   │   ├── write_with_newline.rs
│   │   ├── write_with_newline.stderr
│   │   ├── writeln_empty_string.fixed
│   │   ├── writeln_empty_string.rs
│   │   ├── writeln_empty_string.stderr
│   │   ├── writeln_empty_string_unfixable.rs
│   │   ├── writeln_empty_string_unfixable.stderr
│   │   ├── wrong_self_convention.rs
│   │   ├── wrong_self_convention.stderr
│   │   ├── wrong_self_convention2.rs
│   │   ├── wrong_self_convention2.stderr
│   │   ├── wrong_self_conventions_mut.rs
│   │   ├── wrong_self_conventions_mut.stderr
│   │   ├── zero_div_zero.rs
│   │   ├── zero_div_zero.stderr
│   │   ├── zero_offset.rs
│   │   ├── zero_offset.stderr
│   │   ├── zero_ptr.fixed
│   │   ├── zero_ptr.rs
│   │   ├── zero_ptr.stderr
│   │   ├── zero_ptr_no_std.fixed
│   │   ├── zero_ptr_no_std.rs
│   │   ├── zero_ptr_no_std.stderr
│   │   ├── zero_repeat_side_effects.fixed
│   │   ├── zero_repeat_side_effects.rs
│   │   ├── zero_repeat_side_effects.stderr
│   │   ├── zero_repeat_side_effects_never_pattern.fixed
│   │   ├── zero_repeat_side_effects_never_pattern.rs
│   │   ├── zero_repeat_side_effects_never_pattern.stderr
│   │   ├── zero_repeat_side_effects_unfixable.rs
│   │   ├── zero_repeat_side_effects_unfixable.stderr
│   │   ├── zero_sized_btreemap_values.rs
│   │   ├── zero_sized_btreemap_values.stderr
│   │   ├── zero_sized_hashmap_values.rs
│   │   ├── zero_sized_hashmap_values.stderr
│   │   ├── zombie_processes.rs
│   │   ├── zombie_processes.stderr
│   │   ├── zombie_processes_fixable.fixed
│   │   ├── zombie_processes_fixable.rs
│   │   ├── zombie_processes_fixable.stderr
│   │   └── {literal_string_with_formatting_args}.rs
│   ├── ui-cargo/
│   │   ├── cargo_common_metadata/
│   │   │   ├── fail/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── fail_publish/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── fail_publish_true/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── pass/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── pass_publish_empty/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   └── pass_publish_false/
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           └── main.rs
│   │   ├── cargo_rust_version/
│   │   │   ├── fail_both_diff/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── fail_both_same/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── fail_cargo/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── fail_clippy/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── fail_file_attr/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── pass_both_same/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── pass_cargo/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── pass_clippy/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── pass_file_attr/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   └── warn_both_diff/
│   │   │       ├── Cargo.stderr
│   │   │       ├── Cargo.toml
│   │   │       ├── clippy.toml
│   │   │       └── src/
│   │   │           └── main.rs
│   │   ├── duplicate_mod/
│   │   │   └── fail/
│   │   │       ├── Cargo.stderr
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           ├── a.rs
│   │   │           ├── b.rs
│   │   │           ├── c.rs
│   │   │           ├── d.rs
│   │   │           ├── from_other_module.rs
│   │   │           ├── main.rs
│   │   │           └── other_module/
│   │   │               └── mod.rs
│   │   ├── feature_name/
│   │   │   ├── fail/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   └── pass/
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           └── main.rs
│   │   ├── lint_groups_priority/
│   │   │   ├── fail/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── lib.rs
│   │   │   └── pass/
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           └── lib.rs
│   │   ├── module_style/
│   │   │   ├── duplicated_mod_names_14697/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       ├── foo/
│   │   │   │       │   └── bar.rs
│   │   │   │       ├── foo.rs
│   │   │   │       ├── lib.rs
│   │   │   │       └── other/
│   │   │   │           ├── foo/
│   │   │   │           │   └── mod.rs
│   │   │   │           └── mod.rs
│   │   │   ├── fail_mod/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       ├── bad/
│   │   │   │       │   ├── inner/
│   │   │   │       │   │   ├── stuff/
│   │   │   │       │   │   │   └── most.rs
│   │   │   │       │   │   └── stuff.rs
│   │   │   │       │   ├── inner.rs
│   │   │   │       │   └── mod.rs
│   │   │   │       └── main.rs
│   │   │   ├── fail_mod_remap/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       ├── bad/
│   │   │   │       │   └── inner.rs
│   │   │   │       ├── bad.rs
│   │   │   │       └── main.rs
│   │   │   ├── fail_no_mod/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       ├── bad/
│   │   │   │       │   └── mod.rs
│   │   │   │       └── main.rs
│   │   │   ├── pass_mod/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       ├── bad/
│   │   │   │       │   └── mod.rs
│   │   │   │       ├── main.rs
│   │   │   │       └── more/
│   │   │   │           ├── foo.rs
│   │   │   │           ├── inner/
│   │   │   │           │   └── mod.rs
│   │   │   │           └── mod.rs
│   │   │   ├── pass_no_mod/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       ├── good.rs
│   │   │   │       └── main.rs
│   │   │   ├── segment_with_mod_name_10271_11916/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── foo/
│   │   │   │   │   └── bar/
│   │   │   │   │       ├── Cargo.toml
│   │   │   │   │       └── src/
│   │   │   │   │           ├── foo.rs
│   │   │   │   │           └── lib.rs
│   │   │   │   └── src/
│   │   │   │       └── lib.rs
│   │   │   ├── with_path_attr_mod/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       ├── bar/
│   │   │   │       │   └── mod.rs
│   │   │   │       └── lib.rs
│   │   │   └── with_path_attr_no_mod/
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           ├── bar.rs
│   │   │           ├── foo.rs
│   │   │           └── lib.rs
│   │   ├── multiple_config_files/
│   │   │   ├── no_warn/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   └── warn/
│   │   │       ├── .clippy.toml
│   │   │       ├── Cargo.stderr
│   │   │       ├── Cargo.toml
│   │   │       ├── clippy.toml
│   │   │       └── src/
│   │   │           └── main.rs
│   │   ├── multiple_crate_versions/
│   │   │   ├── 12145_with_dashes/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── 12176_allow_duplicate_crates/
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── 5041_allow_dev_build/
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── fail/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   └── pass/
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           └── main.rs
│   │   ├── multiple_inherent_impl/
│   │   │   ├── config_fail/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       └── main.rs
│   │   │   ├── crate_fail/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       ├── b.rs
│   │   │   │       └── main.rs
│   │   │   ├── file_fail/
│   │   │   │   ├── Cargo.stderr
│   │   │   │   ├── Cargo.toml
│   │   │   │   ├── clippy.toml
│   │   │   │   └── src/
│   │   │   │       ├── c.rs
│   │   │   │       └── main.rs
│   │   │   └── module_fail/
│   │   │       ├── Cargo.stderr
│   │   │       ├── Cargo.toml
│   │   │       ├── clippy.toml
│   │   │       └── src/
│   │   │           ├── c.rs
│   │   │           └── main.rs
│   │   ├── undocumented_unsafe_blocks/
│   │   │   └── fail/
│   │   │       ├── Cargo.stderr
│   │   │       ├── Cargo.toml
│   │   │       └── src/
│   │   │           └── main.rs
│   │   ├── update-all-references.sh
│   │   └── wildcard_dependencies/
│   │       ├── fail/
│   │       │   ├── Cargo.stderr
│   │       │   ├── Cargo.toml
│   │       │   └── src/
│   │       │       └── main.rs
│   │       └── pass/
│   │           ├── Cargo.toml
│   │           └── src/
│   │               └── main.rs
│   ├── ui-internal/
│   │   ├── check_clippy_version_attribute.rs
│   │   ├── check_clippy_version_attribute.stderr
│   │   ├── check_formulation.rs
│   │   ├── check_formulation.stderr
│   │   ├── collapsible_span_lint_calls.fixed
│   │   ├── collapsible_span_lint_calls.rs
│   │   ├── collapsible_span_lint_calls.stderr
│   │   ├── custom_ice_message.rs
│   │   ├── custom_ice_message.stderr
│   │   ├── default_lint.rs
│   │   ├── default_lint.stderr
│   │   ├── derive_deserialize_allowing_unknown.rs
│   │   ├── derive_deserialize_allowing_unknown.stderr
│   │   ├── disallow_span_lint.rs
│   │   ├── disallow_span_lint.stderr
│   │   ├── interning_literals.fixed
│   │   ├── interning_literals.rs
│   │   ├── interning_literals.stderr
│   │   ├── interning_literals_unfixable.rs
│   │   ├── interning_literals_unfixable.stderr
│   │   ├── invalid_msrv_attr_impl.fixed
│   │   ├── invalid_msrv_attr_impl.rs
│   │   ├── invalid_msrv_attr_impl.stderr
│   │   ├── lint_without_lint_pass.rs
│   │   ├── lint_without_lint_pass.stderr
│   │   ├── outer_expn_data.fixed
│   │   ├── outer_expn_data.rs
│   │   ├── outer_expn_data.stderr
│   │   ├── repeated_is_diagnostic_item.fixed
│   │   ├── repeated_is_diagnostic_item.rs
│   │   ├── repeated_is_diagnostic_item.stderr
│   │   ├── repeated_is_diagnostic_item_unfixable.rs
│   │   ├── repeated_is_diagnostic_item_unfixable.stderr
│   │   ├── symbol_as_str.fixed
│   │   ├── symbol_as_str.rs
│   │   ├── symbol_as_str.stderr
│   │   ├── symbol_as_str_unfixable.rs
│   │   ├── symbol_as_str_unfixable.stderr
│   │   ├── unnecessary_def_path.rs
│   │   └── unnecessary_def_path.stderr
│   ├── ui-toml/
│   │   ├── absolute_paths/
│   │   │   ├── absolute_paths.allow_crates.stderr
│   │   │   ├── absolute_paths.allow_long.stderr
│   │   │   ├── absolute_paths.default.stderr
│   │   │   ├── absolute_paths.no_short.stderr
│   │   │   ├── absolute_paths.rs
│   │   │   ├── absolute_paths_2015.default.stderr
│   │   │   ├── absolute_paths_2015.rs
│   │   │   ├── allow_crates/
│   │   │   │   └── clippy.toml
│   │   │   ├── allow_long/
│   │   │   │   └── clippy.toml
│   │   │   ├── default/
│   │   │   │   └── clippy.toml
│   │   │   └── no_short/
│   │   │       └── clippy.toml
│   │   ├── allow_mixed_uninlined_format_args/
│   │   │   ├── clippy.toml
│   │   │   ├── uninlined_format_args.fixed
│   │   │   ├── uninlined_format_args.rs
│   │   │   └── uninlined_format_args.stderr
│   │   ├── arbitrary_source_item_ordering/
│   │   │   ├── bad_conf_1/
│   │   │   │   └── clippy.toml
│   │   │   ├── bad_conf_2/
│   │   │   │   └── clippy.toml
│   │   │   ├── bad_conf_3/
│   │   │   │   └── clippy.toml
│   │   │   ├── bad_conf_4/
│   │   │   │   └── clippy.toml
│   │   │   ├── bad_conf_5/
│   │   │   │   └── clippy.toml
│   │   │   ├── bad_conf_6/
│   │   │   │   └── clippy.toml
│   │   │   ├── default/
│   │   │   │   └── clippy.toml
│   │   │   ├── default_exp/
│   │   │   │   └── clippy.toml
│   │   │   ├── only_enum/
│   │   │   │   └── clippy.toml
│   │   │   ├── only_impl/
│   │   │   │   └── clippy.toml
│   │   │   ├── only_trait/
│   │   │   │   └── clippy.toml
│   │   │   ├── ord_in_2/
│   │   │   │   └── clippy.toml
│   │   │   ├── ord_in_3/
│   │   │   │   └── clippy.toml
│   │   │   ├── ord_within/
│   │   │   │   └── clippy.toml
│   │   │   ├── ordering_good.bad_conf_1.stderr
│   │   │   ├── ordering_good.bad_conf_2.stderr
│   │   │   ├── ordering_good.bad_conf_3.stderr
│   │   │   ├── ordering_good.bad_conf_4.stderr
│   │   │   ├── ordering_good.bad_conf_5.stderr
│   │   │   ├── ordering_good.bad_conf_6.stderr
│   │   │   ├── ordering_good.rs
│   │   │   ├── ordering_good_var_1.rs
│   │   │   ├── ordering_mixed.default.stderr
│   │   │   ├── ordering_mixed.default_exp.stderr
│   │   │   ├── ordering_mixed.ord_within.stderr
│   │   │   ├── ordering_mixed.rs
│   │   │   ├── ordering_mixed_var_1.rs
│   │   │   ├── ordering_mixed_var_1.var_1.stderr
│   │   │   ├── ordering_only_enum.only_enum.stderr
│   │   │   ├── ordering_only_enum.rs
│   │   │   ├── ordering_only_impl.only_impl.stderr
│   │   │   ├── ordering_only_impl.rs
│   │   │   ├── ordering_only_trait.only_trait.stderr
│   │   │   ├── ordering_only_trait.rs
│   │   │   ├── selective_ordering.default.stderr
│   │   │   ├── selective_ordering.ord_in_2.stderr
│   │   │   ├── selective_ordering.ord_in_3.stderr
│   │   │   ├── selective_ordering.ord_within.stderr
│   │   │   ├── selective_ordering.rs
│   │   │   └── var_1/
│   │   │       └── clippy.toml
│   │   ├── arithmetic_side_effects_allowed/
│   │   │   ├── arithmetic_side_effects_allowed.rs
│   │   │   ├── arithmetic_side_effects_allowed.stderr
│   │   │   └── clippy.toml
│   │   ├── array_size_threshold/
│   │   │   ├── array_size_threshold.rs
│   │   │   ├── array_size_threshold.stderr
│   │   │   └── clippy.toml
│   │   ├── await_holding_invalid_type/
│   │   │   ├── await_holding_invalid_type.rs
│   │   │   ├── await_holding_invalid_type.stderr
│   │   │   └── clippy.toml
│   │   ├── await_holding_invalid_type_with_replacement/
│   │   │   ├── await_holding_invalid_type.rs
│   │   │   ├── await_holding_invalid_type.stderr
│   │   │   └── clippy.toml
│   │   ├── bad_toml/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_bad_toml.rs
│   │   │   └── conf_bad_toml.stderr
│   │   ├── bad_toml_type/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_bad_type.rs
│   │   │   └── conf_bad_type.stderr
│   │   ├── borrow_interior_mutable_const/
│   │   │   ├── clippy.toml
│   │   │   └── ignore.rs
│   │   ├── check_incompatible_msrv_in_tests/
│   │   │   ├── check_incompatible_msrv_in_tests.default.stderr
│   │   │   ├── check_incompatible_msrv_in_tests.enabled.stderr
│   │   │   ├── check_incompatible_msrv_in_tests.rs
│   │   │   ├── default/
│   │   │   │   └── clippy.toml
│   │   │   └── enabled/
│   │   │       └── clippy.toml
│   │   ├── collapsible_if/
│   │   │   ├── clippy.toml
│   │   │   ├── collapsible_else_if.fixed
│   │   │   ├── collapsible_else_if.rs
│   │   │   ├── collapsible_else_if.stderr
│   │   │   ├── collapsible_if.fixed
│   │   │   ├── collapsible_if.rs
│   │   │   ├── collapsible_if.stderr
│   │   │   ├── collapsible_if_let_chains.fixed
│   │   │   ├── collapsible_if_let_chains.rs
│   │   │   └── collapsible_if_let_chains.stderr
│   │   ├── conf_deprecated_key/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_deprecated_key.rs
│   │   │   └── conf_deprecated_key.stderr
│   │   ├── dbg_macro/
│   │   │   ├── clippy.toml
│   │   │   ├── dbg_macro.fixed
│   │   │   ├── dbg_macro.rs
│   │   │   └── dbg_macro.stderr
│   │   ├── decimal_literal_representation/
│   │   │   ├── clippy.toml
│   │   │   ├── decimal_literal_representation.fixed
│   │   │   ├── decimal_literal_representation.rs
│   │   │   └── decimal_literal_representation.stderr
│   │   ├── declare_interior_mutable_const/
│   │   │   ├── clippy.toml
│   │   │   └── ignore.rs
│   │   ├── disallowed_macros/
│   │   │   ├── auxiliary/
│   │   │   │   ├── macros.rs
│   │   │   │   └── proc_macros.rs
│   │   │   ├── clippy.toml
│   │   │   ├── disallowed_macros.rs
│   │   │   └── disallowed_macros.stderr
│   │   ├── disallowed_names_append/
│   │   │   ├── clippy.toml
│   │   │   ├── disallowed_names.rs
│   │   │   └── disallowed_names.stderr
│   │   ├── disallowed_names_replace/
│   │   │   ├── clippy.toml
│   │   │   ├── disallowed_names.rs
│   │   │   └── disallowed_names.stderr
│   │   ├── disallowed_script_idents/
│   │   │   ├── clippy.toml
│   │   │   ├── disallowed_script_idents.rs
│   │   │   └── disallowed_script_idents.stderr
│   │   ├── doc_valid_idents_append/
│   │   │   ├── clippy.toml
│   │   │   ├── doc_markdown.fixed
│   │   │   ├── doc_markdown.rs
│   │   │   └── doc_markdown.stderr
│   │   ├── doc_valid_idents_replace/
│   │   │   ├── clippy.toml
│   │   │   ├── doc_markdown.fixed
│   │   │   ├── doc_markdown.rs
│   │   │   └── doc_markdown.stderr
│   │   ├── duplicated_keys/
│   │   │   ├── clippy.toml
│   │   │   ├── duplicated_keys.rs
│   │   │   └── duplicated_keys.stderr
│   │   ├── duplicated_keys_deprecated/
│   │   │   ├── clippy.toml
│   │   │   ├── duplicated_keys.rs
│   │   │   └── duplicated_keys.stderr
│   │   ├── duplicated_keys_deprecated_2/
│   │   │   ├── clippy.toml
│   │   │   ├── duplicated_keys.rs
│   │   │   └── duplicated_keys.stderr
│   │   ├── enum_variant_size/
│   │   │   ├── clippy.toml
│   │   │   ├── enum_variant_size.fixed
│   │   │   ├── enum_variant_size.rs
│   │   │   └── enum_variant_size.stderr
│   │   ├── excessive_nesting/
│   │   │   ├── clippy.toml
│   │   │   ├── excessive_nesting.rs
│   │   │   └── excessive_nesting.stderr
│   │   ├── excessive_precision/
│   │   │   ├── clippy.toml
│   │   │   ├── excessive_precision.fixed
│   │   │   ├── excessive_precision.rs
│   │   │   └── excessive_precision.stderr
│   │   ├── expect_used/
│   │   │   ├── clippy.toml
│   │   │   ├── expect_used.rs
│   │   │   └── expect_used.stderr
│   │   ├── explicit_iter_loop/
│   │   │   ├── clippy.toml
│   │   │   ├── explicit_iter_loop.fixed
│   │   │   ├── explicit_iter_loop.rs
│   │   │   └── explicit_iter_loop.stderr
│   │   ├── extra_unused_type_parameters/
│   │   │   ├── clippy.toml
│   │   │   └── extra_unused_type_parameters.rs
│   │   ├── fn_params_excessive_bools/
│   │   │   ├── clippy.toml
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── functions_maxlines/
│   │   │   ├── clippy.toml
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── good_toml_no_false_negatives/
│   │   │   ├── clippy.toml
│   │   │   └── conf_no_false_negatives.rs
│   │   ├── ifs_same_cond/
│   │   │   ├── clippy.toml
│   │   │   ├── ifs_same_cond.rs
│   │   │   └── ifs_same_cond.stderr
│   │   ├── impl_trait_in_params/
│   │   │   ├── clippy.toml
│   │   │   ├── impl_trait_in_params.rs
│   │   │   └── impl_trait_in_params.stderr
│   │   ├── indexing_slicing/
│   │   │   ├── clippy.toml
│   │   │   ├── indexing_slicing.rs
│   │   │   └── indexing_slicing.stderr
│   │   ├── invalid_min_rust_version/
│   │   │   ├── clippy.toml
│   │   │   ├── invalid_min_rust_version.rs
│   │   │   └── invalid_min_rust_version.stderr
│   │   ├── item_name_repetitions/
│   │   │   ├── allow_exact_repetitions/
│   │   │   │   ├── clippy.toml
│   │   │   │   ├── item_name_repetitions.rs
│   │   │   │   └── item_name_repetitions.stderr
│   │   │   ├── allowed_prefixes/
│   │   │   │   ├── clippy.toml
│   │   │   │   ├── item_name_repetitions.rs
│   │   │   │   └── item_name_repetitions.stderr
│   │   │   ├── allowed_prefixes_extend/
│   │   │   │   ├── clippy.toml
│   │   │   │   ├── item_name_repetitions.rs
│   │   │   │   └── item_name_repetitions.stderr
│   │   │   ├── threshold0/
│   │   │   │   ├── clippy.toml
│   │   │   │   └── item_name_repetitions.rs
│   │   │   └── threshold5/
│   │   │       ├── clippy.toml
│   │   │       ├── item_name_repetitions.rs
│   │   │       └── item_name_repetitions.stderr
│   │   ├── large_futures/
│   │   │   ├── clippy.toml
│   │   │   ├── large_futures.fixed
│   │   │   ├── large_futures.rs
│   │   │   └── large_futures.stderr
│   │   ├── large_include_file/
│   │   │   ├── clippy.toml
│   │   │   ├── empty.txt
│   │   │   ├── large_include_file.rs
│   │   │   ├── large_include_file.stderr
│   │   │   └── too_big.txt
│   │   ├── large_stack_frames/
│   │   │   ├── clippy.toml
│   │   │   ├── large_stack_frames.rs
│   │   │   └── large_stack_frames.stderr
│   │   ├── large_stack_frames_for_macros/
│   │   │   ├── clippy.toml
│   │   │   ├── large_stack_frames.rs
│   │   │   └── large_stack_frames.stderr
│   │   ├── large_stack_frames_for_special_targets/
│   │   │   ├── clippy.toml
│   │   │   └── large_stack_frames.rs
│   │   ├── large_types_passed_by_value/
│   │   │   ├── clippy.toml
│   │   │   ├── large_types_passed_by_value.fixed
│   │   │   ├── large_types_passed_by_value.rs
│   │   │   └── large_types_passed_by_value.stderr
│   │   ├── lint_decimal_readability/
│   │   │   ├── clippy.toml
│   │   │   ├── test.fixed
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── macro_metavars_in_unsafe/
│   │   │   ├── default/
│   │   │   │   ├── test.rs
│   │   │   │   └── test.stderr
│   │   │   └── private/
│   │   │       ├── clippy.toml
│   │   │       ├── test.rs
│   │   │       └── test.stderr
│   │   ├── manual_let_else/
│   │   │   ├── clippy.toml
│   │   │   ├── manual_let_else.fixed
│   │   │   ├── manual_let_else.rs
│   │   │   └── manual_let_else.stderr
│   │   ├── max_suggested_slice_pattern_length/
│   │   │   ├── clippy.toml
│   │   │   ├── index_refutable_slice.fixed
│   │   │   ├── index_refutable_slice.rs
│   │   │   └── index_refutable_slice.stderr
│   │   ├── min_ident_chars/
│   │   │   ├── auxiliary/
│   │   │   │   └── extern_types.rs
│   │   │   ├── clippy.toml
│   │   │   ├── min_ident_chars.rs
│   │   │   └── min_ident_chars.stderr
│   │   ├── min_rust_version/
│   │   │   ├── clippy.toml
│   │   │   ├── min_rust_version.fixed
│   │   │   ├── min_rust_version.rs
│   │   │   └── min_rust_version.stderr
│   │   ├── missing_docs_in_private_items/
│   │   │   ├── allow_unused/
│   │   │   │   └── clippy.toml
│   │   │   ├── crate_root/
│   │   │   │   └── clippy.toml
│   │   │   ├── default/
│   │   │   │   └── clippy.toml
│   │   │   ├── missing_docs_in_private_items.allow_unused.stderr
│   │   │   ├── missing_docs_in_private_items.crate_root.stderr
│   │   │   ├── missing_docs_in_private_items.default.stderr
│   │   │   └── missing_docs_in_private_items.rs
│   │   ├── missing_enforced_import_rename/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_missing_enforced_import_rename.fixed
│   │   │   ├── conf_missing_enforced_import_rename.rs
│   │   │   └── conf_missing_enforced_import_rename.stderr
│   │   ├── module_inception/
│   │   │   ├── clippy.toml
│   │   │   ├── module_inception.rs
│   │   │   └── module_inception.stderr
│   │   ├── modulo_arithmetic/
│   │   │   ├── clippy.toml
│   │   │   ├── modulo_arithmetic.rs
│   │   │   └── modulo_arithmetic.stderr
│   │   ├── mut_key/
│   │   │   ├── clippy.toml
│   │   │   └── mut_key.rs
│   │   ├── needless_pass_by_ref_mut/
│   │   │   ├── clippy.toml
│   │   │   ├── needless_pass_by_ref_mut.fixed
│   │   │   ├── needless_pass_by_ref_mut.rs
│   │   │   └── needless_pass_by_ref_mut.stderr
│   │   ├── needless_raw_string_hashes_one_allowed/
│   │   │   ├── clippy.toml
│   │   │   ├── needless_raw_string_hashes.fixed
│   │   │   ├── needless_raw_string_hashes.rs
│   │   │   └── needless_raw_string_hashes.stderr
│   │   ├── nonstandard_macro_braces/
│   │   │   ├── auxiliary/
│   │   │   │   └── proc_macro_derive.rs
│   │   │   ├── clippy.toml
│   │   │   ├── conf_nonstandard_macro_braces.fixed
│   │   │   ├── conf_nonstandard_macro_braces.rs
│   │   │   └── conf_nonstandard_macro_braces.stderr
│   │   ├── panic/
│   │   │   ├── clippy.toml
│   │   │   ├── panic.rs
│   │   │   └── panic.stderr
│   │   ├── path_ends_with_ext/
│   │   │   ├── clippy.toml
│   │   │   └── path_ends_with_ext.rs
│   │   ├── print_macro/
│   │   │   ├── clippy.toml
│   │   │   ├── print_macro.rs
│   │   │   └── print_macro.stderr
│   │   ├── private-doc-errors/
│   │   │   ├── clippy.toml
│   │   │   ├── doc_lints.rs
│   │   │   └── doc_lints.stderr
│   │   ├── pub_underscore_fields/
│   │   │   ├── all_pub_fields/
│   │   │   │   └── clippy.toml
│   │   │   ├── exported/
│   │   │   │   └── clippy.toml
│   │   │   ├── pub_underscore_fields.all_pub_fields.stderr
│   │   │   ├── pub_underscore_fields.exported.stderr
│   │   │   └── pub_underscore_fields.rs
│   │   ├── ref_option/
│   │   │   ├── all/
│   │   │   │   └── clippy.toml
│   │   │   ├── private/
│   │   │   │   └── clippy.toml
│   │   │   ├── ref_option.all.fixed
│   │   │   ├── ref_option.all.stderr
│   │   │   ├── ref_option.private.fixed
│   │   │   ├── ref_option.private.stderr
│   │   │   ├── ref_option.rs
│   │   │   ├── ref_option_traits.all.stderr
│   │   │   ├── ref_option_traits.private.stderr
│   │   │   └── ref_option_traits.rs
│   │   ├── renamed_function_params/
│   │   │   ├── default/
│   │   │   │   └── clippy.toml
│   │   │   ├── extend/
│   │   │   │   └── clippy.toml
│   │   │   ├── renamed_function_params.default.stderr
│   │   │   ├── renamed_function_params.extend.stderr
│   │   │   └── renamed_function_params.rs
│   │   ├── replaceable_disallowed_types/
│   │   │   ├── clippy.toml
│   │   │   ├── replaceable_disallowed_types.fixed
│   │   │   ├── replaceable_disallowed_types.rs
│   │   │   └── replaceable_disallowed_types.stderr
│   │   ├── result_large_err/
│   │   │   ├── clippy.toml
│   │   │   ├── result_large_err.rs
│   │   │   └── result_large_err.stderr
│   │   ├── semicolon_block/
│   │   │   ├── both.fixed
│   │   │   ├── both.rs
│   │   │   ├── both.stderr
│   │   │   ├── clippy.toml
│   │   │   ├── semicolon_inside_block.fixed
│   │   │   ├── semicolon_inside_block.rs
│   │   │   ├── semicolon_inside_block.stderr
│   │   │   ├── semicolon_outside_block.fixed
│   │   │   ├── semicolon_outside_block.rs
│   │   │   └── semicolon_outside_block.stderr
│   │   ├── strict_non_send_fields_in_send_ty/
│   │   │   ├── clippy.toml
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── struct_excessive_bools/
│   │   │   ├── clippy.toml
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── suppress_lint_in_const/
│   │   │   ├── clippy.toml
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── toml_disallow/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_french_disallowed_name.rs
│   │   │   └── conf_french_disallowed_name.stderr
│   │   ├── toml_disallowed_fields/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_disallowed_fields.rs
│   │   │   └── conf_disallowed_fields.stderr
│   │   ├── toml_disallowed_methods/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_disallowed_methods.rs
│   │   │   └── conf_disallowed_methods.stderr
│   │   ├── toml_disallowed_types/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_disallowed_types.rs
│   │   │   └── conf_disallowed_types.stderr
│   │   ├── toml_inconsistent_struct_constructor/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_inconsistent_struct_constructor.fixed
│   │   │   ├── conf_inconsistent_struct_constructor.rs
│   │   │   └── conf_inconsistent_struct_constructor.stderr
│   │   ├── toml_invalid_path/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_invalid_path.rs
│   │   │   └── conf_invalid_path.stderr
│   │   ├── toml_replaceable_disallowed_methods/
│   │   │   ├── clippy.toml
│   │   │   ├── replaceable_disallowed_methods.fixed
│   │   │   ├── replaceable_disallowed_methods.rs
│   │   │   └── replaceable_disallowed_methods.stderr
│   │   ├── toml_trivially_copy/
│   │   │   ├── clippy.toml
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── toml_unknown_config_struct_field/
│   │   │   ├── clippy.toml
│   │   │   ├── toml_unknown_config_struct_field.rs
│   │   │   └── toml_unknown_config_struct_field.stderr
│   │   ├── toml_unknown_key/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_unknown_key.rs
│   │   │   └── conf_unknown_key.stderr
│   │   ├── toml_unloaded_crate/
│   │   │   ├── clippy.toml
│   │   │   ├── conf_unloaded_crate.rs
│   │   │   └── conf_unloaded_crate.stderr
│   │   ├── too_large_for_stack/
│   │   │   ├── boxed_local.rs
│   │   │   ├── boxed_local.stderr
│   │   │   ├── clippy.toml
│   │   │   ├── useless_vec.fixed
│   │   │   ├── useless_vec.rs
│   │   │   └── useless_vec.stderr
│   │   ├── too_many_arguments/
│   │   │   ├── clippy.toml
│   │   │   ├── too_many_arguments.rs
│   │   │   └── too_many_arguments.stderr
│   │   ├── type_complexity/
│   │   │   ├── clippy.toml
│   │   │   ├── type_complexity.rs
│   │   │   └── type_complexity.stderr
│   │   ├── type_repetition_in_bounds/
│   │   │   ├── clippy.toml
│   │   │   ├── main.rs
│   │   │   └── main.stderr
│   │   ├── undocumented_unsafe_blocks/
│   │   │   ├── default/
│   │   │   │   └── clippy.toml
│   │   │   ├── disabled/
│   │   │   │   └── clippy.toml
│   │   │   ├── undocumented_unsafe_blocks.default.stderr
│   │   │   ├── undocumented_unsafe_blocks.disabled.stderr
│   │   │   ├── undocumented_unsafe_blocks.rs
│   │   │   ├── undocumented_unsafe_blocks_fixable.default.fixed
│   │   │   ├── undocumented_unsafe_blocks_fixable.default.stderr
│   │   │   ├── undocumented_unsafe_blocks_fixable.disabled.fixed
│   │   │   ├── undocumented_unsafe_blocks_fixable.disabled.stderr
│   │   │   └── undocumented_unsafe_blocks_fixable.rs
│   │   ├── unnecessary_box_returns/
│   │   │   ├── clippy.toml
│   │   │   ├── unnecessary_box_returns.fixed
│   │   │   ├── unnecessary_box_returns.rs
│   │   │   └── unnecessary_box_returns.stderr
│   │   ├── unwrap_used/
│   │   │   ├── clippy.toml
│   │   │   ├── unwrap_used.fixed
│   │   │   ├── unwrap_used.rs
│   │   │   ├── unwrap_used.stderr
│   │   │   ├── unwrap_used_const.rs
│   │   │   └── unwrap_used_const.stderr
│   │   ├── unwrap_used_allowed/
│   │   │   ├── clippy.toml
│   │   │   ├── unwrap_used_allowed.rs
│   │   │   └── unwrap_used_allowed.stderr
│   │   ├── update-all-references.sh
│   │   ├── upper_case_acronyms_aggressive/
│   │   │   ├── clippy.toml
│   │   │   ├── upper_case_acronyms.fixed
│   │   │   ├── upper_case_acronyms.rs
│   │   │   └── upper_case_acronyms.stderr
│   │   ├── use_self/
│   │   │   ├── default/
│   │   │   │   └── clippy.toml
│   │   │   ├── disabled/
│   │   │   │   └── clippy.toml
│   │   │   ├── use_self.default.fixed
│   │   │   ├── use_self.default.stderr
│   │   │   ├── use_self.disabled.fixed
│   │   │   ├── use_self.disabled.stderr
│   │   │   └── use_self.rs
│   │   ├── useless_vec/
│   │   │   ├── clippy.toml
│   │   │   ├── useless_vec.fixed
│   │   │   ├── useless_vec.rs
│   │   │   └── useless_vec.stderr
│   │   ├── vec_box_sized/
│   │   │   ├── clippy.toml
│   │   │   ├── test.fixed
│   │   │   ├── test.rs
│   │   │   └── test.stderr
│   │   ├── verbose_bit_mask/
│   │   │   ├── clippy.toml
│   │   │   ├── verbose_bit_mask.fixed
│   │   │   ├── verbose_bit_mask.rs
│   │   │   └── verbose_bit_mask.stderr
│   │   ├── wildcard_imports/
│   │   │   ├── clippy.toml
│   │   │   ├── wildcard_imports.fixed
│   │   │   ├── wildcard_imports.rs
│   │   │   └── wildcard_imports.stderr
│   │   ├── wildcard_imports_whitelist/
│   │   │   ├── clippy.toml
│   │   │   ├── wildcard_imports.fixed
│   │   │   ├── wildcard_imports.rs
│   │   │   └── wildcard_imports.stderr
│   │   └── zero_single_char_names/
│   │       ├── clippy.toml
│   │       └── zero_single_char_names.rs
│   ├── versioncheck.rs
│   ├── workspace.rs
│   └── workspace_test/
│       ├── Cargo.toml
│       ├── build.rs
│       ├── module_style/
│       │   ├── pass_mod_with_dep_in_subdir/
│       │   │   ├── Cargo.toml
│       │   │   ├── dep_no_mod/
│       │   │   │   ├── Cargo.toml
│       │   │   │   └── src/
│       │   │   │       ├── foo/
│       │   │   │       │   └── hello.rs
│       │   │   │       ├── foo.rs
│       │   │   │       └── lib.rs
│       │   │   └── src/
│       │   │       ├── bad/
│       │   │       │   └── mod.rs
│       │   │       ├── main.rs
│       │   │       └── more/
│       │   │           ├── foo.rs
│       │   │           ├── inner/
│       │   │           │   └── mod.rs
│       │   │           └── mod.rs
│       │   └── pass_no_mod_with_dep_in_subdir/
│       │       ├── Cargo.toml
│       │       ├── dep_with_mod/
│       │       │   ├── Cargo.toml
│       │       │   └── src/
│       │       │       ├── lib.rs
│       │       │       └── with_mod/
│       │       │           ├── inner/
│       │       │           │   ├── stuff/
│       │       │           │   │   └── most.rs
│       │       │           │   └── stuff.rs
│       │       │           ├── inner.rs
│       │       │           └── mod.rs
│       │       └── src/
│       │           ├── good.rs
│       │           └── main.rs
│       ├── path_dep/
│       │   ├── Cargo.toml
│       │   └── src/
│       │       └── lib.rs
│       ├── src/
│       │   └── main.rs
│       └── subcrate/
│           ├── Cargo.toml
│           └── src/
│               └── lib.rs
├── triagebot.toml
└── util/
    ├── etc/
    │   ├── pre-commit.sh
    │   └── vscode-tasks.json
    ├── fetch_prs_between.sh
    ├── gh-pages/
    │   ├── index_template.html
    │   ├── script.js
    │   ├── style.css
    │   ├── theme.js
    │   └── versions.html
    └── versions.py

SYMBOL INDEX (16631 symbols across 2195 files)

FILE: build.rs
  function main (line 1) | fn main() {

FILE: clippy_config/src/conf.rs
  constant DEFAULT_DOC_VALID_IDENTS (line 25) | const DEFAULT_DOC_VALID_IDENTS: &[&str] = &[
  constant DEFAULT_DISALLOWED_NAMES (line 53) | const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
  constant DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS (line 54) | const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x",...
  constant DEFAULT_ALLOWED_PREFIXES (line 55) | const DEFAULT_ALLOWED_PREFIXES: &[&str] = &["to", "as", "into", "from", ...
  constant DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS (line 56) | const DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS: &[&str] =
  constant DEFAULT_MODULE_ITEM_ORDERING_GROUPS (line 58) | const DEFAULT_MODULE_ITEM_ORDERING_GROUPS: &[(&str, &[SourceItemOrdering...
  constant DEFAULT_TRAIT_ASSOC_ITEM_KINDS_ORDER (line 71) | const DEFAULT_TRAIT_ASSOC_ITEM_KINDS_ORDER: &[SourceItemOrderingTraitAss...
  constant DEFAULT_SOURCE_ITEM_ORDERING (line 76) | const DEFAULT_SOURCE_ITEM_ORDERING: &[SourceItemOrderingCategory] = {
  type TryConf (line 84) | struct TryConf {
    method from_toml_error (line 92) | fn from_toml_error(file: &SourceFile, error: &toml::de::Error) -> Self {
  type ConfError (line 103) | struct ConfError {
    method from_toml (line 110) | fn from_toml(file: &SourceFile, error: &toml::de::Error) -> Self {
    method spanned (line 115) | fn spanned(
  function sanitize_explanation (line 130) | pub fn sanitize_explanation(raw_docs: &str) -> String {
  function union (line 328) | fn union(x: &Range<usize>, y: &Range<usize>) -> Range<usize> {
  function span_from_toml_range (line 335) | fn span_from_toml_range(file: &SourceFile, span: Range<usize>) -> Span {
  function lookup_conf_file (line 928) | pub fn lookup_conf_file() -> io::Result<(Option<PathBuf>, Vec<String>)> {
  function deserialize (line 976) | fn deserialize(file: &SourceFile) -> TryConf {
  function extend_vec_if_indicator_present (line 1033) | fn extend_vec_if_indicator_present(vec: &mut Vec<String>, default: &[&st...
  method read (line 1040) | pub fn read(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<Stri...
  method read_inner (line 1045) | fn read_inner(sess: &Session, path: &io::Result<(Option<PathBuf>, Vec<St...
  constant SEPARATOR_WIDTH (line 1101) | const SEPARATOR_WIDTH: usize = 4;
  type FieldError (line 1104) | struct FieldError {
    method custom (line 1124) | fn custom<T: Display>(msg: T) -> Self {
    method unknown_field (line 1131) | fn unknown_field(field: &str, expected: &'static [&'static str]) -> Se...
  type Suggestion (line 1110) | struct Suggestion {
  method fmt (line 1118) | fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
  function calculate_dimensions (line 1176) | fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
  function suggest_candidate (line 1210) | fn suggest_candidate<'a, I>(value: &str, candidates: I) -> Option<&'a str>
  function configs_are_tested (line 1232) | fn configs_are_tested() {

FILE: clippy_config/src/metadata.rs
  type ClippyConfiguration (line 5) | pub struct ClippyConfiguration {
    method fmt (line 14) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method to_markdown_paragraph (line 24) | pub fn to_markdown_paragraph(&self) -> String {
    method to_markdown_link (line 36) | pub fn to_markdown_link(&self) -> String {

FILE: clippy_config/src/types.rs
  type Rename (line 16) | pub struct Rename {
  type DisallowedPathWithoutReplacement (line 21) | pub type DisallowedPathWithoutReplacement = DisallowedPath<false>;
  type DisallowedPath (line 24) | pub struct DisallowedPath<const REPLACEMENT_ALLOWED: bool = true> {
  function deserialize (line 42) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type DisallowedPathEnum (line 64) | enum DisallowedPathEnum {
    method path (line 105) | pub fn path(&self) -> &str {
    method reason (line 111) | fn reason(&self) -> Option<&str> {
    method replacement (line 118) | fn replacement(&self) -> Option<&str> {
    method allow_invalid (line 125) | fn allow_invalid(&self) -> bool {
  function path (line 76) | pub fn path(&self) -> &str {
  function diag_amendment (line 80) | pub fn diag_amendment(&self, span: Span) -> impl FnOnce(&mut Diag<'_, ()...
  function span (line 95) | pub fn span(&self) -> Span {
  function set_span (line 99) | pub fn set_span(&mut self, span: Span) {
  function create_disallowed_map (line 135) | pub fn create_disallowed_map<const REPLACEMENT_ALLOWED: bool>(
  type MatchLintBehaviour (line 199) | pub enum MatchLintBehaviour {
  type MacroMatcher (line 206) | pub struct MacroMatcher {
    method deserialize (line 212) | fn deserialize<D>(deser: D) -> Result<Self, D::Error>
  type SourceItemOrderingCategory (line 273) | pub enum SourceItemOrderingCategory {
  type SourceItemOrdering (line 285) | pub struct SourceItemOrdering(Vec<SourceItemOrderingCategory>);
    method contains (line 288) | pub fn contains(&self, category: &SourceItemOrderingCategory) -> bool {
    method from (line 297) | fn from(value: T) -> Self {
    method fmt (line 303) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method deserialize (line 309) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 330) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type SourceItemOrderingModuleItemKind (line 341) | pub enum SourceItemOrderingModuleItemKind {
    method all_variants (line 361) | pub fn all_variants() -> Vec<Self> {
  type SourceItemOrderingModuleItemGroupings (line 390) | pub struct SourceItemOrderingModuleItemGroupings {
    method build_lut (line 397) | fn build_lut(
    method build_back_lut (line 409) | fn build_back_lut(
    method grouping_name_of (line 421) | pub fn grouping_name_of(&self, item: &SourceItemOrderingModuleItemKind...
    method grouping_names (line 425) | pub fn grouping_names(&self) -> Vec<String> {
    method is_grouping (line 429) | pub fn is_grouping(&self, grouping: &str) -> bool {
    method module_level_order_of (line 433) | pub fn module_level_order_of(&self, item: &SourceItemOrderingModuleIte...
    method from (line 439) | fn from(value: &[(&str, &[SourceItemOrderingModuleItemKind])]) -> Self {
    method fmt (line 449) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method deserialize (line 455) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 502) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type SourceItemOrderingTraitAssocItemKind (line 513) | pub enum SourceItemOrderingTraitAssocItemKind {
    method all_variants (line 520) | pub fn all_variants() -> Vec<Self> {
  type SourceItemOrderingTraitAssocItemKinds (line 535) | pub struct SourceItemOrderingTraitAssocItemKinds(Vec<SourceItemOrderingT...
    method index_of (line 538) | pub fn index_of(&self, item: &SourceItemOrderingTraitAssocItemKind) ->...
    method from (line 547) | fn from(value: T) -> Self {
    method fmt (line 553) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method deserialize (line 559) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method serialize (line 589) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type SourceItemOrderingWithinModuleItemGroupings (line 605) | pub enum SourceItemOrderingWithinModuleItemGroupings {
    method ordered_within (line 617) | pub fn ordered_within(&self, grouping_name: &String) -> bool {
    method deserialize (line 635) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type StringOrVecOfString (line 629) | enum StringOrVecOfString {
  method serialize (line 662) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type PubUnderscoreFieldsBehaviour (line 697) | pub enum PubUnderscoreFieldsBehaviour {
  type InherentImplLintScope (line 704) | pub enum InherentImplLintScope {

FILE: clippy_dev/src/deprecate_lint.rs
  function deprecate (line 17) | pub fn deprecate<'cx>(cx: ParseCx<'cx>, clippy_version: Version, name: &...
  function uplift (line 64) | pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version,...
  function remove_lint_declaration (line 116) | fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint...

FILE: clippy_dev/src/dogfood.rs
  function dogfood (line 8) | pub fn dogfood(fix: bool, allow_dirty: bool, allow_staged: bool, allow_n...

FILE: clippy_dev/src/edit_lints.rs
  function deprecate (line 23) | pub fn deprecate<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Versi...
  function uplift (line 47) | pub fn uplift<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version,...
  function rename (line 96) | pub fn rename<'cx, 'env: 'cx>(cx: ParseCx<'cx>, clippy_version: Version,...
  function remove_lint_declaration (line 163) | fn remove_lint_declaration(name: &str, lint: &ActiveLint<'_>, data: &Lin...
  function update_rename_targets (line 197) | fn update_rename_targets<'cx>(data: &mut LintData<'cx>, old_name: &str, ...
  function create_ignored_prefixes (line 209) | fn create_ignored_prefixes<'cx>(name: &str, data: &LintData<'cx>) -> Vec...
  function collect_ui_test_names (line 217) | fn collect_ui_test_names(lint: &str, ignored_prefixes: &[&str], dst: &mu...
  function collect_ui_toml_test_names (line 233) | fn collect_ui_toml_test_names(lint: &str, ignored_prefixes: &[&str], dst...
  function rename_test_files (line 250) | fn rename_test_files(old_name: &str, new_name: &str, ignored_prefixes: &...
  function delete_test_files (line 285) | fn delete_test_files(lint: &str, ignored_prefixes: &[&str]) {
  function snake_to_pascal (line 312) | fn snake_to_pascal(s: &str) -> String {
  function uplift_update_fn (line 331) | fn uplift_update_fn<'a>(
  function rename_update_fn (line 368) | fn rename_update_fn<'a>(

FILE: clippy_dev/src/fmt.rs
  type Error (line 17) | pub enum Error {
    method from (line 24) | fn from(error: io::Error) -> Self {
    method display (line 30) | fn display(&self) {
  type ClippyConf (line 45) | struct ClippyConf<'a> {
  function offset_to_line (line 52) | fn offset_to_line(text: &str, offset: usize) -> usize {
  function fmt_conf (line 67) | fn fmt_conf(check: bool) -> Result<(), Error> {
  function fmt_syms (line 235) | fn fmt_syms(update_mode: UpdateMode) {
  function run_rustfmt (line 266) | fn run_rustfmt(update_mode: UpdateMode) {
  function run (line 331) | pub fn run(update_mode: UpdateMode) {

FILE: clippy_dev/src/generate.rs
  constant GENERATED_FILE_COMMENT (line 10) | const GENERATED_FILE_COMMENT: &str = "// This file was generated by `car...
  constant DOCS_LINK (line 14) | const DOCS_LINK: &str = "https://rust-lang.github.io/rust-clippy/master/...
  function gen_decls (line 18) | pub fn gen_decls(&self, update_mode: UpdateMode) {
  function gen_mac (line 196) | pub fn gen_mac(&self, dst: &mut String) {
  function write_comment_lines (line 225) | fn write_comment_lines(s: &str, prefix: &str, dst: &mut String) -> bool {
  type ListFmt (line 238) | enum ListFmt {
  function write_list (line 243) | fn write_list<'a>(
  function gen_sorted_lints_file (line 263) | pub fn gen_sorted_lints_file(

FILE: clippy_dev/src/lint.rs
  function run (line 10) | pub fn run<'a>(path: &str, edition: &str, args: impl Iterator<Item = &'a...

FILE: clippy_dev/src/main.rs
  function main (line 11) | fn main() {
  function lint_name (line 96) | fn lint_name(name: &str) -> Result<String, String> {
  type Dev (line 112) | struct Dev {
  type DevCommand (line 118) | enum DevCommand {
  type SetupCommand (line 269) | struct SetupCommand {
  type SetupSubcommand (line 275) | enum SetupSubcommand {
  type RemoveCommand (line 329) | struct RemoveCommand {
  type RemoveSubcommand (line 335) | enum RemoveSubcommand {
  type SyncCommand (line 345) | struct SyncCommand {
  type SyncSubcommand (line 351) | enum SyncSubcommand {
  type ReleaseCommand (line 358) | struct ReleaseCommand {
  type ReleaseSubcommand (line 364) | enum ReleaseSubcommand {

FILE: clippy_dev/src/new_lint.rs
  type Pass (line 11) | pub enum Pass {
    method fmt (line 17) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LintData (line 25) | struct LintData<'a> {
  type Context (line 33) | trait Context {
    method context (line 34) | fn context<C: AsRef<str>>(self, text: C) -> Self;
    method context (line 38) | fn context<C: AsRef<str>>(self, text: C) -> Self {
  function create (line 54) | pub fn create(
  function create_lint (line 93) | fn create_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
  function create_test (line 106) | fn create_test(lint: &LintData<'_>, msrv: bool) -> io::Result<()> {
  function add_lint (line 156) | fn add_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
  function write_file (line 180) | fn write_file<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> i...
  function to_camel_case (line 192) | fn to_camel_case(name: &str) -> String {
  function get_test_file_contents (line 204) | fn get_test_file_contents(lint_name: &str, msrv: bool) -> String {
  function get_manifest_contents (line 238) | fn get_manifest_contents(lint_name: &str, hint: &str) -> String {
  function get_lint_file_contents (line 253) | fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> Str...
  function get_lint_declaration (line 340) | fn get_lint_declaration(version: Version, name_upper: &str, category: &s...
  function create_lint_for_ty (line 370) | fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) ...
  function setup_mod_file (line 448) | fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'stat...
  function parse_mod_file (line 519) | fn parse_mod_file(path: &Path, contents: &str) -> (&'static str, usize) {
  function test_camel_case (line 550) | fn test_camel_case() {

FILE: clippy_dev/src/parse.rs
  type ParseCxImpl (line 13) | pub struct ParseCxImpl<'cx> {
  type ParseCx (line 18) | pub type ParseCx<'cx> = &'cx mut ParseCxImpl<'cx>;
  function new_parse_cx (line 21) | pub fn new_parse_cx<'env, T>(f: impl for<'cx> FnOnce(&'cx mut Scoped<'cx...
  type StrBuf (line 31) | pub struct StrBuf(String);
    method with_capacity (line 34) | pub fn with_capacity(cap: usize) -> Self {
    method alloc_display (line 39) | pub fn alloc_display<'cx>(&mut self, arena: &'cx DroplessArena, value:...
    method alloc_ascii_lower (line 47) | pub fn alloc_ascii_lower<'cx>(&mut self, arena: &'cx DroplessArena, s:...
    method alloc_replaced (line 56) | pub fn alloc_replaced<'cx>(
    method with (line 81) | pub fn with<T>(&mut self, f: impl FnOnce(&mut String) -> T) -> T {
  type VecBuf (line 87) | pub struct VecBuf<T>(Vec<T>);
  function with_capacity (line 90) | pub fn with_capacity(cap: usize) -> Self {
  function with (line 95) | pub fn with<R>(&mut self, f: impl FnOnce(&mut Vec<T>) -> R) -> R {
  type LintTool (line 102) | pub enum LintTool {
    method prefix (line 108) | pub fn prefix(self) -> &'static str {
  type LintName (line 117) | pub struct LintName<'cx> {
  function new_rustc (line 122) | pub fn new_rustc(name: &'cx str) -> Self {
  function new_clippy (line 129) | pub fn new_clippy(name: &'cx str) -> Self {
  method fmt (line 137) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ActiveLint (line 143) | pub struct ActiveLint<'cx> {
  type DeprecatedLint (line 150) | pub struct DeprecatedLint<'cx> {
  type RenamedLint (line 155) | pub struct RenamedLint<'cx> {
  type Lint (line 160) | pub enum Lint<'cx> {
  type LintPassMac (line 167) | pub enum LintPassMac {
    method name (line 172) | pub fn name(self) -> &'static str {
  type LintPass (line 180) | pub struct LintPass<'cx> {
  type LintData (line 192) | pub struct LintData<'cx> {
  function split_by_lint_file (line 198) | pub fn split_by_lint_file<'s>(
  function parse_lint_decls (line 224) | pub fn parse_lint_decls(&mut self) -> LintData<'cx> {
  function parse_lint_src_file (line 279) | fn parse_lint_src_file(&mut self, path: &Path, contents: &str, module: &...
  function read_deprecated_lints (line 390) | fn read_deprecated_lints(&mut self, data: &mut LintData<'cx>) {
  function parse_str_lit (line 462) | fn parse_str_lit(&mut self, s: &str) -> &'cx str {
  function parse_str_single_line (line 487) | fn parse_str_single_line(&mut self, path: &Path, s: &str) -> &'cx str {
  function parse_clippy_lint_name (line 497) | fn parse_clippy_lint_name(&mut self, path: &Path, s: &str) -> &'cx str {
  function parse_lint_name (line 507) | fn parse_lint_name(&mut self, path: &Path, s: &str) -> LintName<'cx> {

FILE: clippy_dev/src/parse/cursor.rs
  type Pat (line 11) | pub enum Pat<'a> {
  type Capture (line 39) | pub struct Capture {
    constant EMPTY (line 44) | pub const EMPTY: Self = Self { pos: 0, len: 0 };
  type Cursor (line 48) | pub struct Cursor<'txt> {
  function new (line 56) | pub fn new(text: &'txt str) -> Self {
  function get_text (line 68) | pub fn get_text(&self, capture: Capture) -> &'txt str {
  function peek_text (line 75) | pub fn peek_text(&self) -> &'txt str {
  function peek_len (line 81) | pub fn peek_len(&self) -> u32 {
  function peek (line 88) | pub fn peek(&self) -> TokenKind {
  function pos (line 95) | pub fn pos(&self) -> u32 {
  function at_end (line 101) | pub fn at_end(&self) -> bool {
  function step (line 107) | pub fn step(&mut self) {
  function match_impl (line 119) | fn match_impl(&mut self, pat: Pat<'_>, captures: &mut slice::IterMut<'_,...
  function find_ident (line 247) | pub fn find_ident(&mut self, ident: &str) -> Option<u32> {
  function find_any_ident (line 266) | pub fn find_any_ident(&mut self) -> Option<Capture> {
  function match_ident (line 285) | pub fn match_ident(&mut self, s: &str) -> Option<u32> {
  function capture_ident (line 301) | pub fn capture_ident(&mut self) -> Option<Capture> {
  function find_pat (line 322) | pub fn find_pat(&mut self, pat: Pat<'_>) -> bool {
  function match_all (line 343) | pub fn match_all(&mut self, pats: &[Pat<'_>], captures: &mut [Capture]) ...
  function match_pat (line 354) | pub fn match_pat(&mut self, pat: Pat<'_>) -> bool {

FILE: clippy_dev/src/release.rs
  function bump_version (line 12) | pub fn bump_version(mut version: Version) {

FILE: clippy_dev/src/serve.rs
  constant PYTHON (line 11) | const PYTHON: &str = "python";
  constant PYTHON (line 14) | const PYTHON: &str = "python3";
  function run (line 19) | pub fn run(port: u16, lint: Option<String>) -> ! {
  function log_err_and_continue (line 61) | fn log_err_and_continue<T>(res: Result<T, impl Display>, path: &Path) ->...
  function mtime (line 71) | fn mtime(path: &str) -> SystemTime {
  function is_metadata_outdated (line 77) | fn is_metadata_outdated(time: SystemTime) -> bool {

FILE: clippy_dev/src/setup/git_hook.rs
  constant REPO_GIT_DIR (line 8) | const REPO_GIT_DIR: &str = ".git";
  constant HOOK_SOURCE_FILE (line 9) | const HOOK_SOURCE_FILE: &str = "util/etc/pre-commit.sh";
  constant HOOK_TARGET_FILE (line 10) | const HOOK_TARGET_FILE: &str = ".git/hooks/pre-commit";
  function install_hook (line 12) | pub fn install_hook(force_override: bool) {
  function check_precondition (line 35) | fn check_precondition(force_override: bool) -> bool {
  function remove_hook (line 58) | pub fn remove_hook() {
  function delete_git_hook_file (line 69) | fn delete_git_hook_file(path: &Path) -> bool {

FILE: clippy_dev/src/setup/intellij.rs
  constant RUSTC_PATH_SECTION (line 11) | const RUSTC_PATH_SECTION: &str = "[target.'cfg(NOT_A_PLATFORM)'.dependen...
  constant DEPENDENCIES_SECTION (line 12) | const DEPENDENCIES_SECTION: &str = "[dependencies]";
  constant CLIPPY_PROJECTS (line 14) | const CLIPPY_PROJECTS: &[ClippyProjectInfo] = &[
  type ClippyProjectInfo (line 21) | struct ClippyProjectInfo {
    method new (line 29) | const fn new(name: &'static str, cargo_file: &'static str, lib_rs_file...
  function setup_rustc_src (line 38) | pub fn setup_rustc_src(rustc_path: &str) {
  function check_and_get_rustc_dir (line 52) | fn check_and_get_rustc_dir(rustc_path: &str) -> Result<PathBuf, ()> {
  function inject_deps_into_project (line 84) | fn inject_deps_into_project(rustc_source_dir: &Path, project: &ClippyPro...
  function read_project_file (line 102) | fn read_project_file(file_path: &str) -> Result<String, ()> {
  function inject_deps_into_manifest (line 118) | fn inject_deps_into_manifest(
  function remove_rustc_src (line 167) | pub fn remove_rustc_src() {
  function remove_rustc_src_from_project (line 173) | fn remove_rustc_src_from_project(project: &ClippyProjectInfo) -> bool {

FILE: clippy_dev/src/setup/toolchain.rs
  function create (line 9) | pub fn create(standalone: bool, force: bool, release: bool, name: &str) {
  function install_bin (line 60) | fn install_bin(bin: &str, dest: &Path, standalone: bool, release: bool) {

FILE: clippy_dev/src/setup/vscode.rs
  constant VSCODE_DIR (line 4) | const VSCODE_DIR: &str = ".vscode";
  constant TASK_SOURCE_FILE (line 5) | const TASK_SOURCE_FILE: &str = "util/etc/vscode-tasks.json";
  constant TASK_TARGET_FILE (line 6) | const TASK_TARGET_FILE: &str = ".vscode/tasks.json";
  function install_tasks (line 8) | pub fn install_tasks(force_override: bool) {
  function check_install_precondition (line 22) | fn check_install_precondition(force_override: bool) -> bool {
  function remove_tasks (line 56) | pub fn remove_tasks() {
  function delete_vs_task_file (line 68) | fn delete_vs_task_file(path: &Path) -> bool {
  function try_delete_vs_directory_if_empty (line 79) | fn try_delete_vs_directory_if_empty() {

FILE: clippy_dev/src/sync.rs
  function update_nightly (line 5) | pub fn update_nightly() {

FILE: clippy_dev/src/utils.rs
  type Scoped (line 16) | pub struct Scoped<'inner, 'outer: 'inner, T>(T, PhantomData<&'inner mut ...
  function new (line 18) | pub fn new(value: T) -> Self {
  type Target (line 23) | type Target = T;
  method deref (line 24) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 29) | fn deref_mut(&mut self) -> &mut Self::Target {
  type ErrAction (line 35) | pub enum ErrAction {
    method as_str (line 45) | fn as_str(self) -> &'static str {
  function panic_action (line 60) | pub fn panic_action(err: &impl Display, action: ErrAction, path: &Path) ...
  function expect_action (line 65) | pub fn expect_action<T>(res: Result<T, impl Display>, action: ErrAction,...
  type File (line 73) | pub struct File<'a> {
  function open (line 80) | pub fn open(path: &'a (impl AsRef<Path> + ?Sized), options: &mut OpenOpt...
  function open_if_exists (line 90) | pub fn open_if_exists(path: &'a (impl AsRef<Path> + ?Sized), options: &m...
  function open_read_to_cleared_string (line 101) | pub fn open_read_to_cleared_string<'dst>(
  function read_append_to_string (line 110) | pub fn read_append_to_string<'dst>(&mut self, dst: &'dst mut String) -> ...
  function read_to_cleared_string (line 116) | pub fn read_to_cleared_string<'dst>(&mut self, dst: &'dst mut String) ->...
  function replace_contents (line 123) | pub fn replace_contents(&mut self, data: &[u8]) {
  function cargo_cmd (line 137) | pub fn cargo_cmd() -> Command {
  type Version (line 146) | pub struct Version {
    method rust_display (line 167) | pub fn rust_display(self) -> impl Display {
    method toml_display (line 179) | pub fn toml_display(self) -> impl Display {
  type Err (line 151) | type Err = ();
  method from_str (line 152) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type TomlPart (line 190) | enum TomlPart<'a> {
  function toml_iter (line 195) | fn toml_iter(s: &str) -> impl Iterator<Item = (usize, TomlPart<'_>)> {
  type CargoPackage (line 214) | pub struct CargoPackage<'a> {
  function parse_cargo_package (line 221) | pub fn parse_cargo_package(s: &str) -> CargoPackage<'_> {
  type ClippyInfo (line 263) | pub struct ClippyInfo {
    method search_for_manifest (line 270) | pub fn search_for_manifest() -> Self {
  type UpdateStatus (line 304) | pub enum UpdateStatus {
    method from_changed (line 310) | pub fn from_changed(value: bool) -> Self {
    method is_changed (line 315) | pub fn is_changed(self) -> bool {
  type UpdateMode (line 321) | pub enum UpdateMode {
    method from_check (line 327) | pub fn from_check(check: bool) -> Self {
    method is_check (line 332) | pub fn is_check(self) -> bool {
  type FileUpdater (line 338) | pub struct FileUpdater {
    method update_file_checked_inner (line 344) | fn update_file_checked_inner(
    method update_file_inner (line 368) | fn update_file_inner(&mut self, path: &Path, update: &mut dyn FnMut(&P...
    method update_file_checked (line 378) | pub fn update_file_checked(
    method update_file (line 389) | pub fn update_file(
  function update_text_region (line 400) | pub fn update_text_region(
  function update_text_region_fn (line 424) | pub fn update_text_region_fn(
  function try_rename_file (line 433) | pub fn try_rename_file(old_name: &Path, new_name: &Path) -> bool {
  function try_rename_dir (line 455) | pub fn try_rename_dir(old_name: &Path, new_name: &Path) -> bool {
  function run_exit_on_err (line 481) | pub fn run_exit_on_err(path: &(impl AsRef<Path> + ?Sized), cmd: &mut Com...
  function run_with_output (line 494) | pub fn run_with_output(path: &(impl AsRef<Path> + ?Sized), cmd: &mut Com...
  function split_args_for_threads (line 517) | pub fn split_args_for_threads(
  function delete_file_if_exists (line 579) | pub fn delete_file_if_exists(path: &Path) -> bool {
  function delete_dir_if_exists (line 588) | pub fn delete_dir_if_exists(path: &Path) {
  function walk_dir_no_dot_or_target (line 597) | pub fn walk_dir_no_dot_or_target(p: impl AsRef<Path>) -> impl Iterator<I...
  function slice_groups_mut (line 605) | pub fn slice_groups_mut<T>(

FILE: clippy_dummy/build.rs
  function main (line 4) | fn main() {
  function foo (line 14) | fn foo() -> Result<()> {

FILE: clippy_dummy/src/main.rs
  function main (line 1) | fn main() {

FILE: clippy_lints/src/absolute_paths.rs
  type AbsolutePaths (line 58) | pub struct AbsolutePaths {
    method new (line 64) | pub fn new(conf: &'static Conf) -> Self {
    method check_path (line 80) | fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, hi...

FILE: clippy_lints/src/almost_complete_range.rs
  type AlmostCompleteRange (line 34) | pub struct AlmostCompleteRange {
    method new (line 38) | pub fn new(conf: &'static Conf) -> Self {
  method check_expr (line 45) | fn check_expr(&mut self, cx: &EarlyContext<'_>, e: &Expr) {
  method check_pat (line 73) | fn check_pat(&mut self, cx: &EarlyContext<'_>, p: &Pat) {
  function is_incomplete_range (line 103) | fn is_incomplete_range(start: &Expr, end: &Expr) -> bool {

FILE: clippy_lints/src/approx_const.rs
  constant KNOWN_CONSTS (line 45) | const KNOWN_CONSTS: [(f64, &str, usize, Option<RustcVersion>); 19] = [
  type ApproxConstant (line 67) | pub struct ApproxConstant {
    method new (line 72) | pub fn new(conf: &'static Conf) -> Self {
    method check_lit (line 78) | fn check_lit(&mut self, cx: &LateContext<'_>, _hir_id: HirId, lit: Lit...
    method check_known_consts (line 94) | fn check_known_consts(&self, cx: &LateContext<'_>, span: Span, s: symb...
  function count_digits_after_dot (line 116) | fn count_digits_after_dot(input: &str) -> usize {
  function is_approx_const (line 127) | fn is_approx_const(constant: f64, value: &str, f_value: f64, min_digits:...

FILE: clippy_lints/src/arbitrary_source_item_ordering.rs
  type ArbitrarySourceItemOrdering (line 171) | pub struct ArbitrarySourceItemOrdering {
    method new (line 183) | pub fn new(conf: &'static Conf) -> Self {
    method lint_impl_item (line 199) | fn lint_impl_item(&self, cx: &LateContext<'_>, item: ImplItemId, befor...
    method lint_member_name (line 214) | fn lint_member_name<T: LintContext>(cx: &T, ident: Ident, before_ident...
    method lint_member_item (line 225) | fn lint_member_item(cx: &LateContext<'_>, item: &Item<'_>, before_item...
    method lint_trait_item (line 250) | fn lint_trait_item(&self, cx: &LateContext<'_>, item: TraitItemId, bef...
    method check_item (line 266) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx...
    method check_mod (line 365) | fn check_mod(&mut self, cx: &LateContext<'tcx>, module: &'tcx Mod<'tcx...
  function convert_assoc_item_kind (line 471) | fn convert_assoc_item_kind(cx: &LateContext<'_>, owner_id: OwnerId) -> S...
  function convert_module_item_kind (line 489) | fn convert_module_item_kind(value: &ItemKind<'_>) -> SourceItemOrderingM...
  function get_item_name (line 526) | fn get_item_name(item: &Item<'_>) -> Option<String> {

FILE: clippy_lints/src/arc_with_non_send_sync.rs
  method check_expr (line 46) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {

FILE: clippy_lints/src/as_conversions.rs
  method check_expr (line 61) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {

FILE: clippy_lints/src/asm_syntax.rs
  type AsmStyle (line 12) | enum AsmStyle {
    method fmt (line 18) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 27) | type Output = AsmStyle;
    method not (line 29) | fn not(self) -> AsmStyle {
  function check_asm_syntax (line 37) | fn check_asm_syntax(
  method check_expr (line 129) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  method check_item (line 135) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
  method check_expr (line 143) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  method check_item (line 149) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {

FILE: clippy_lints/src/assertions_on_constants.rs
  type AssertionsOnConstants (line 37) | pub struct AssertionsOnConstants {
    method new (line 41) | pub fn new(conf: &Conf) -> Self {
    method check_expr (line 47) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
  function as_bool_lit (line 85) | fn as_bool_lit(e: &Expr<'_>) -> Option<bool> {

FILE: clippy_lints/src/assertions_on_result_states.rs
  method check_expr (line 51) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
  function type_suitable_to_unwrap (line 100) | fn type_suitable_to_unwrap<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -...

FILE: clippy_lints/src/assigning_clones.rs
  type AssigningClones (line 58) | pub struct AssigningClones {
    method new (line 63) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 69) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
  function clone_source_borrows_from_dest (line 155) | fn clone_source_borrows_from_dest(cx: &LateContext<'_>, lhs: &Expr<'_>, ...
  type CloneTrait (line 202) | enum CloneTrait {
  type CallKind (line 208) | enum CallKind {
  function build_sugg (line 213) | fn build_sugg<'tcx>(

FILE: clippy_lints/src/async_yields_async.rs
  method check_expr (line 51) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {

FILE: clippy_lints/src/attrs/allow_attributes.rs
  function check (line 10) | pub fn check<'cx>(cx: &EarlyContext<'cx>, attr: &'cx Attribute) {

FILE: clippy_lints/src/attrs/allow_attributes_without_reason.rs
  function check (line 9) | pub(super) fn check<'cx>(cx: &EarlyContext<'cx>, name: Symbol, items: &[...

FILE: clippy_lints/src/attrs/blanket_clippy_restriction_lints.rs
  function check (line 10) | pub(super) fn check(cx: &EarlyContext<'_>, name: Symbol, items: &[MetaIt...
  function check_command_line (line 25) | pub(super) fn check_command_line(cx: &EarlyContext<'_>) {

FILE: clippy_lints/src/attrs/deprecated_cfg_attr.rs
  function check (line 9) | pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msrv...
  function check_clippy (line 52) | pub(super) fn check_clippy(cx: &EarlyContext<'_>, attr: &Attribute) {
  function check_deprecated_cfg_recursively (line 62) | fn check_deprecated_cfg_recursively(cx: &EarlyContext<'_>, attr: &rustc_...
  function check_cargo_clippy_attr (line 75) | fn check_cargo_clippy_attr(cx: &EarlyContext<'_>, item: &rustc_ast::Meta...

FILE: clippy_lints/src/attrs/deprecated_semver.rs
  function check (line 10) | pub(super) fn check(cx: &EarlyContext<'_>, span: Span, lit: &MetaItemLit) {

FILE: clippy_lints/src/attrs/duplicated_attributes.rs
  function emit_if_duplicated (line 11) | fn emit_if_duplicated(
  function check_duplicated_attr (line 30) | fn check_duplicated_attr(
  function check (line 82) | pub fn check(cx: &EarlyContext<'_>, attrs: &[Attribute]) {

FILE: clippy_lints/src/attrs/inline_always.rs
  function check (line 9) | pub(super) fn check(cx: &LateContext<'_>, span: Span, name: Symbol, attr...

FILE: clippy_lints/src/attrs/mixed_attributes_style.rs
  type SimpleAttrKind (line 11) | enum SimpleAttrKind {
    method from (line 18) | fn from(value: &AttrKind) -> Self {
  function check (line 35) | pub(super) fn check(cx: &EarlyContext<'_>, item_span: Span, attrs: &[Att...
  function lint_mixed_attrs (line 67) | fn lint_mixed_attrs(cx: &EarlyContext<'_>, attrs: &[Attribute]) {
  function attr_in_same_src_as_item (line 82) | fn attr_in_same_src_as_item(source_map: &SourceMap, item_src: &Arc<Sourc...

FILE: clippy_lints/src/attrs/mod.rs
  type Attributes (line 502) | pub struct Attributes {
    method new (line 507) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 513) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
    method check_impl_item (line 523) | fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Impl...
    method check_trait_item (line 529) | fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Tra...
  type EarlyAttributes (line 536) | pub struct EarlyAttributes {
    method new (line 541) | pub fn new(conf: &'static Conf) -> Self {
  method check_attribute (line 549) | fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
  type PostExpansionEarlyAttributes (line 558) | pub struct PostExpansionEarlyAttributes {
    method new (line 563) | pub fn new(conf: &'static Conf) -> Self {
  method check_crate (line 571) | fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &ast::Crate) {
  method check_attribute (line 576) | fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
  method check_item (line 625) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &'_ ast::Item) {

FILE: clippy_lints/src/attrs/non_minimal_cfg.rs
  function check (line 9) | pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute) {
  function check_nested_cfg (line 17) | fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[MetaItemInner]) {

FILE: clippy_lints/src/attrs/repr_attributes.rs
  function check (line 11) | pub(super) fn check(cx: &LateContext<'_>, item_span: Span, attrs: &[Attr...

FILE: clippy_lints/src/attrs/should_panic_without_expect.rs
  function check (line 10) | pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute) {

FILE: clippy_lints/src/attrs/unnecessary_clippy_cfg.rs
  function check (line 10) | pub(super) fn check(

FILE: clippy_lints/src/attrs/useless_attribute.rs
  function check (line 10) | pub(super) fn check(cx: &EarlyContext<'_>, item: &Item, attrs: &[Attribu...

FILE: clippy_lints/src/attrs/utils.rs
  function is_word (line 11) | pub(super) fn is_word(nmi: &MetaItemInner, expected: Symbol) -> bool {
  function is_lint_level (line 19) | pub(super) fn is_lint_level(symbol: Symbol, attr_id: AttrId) -> bool {
  function is_relevant_item (line 23) | pub(super) fn is_relevant_item(cx: &LateContext<'_>, item: &Item<'_>) ->...
  function is_relevant_impl (line 31) | pub(super) fn is_relevant_impl(cx: &LateContext<'_>, item: &ImplItem<'_>...
  function is_relevant_trait (line 38) | pub(super) fn is_relevant_trait(cx: &LateContext<'_>, item: &TraitItem<'...
  function is_relevant_block (line 48) | fn is_relevant_block(cx: &LateContext<'_>, typeck_results: &ty::TypeckRe...
  function is_relevant_expr (line 64) | fn is_relevant_expr(cx: &LateContext<'_>, typeck_results: &ty::TypeckRes...
  function extract_clippy_lint (line 79) | pub(super) fn extract_clippy_lint(lint: &MetaItemInner) -> Option<Symbol> {
  function namespace_and_lint (line 88) | pub(super) fn namespace_and_lint(lint: &MetaItemInner) -> (Option<Symbol...

FILE: clippy_lints/src/await_holding_invalid.rs
  type AwaitHolding (line 181) | pub struct AwaitHolding {
    method new (line 186) | pub(crate) fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
    method check_expr (line 200) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr...
    method check_interior_types (line 214) | fn check_interior_types(&self, cx: &LateContext<'_>, coroutine: &Corou...
  function emit_invalid_type (line 268) | fn emit_invalid_type(
  function is_mutex_guard (line 283) | fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {
  function is_refcell_ref (line 290) | fn is_refcell_ref(cx: &LateContext<'_>, def_id: DefId) -> bool {

FILE: clippy_lints/src/blocks_in_conditions.rs
  constant BRACED_EXPR_MESSAGE (line 52) | const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression ...
  method check_expr (line 55) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/bool_assert_comparison.rs
  function extract_bool_lit (line 40) | fn extract_bool_lit(e: &Expr<'_>) -> Option<bool> {
  function is_impl_not_trait_with_bool_out (line 52) | fn is_impl_not_trait_with_bool_out<'tcx>(cx: &LateContext<'tcx>, ty: Ty<...
  method check_expr (line 74) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/bool_comparison.rs
  method check_expr (line 40) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
  function check_comparison (line 106) | fn check_comparison<'a, 'tcx>(
  function suggest_bool_comparison (line 152) | fn suggest_bool_comparison<'a, 'tcx>(
  function fetch_bool_expr (line 172) | fn fetch_bool_expr(expr: &Expr<'_>) -> Option<bool> {

FILE: clippy_lints/src/bool_to_int_with_if.rs
  method check_expr (line 49) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
  function as_int_bool_lit (line 102) | fn as_int_bool_lit(expr: &Expr<'_>) -> Option<bool> {

FILE: clippy_lints/src/booleans.rs
  constant METHODS_WITH_NEGATION (line 80) | const METHODS_WITH_NEGATION: [(Option<RustcVersion>, Symbol, Symbol); 3]...
  type NonminimalBool (line 86) | pub struct NonminimalBool {
    method new (line 91) | pub fn new(conf: &'static Conf) -> Self {
    method check_fn (line 97) | fn check_fn(
    method check_expr (line 109) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...
  function inverted_bin_op_eq_str (line 125) | fn inverted_bin_op_eq_str(op: BinOpKind) -> Option<&'static str> {
  function bin_op_eq_str (line 133) | fn bin_op_eq_str(op: BinOpKind) -> Option<&'static str> {
  function check_inverted_bool_in_condition (line 141) | fn check_inverted_bool_in_condition(
  function check_simplify_not (line 199) | fn check_simplify_not(cx: &LateContext<'_>, msrv: Msrv, expr: &Expr<'_>) {
  type NonminimalBoolVisitor (line 233) | struct NonminimalBoolVisitor<'a, 'tcx> {
  type Hir2Qmm (line 239) | struct Hir2Qmm<'a, 'tcx, 'v> {
  function extract (line 245) | fn extract(&mut self, op: BinOpKind, a: &[&'v Expr<'_>], mut v: Vec<Bool...
  function run (line 258) | fn run(&mut self, e: &'v Expr<'_>) -> Result<Bool, String> {
  type SuggestContext (line 325) | struct SuggestContext<'a, 'tcx, 'v> {
  function recurse (line 333) | fn recurse(&mut self, suggestion: &Bool) -> Option<()> {
  function simplify_not (line 403) | fn simplify_not(cx: &LateContext<'_>, curr_msrv: Msrv, expr: &Expr<'_>) ...
  function suggest (line 473) | fn suggest(cx: &LateContext<'_>, msrv: Msrv, suggestion: &Bool, terminal...
  function simple_negate (line 484) | fn simple_negate(b: Bool) -> Bool {
  type Stats (line 507) | struct Stats {
  function terminal_stats (line 513) | fn terminal_stats(b: &Bool) -> Stats {
  function bool_expr (line 540) | fn bool_expr(&self, e: &'tcx Expr<'_>) {
  function visit_expr (line 647) | fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
  function implements_ord (line 672) | fn implements_ord(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/borrow_deref_ref.rs
  method check_expr (line 54) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) {
  function potentially_bound_to_mutable_ref (line 131) | fn potentially_bound_to_mutable_ref<'tcx>(cx: &LateContext<'tcx>, expr: ...

FILE: clippy_lints/src/box_default.rs
  method check_expr (line 39) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  function is_plain_default (line 73) | fn is_plain_default(cx: &LateContext<'_>, arg_path: &Expr<'_>) -> bool {
  function is_local_vec_expn (line 85) | fn is_local_vec_expn(cx: &LateContext<'_>, expr: &Expr<'_>, ref_expr: &E...
  type InferVisitor (line 92) | struct InferVisitor(bool);
    method visit_infer (line 95) | fn visit_infer(&mut self, inf_id: HirId, _inf_span: Span, _kind: Infer...
    method visit_ty (line 100) | fn visit_ty(&mut self, t: &Ty<'_, AmbigArg>) {
  function given_type (line 108) | fn given_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/byte_char_slices.rs
  method check_expr (line 34) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  function is_byte_char_slices (line 52) | fn is_byte_char_slices(expr: &Expr) -> Option<String> {

FILE: clippy_lints/src/cargo/common_metadata.rs
  function check (line 8) | pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata, ignore_pu...
  function missing_warning (line 40) | fn missing_warning(cx: &LateContext<'_>, package: &cargo_metadata::Packa...
  function is_empty_str (line 45) | fn is_empty_str<T: AsRef<std::ffi::OsStr>>(value: Option<&T>) -> bool {
  function is_empty_vec (line 49) | fn is_empty_vec(value: &[String]) -> bool {

FILE: clippy_lints/src/cargo/feature_name.rs
  function check (line 11) | pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {
  function is_negative_prefix (line 45) | fn is_negative_prefix(s: &str) -> bool {
  function lint (line 49) | fn lint(cx: &LateContext<'_>, feature: &str, substring: &str, is_prefix:...
  function test_prefixes_sorted (line 83) | fn test_prefixes_sorted() {

FILE: clippy_lints/src/cargo/lint_groups_priority.rs
  function toml_span (line 12) | fn toml_span(range: Range<usize>, file: &SourceFile) -> Span {
  type LintConfig (line 21) | struct LintConfig<'a> {
  function priority (line 27) | fn priority(&self) -> i64 {
  function is_implicit (line 31) | fn is_implicit(&self) -> bool {
  function parse (line 35) | fn parse(value: &'a Spanned<DeValue<'a>>) -> Option<Self> {
  function check_table (line 55) | fn check_table(cx: &LateContext<'_>, table: &DeTable<'_>, known_groups: ...
  type LintTbls (line 112) | struct LintTbls<'a> {
  function get_lint_tbls (line 116) | fn get_lint_tbls<'a>(tbl: &'a DeTable<'a>) -> LintTbls<'a> {
  function check (line 131) | pub fn check(cx: &LateContext<'_>) {

FILE: clippy_lints/src/cargo/mod.rs
  type Cargo (line 225) | pub struct Cargo {
    method new (line 231) | pub fn new(conf: &'static Conf) -> Self {
    method check_crate (line 240) | fn check_crate(&mut self, cx: &LateContext<'_>) {

FILE: clippy_lints/src/cargo/multiple_crate_versions.rs
  function check (line 11) | pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata, allowed_d...
  function is_normal_dep (line 60) | fn is_normal_dep(nodes: &[Node], local_id: &PackageId, dep_id: &PackageI...

FILE: clippy_lints/src/cargo/wildcard_dependencies.rs
  function check (line 8) | pub(super) fn check(cx: &LateContext<'_>, metadata: &Metadata) {

FILE: clippy_lints/src/casts/as_pointer_underscore.rs
  function check (line 5) | pub fn check<'tcx>(cx: &LateContext<'tcx>, ty_into: Ty<'_>, cast_to_hir:...

FILE: clippy_lints/src/casts/as_ptr_cast_mut.rs
  function check (line 12) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...

FILE: clippy_lints/src/casts/as_underscore.rs
  function check (line 9) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ...

FILE: clippy_lints/src/casts/borrow_as_ptr.rs
  function check (line 14) | pub(super) fn check<'tcx>(
  function check_implicit_cast (line 61) | pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/casts/cast_abs_to_unsigned.rs
  function check (line 12) | pub(super) fn check(

FILE: clippy_lints/src/casts/cast_enum_constructor.rs
  function check (line 9) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...

FILE: clippy_lints/src/casts/cast_lossless.rs
  function check (line 15) | pub(super) fn check(
  function should_lint (line 79) | fn should_lint(cx: &LateContext<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>,...

FILE: clippy_lints/src/casts/cast_nan_to_int.rs
  function check (line 9) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...
  function is_known_nan (line 22) | fn is_known_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {

FILE: clippy_lints/src/casts/cast_possible_truncation.rs
  function constant_int (line 17) | fn constant_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
  function get_constant_bits (line 25) | fn get_constant_bits(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u6...
  function apply_reductions (line 29) | fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, s...
  function check (line 86) | pub(super) fn check(
  function offer_suggestion (line 179) | fn offer_suggestion(

FILE: clippy_lints/src/casts/cast_possible_wrap.rs
  constant ALLOWED_POINTER_SIZES (line 12) | const ALLOWED_POINTER_SIZES: [u64; 3] = [16, 32, 64];
  type EmitState (line 16) | enum EmitState {
  function check (line 22) | pub(super) fn check(

FILE: clippy_lints/src/casts/cast_precision_loss.rs
  function check (line 9) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty...

FILE: clippy_lints/src/casts/cast_ptr_alignment.rs
  function check (line 11) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, cast_...
  function check_cast_method (line 15) | pub(super) fn check_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>) {
  function lint_cast_ptr_alignment (line 28) | fn lint_cast_ptr_alignment<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>...
  function is_used_as_unaligned (line 53) | fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {

FILE: clippy_lints/src/casts/cast_sign_loss.rs
  constant METHODS_RET_POSITIVE (line 23) | const METHODS_RET_POSITIVE: &[Symbol] = &[
  constant METHODS_POW (line 37) | const METHODS_POW: &[Symbol] = &[sym::pow, sym::saturating_pow, sym::che...
  constant METHODS_UNWRAP (line 40) | const METHODS_UNWRAP: &[Symbol] = &[sym::unwrap, sym::unwrap_unchecked, ...
  function check (line 42) | pub(super) fn check<'cx>(
  function should_lint (line 79) | fn should_lint<'cx>(cx: &LateContext<'cx>, cast_op: &Expr<'_>, cast_from...
  function get_const_signed_int_eval (line 108) | fn get_const_signed_int_eval<'cx>(
  function get_const_unsigned_int_eval (line 123) | fn get_const_unsigned_int_eval<'cx>(
  type Sign (line 139) | enum Sign {
  function expr_sign (line 145) | fn expr_sign<'cx, 'tcx>(cx: &LateContext<'cx>, mut expr: &'tcx Expr<'tcx...
  function pow_call_result_sign (line 189) | fn pow_call_result_sign(cx: &LateContext<'_>, base: &Expr<'_>, exponent:...
  function expr_muldiv_sign (line 218) | fn expr_muldiv_sign(cx: &LateContext<'_>, expr: &Expr<'_>) -> Sign {
  function expr_add_sign (line 249) | fn expr_add_sign(cx: &LateContext<'_>, expr: &Expr<'_>) -> Sign {
  function exprs_with_muldiv_binop_peeled (line 290) | fn exprs_with_muldiv_binop_peeled<'e>(expr: &'e Expr<'_>) -> Vec<&'e Exp...
  function exprs_with_add_binop_peeled (line 339) | fn exprs_with_add_binop_peeled<'e>(expr: &'e Expr<'_>) -> Vec<&'e Expr<'...

FILE: clippy_lints/src/casts/cast_slice_different_sizes.rs
  function check (line 12) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msr...
  function is_child_of_cast (line 63) | fn is_child_of_cast(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function get_raw_slice_ty_mut (line 82) | fn get_raw_slice_ty_mut(ty: Ty<'_>) -> Option<TypeAndMut<'_>> {
  type CastChainInfo (line 92) | struct CastChainInfo<'tcx> {
  function expr_cast_chain_tys (line 105) | fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ...

FILE: clippy_lints/src/casts/cast_slice_from_raw_parts.rs
  type RawPartsKind (line 15) | enum RawPartsKind {
  function raw_parts_kind (line 20) | fn raw_parts_kind(cx: &LateContext<'_>, did: DefId) -> Option<RawPartsKi...
  function check (line 28) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...
  function check_implicit_cast (line 61) | pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/casts/char_lit_as_u8.rs
  function check (line 11) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from_exp...

FILE: clippy_lints/src/casts/confusing_method_to_numeric_cast.rs
  function get_primitive_ty_name (line 13) | fn get_primitive_ty_name(ty: Ty<'_>) -> Option<&'static str> {
  function get_const_name_and_ty_name (line 23) | fn get_const_name_and_ty_name(
  function check (line 60) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...

FILE: clippy_lints/src/casts/fn_to_numeric_cast.rs
  function check (line 10) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...

FILE: clippy_lints/src/casts/fn_to_numeric_cast_any.rs
  function check (line 10) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...

FILE: clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
  function check (line 10) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &E...

FILE: clippy_lints/src/casts/manual_dangling_ptr.rs
  function check (line 13) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'...
  function is_expr_const_aligned (line 49) | fn is_expr_const_aligned(cx: &LateContext<'_>, expr: &Expr<'_>, to: &Ty<...
  function is_align_of_call (line 57) | fn is_align_of_call(cx: &LateContext<'_>, fun: &Expr<'_>, to: &Ty<'_>) -...
  function is_literal_aligned (line 69) | fn is_literal_aligned(cx: &LateContext<'_>, lit: &Spanned<LitKind>, to: ...

FILE: clippy_lints/src/casts/mod.rs
  type Casts (line 880) | pub struct Casts {
    method new (line 885) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 891) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
    method check_body (line 958) | fn check_body(&mut self, cx: &LateContext<'tcx>, body: &rustc_hir::Bod...

FILE: clippy_lints/src/casts/needless_type_cast.rs
  type BindingInfo (line 16) | struct BindingInfo<'a> {
  type UsageInfo (line 22) | struct UsageInfo<'a> {
  function check (line 27) | pub(super) fn check<'a>(cx: &LateContext<'a>, body: &Body<'a>) {
  function collect_binding_from_let (line 56) | fn collect_binding_from_let<'a>(
  function collect_binding_from_local (line 86) | fn collect_binding_from_local<'a>(
  function contains_unsafe (line 117) | fn contains_unsafe(expr: &Expr<'_>) -> bool {
  function has_generic_return_type (line 129) | fn has_generic_return_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function is_generic_res (line 182) | fn is_generic_res(cx: &LateContext<'_>, res: Res) -> bool {
  function is_cast_in_generic_context (line 193) | fn is_cast_in_generic_context<'a>(cx: &LateContext<'a>, cast_expr: &Expr...
  function can_coerce_to_target_type (line 237) | fn can_coerce_to_target_type(expr: &Expr<'_>) -> bool {
  function check_binding_usages (line 249) | fn check_binding_usages<'a>(cx: &LateContext<'a>, body: &Body<'a>, hir_i...

FILE: clippy_lints/src/casts/ptr_as_ptr.rs
  type OmitFollowedCastReason (line 14) | enum OmitFollowedCastReason<'a> {
  function corresponding_item (line 21) | fn corresponding_item(&self) -> Option<&QPath<'_>> {
  function check (line 29) | pub(super) fn check<'tcx>(
  function qpath_span_without_turbofish (line 104) | fn qpath_span_without_turbofish(qpath: &QPath<'_>) -> Span {

FILE: clippy_lints/src/casts/ptr_cast_constness.rs
  function check (line 13) | pub(super) fn check<'tcx>(
  function check_null_ptr_cast_method (line 79) | pub(super) fn check_null_ptr_cast_method(cx: &LateContext<'_>, expr: &Ex...

FILE: clippy_lints/src/casts/ref_as_ptr.rs
  function check (line 12) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/casts/unnecessary_cast.rs
  function check (line 20) | pub(super) fn check<'tcx>(
  function lint_unnecessary_cast (line 210) | fn lint_unnecessary_cast(
  function get_numeric_literal (line 245) | fn get_numeric_literal<'e>(expr: &'e Expr<'e>) -> Option<Lit> {
  function fp_ty_mantissa_nbits (line 261) | fn fp_ty_mantissa_nbits(typ: Ty<'_>) -> u32 {
  function is_cast_from_ty_alias (line 273) | fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visita...

FILE: clippy_lints/src/casts/utils.rs
  function int_ty_to_nbits (line 6) | pub(super) fn int_ty_to_nbits(tcx: TyCtxt<'_>, ty: Ty<'_>) -> Option<u64> {
  function enum_value_nbits (line 15) | pub(super) fn enum_value_nbits(value: EnumValue) -> u64 {
  function enum_ty_to_nbits (line 24) | pub(super) fn enum_ty_to_nbits(adt: AdtDef<'_>, tcx: TyCtxt<'_>) -> u64 {
  type CastTo (line 64) | pub(super) enum CastTo {
  function is_signedness_cast (line 71) | pub(super) fn is_signedness_cast(cast_from: Ty<'_>, cast_to: Ty<'_>) -> ...

FILE: clippy_lints/src/casts/zero_ptr.rs
  function check (line 11) | pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to:...

FILE: clippy_lints/src/cfg_not_test.rs
  method check_attribute (line 36) | fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &rustc_ast::A...
  function contains_not_test (line 58) | fn contains_not_test(cfg: &CfgEntry, not: bool) -> bool {

FILE: clippy_lints/src/checked_conversions.rs
  type CheckedConversions (line 39) | pub struct CheckedConversions {
    method new (line 44) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 50) | fn check_expr(&mut self, cx: &LateContext<'_>, item: &Expr<'_>) {
  type Conversion (line 100) | struct Conversion<'a> {
  type ConversionType (line 108) | enum ConversionType {
    method try_new (line 176) | fn try_new(from: Symbol, to: Symbol) -> Option<Self> {
  function read_le_ge (line 115) | fn read_le_ge<'tcx>(
  function combine (line 129) | pub fn combine(self, other: Self, cx: &LateContext<'_>) -> Option<Conver...
  function is_compatible (line 140) | pub fn is_compatible(&self, other: &Self, cx: &LateContext<'_>) -> bool {
  function has_compatible_to_type (line 147) | fn has_compatible_to_type(&self, other: &Self) -> bool {
  function try_new (line 155) | fn try_new(expr_to_cast: &'a Expr<'_>, from_type: Symbol, to_type: Symbo...
  function new_any (line 164) | fn new_any(expr_to_cast: &'a Expr<'_>) -> Conversion<'a> {
  function check_upper_bound (line 194) | fn check_upper_bound<'tcx>(lt: &'tcx Expr<'tcx>, gt: &'tcx Expr<'tcx>) -...
  function check_lower_bound (line 203) | fn check_lower_bound<'tcx>(lt: &'tcx Expr<'tcx>, gt: &'tcx Expr<'tcx>) -...
  function check_lower_bound_zero (line 208) | fn check_lower_bound_zero<'a>(candidate: &'a Expr<'_>, check: &'a Expr<'...
  function check_lower_bound_min (line 213) | fn check_lower_bound_min<'a>(candidate: &'a Expr<'_>, check: &'a Expr<'_...
  function get_types_from_cast (line 222) | fn get_types_from_cast(
  function get_implementing_type (line 278) | fn get_implementing_type(path: &QPath<'_>, candidates: &[Symbol], functi...
  function int_ty_to_sym (line 291) | fn int_ty_to_sym(path: &QPath<'_>) -> Option<Symbol> {
  constant UINTS (line 302) | const UINTS: &[Symbol] = &[sym::u8, sym::u16, sym::u32, sym::u64, sym::u...
  constant SINTS (line 303) | const SINTS: &[Symbol] = &[sym::i8, sym::i16, sym::i32, sym::i64, sym::i...
  constant INTS (line 304) | const INTS: &[Symbol] = &[

FILE: clippy_lints/src/cloned_ref_to_slice_refs.rs
  type ClonedRefToSliceRefs (line 49) | pub struct ClonedRefToSliceRefs<'a> {
  function new (line 53) | pub fn new(conf: &'a Conf) -> Self {
  function check_expr (line 59) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {

FILE: clippy_lints/src/coerce_container_to_any.rs
  method check_expr (line 53) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
  function is_ref_dyn_any (line 102) | fn is_ref_dyn_any(tcx: TyCtxt<'_>, ty: Ty<'_>) -> bool {
  function is_dyn_any (line 109) | fn is_dyn_any(tcx: TyCtxt<'_>, ty: Ty<'_>) -> bool {

FILE: clippy_lints/src/cognitive_complexity.rs
  type CognitiveComplexity (line 45) | pub struct CognitiveComplexity {
    method new (line 50) | pub fn new(conf: &'static Conf) -> Self {
    method check (line 58) | fn check<'tcx>(
    method check_fn (line 138) | fn check_fn(
    method check_attributes (line 164) | fn check_attributes(&mut self, cx: &LateContext<'tcx>, attrs: &'tcx [A...
    method check_attributes_post (line 167) | fn check_attributes_post(&mut self, cx: &LateContext<'tcx>, attrs: &'t...

FILE: clippy_lints/src/collapsible_if.rs
  type CollapsibleIf (line 84) | pub struct CollapsibleIf {
    method new (line 90) | pub fn new(conf: &'static Conf) -> Self {
    method check_collapsible_else_if (line 97) | fn check_collapsible_else_if(&self, cx: &LateContext<'_>, then_span: S...
    method check_collapsible_if_if (line 166) | fn check_collapsible_if_if(&self, cx: &LateContext<'_>, expr: &Expr<'_...
    method eligible_condition (line 217) | fn eligible_condition(&self, cx: &LateContext<'_>, cond: &Expr<'_>) ->...
    method check_significant_tokens_and_expect_attrs (line 226) | fn check_significant_tokens_and_expect_attrs(
    method check_expr (line 262) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  function single_inner_if_else (line 284) | fn single_inner_if_else(expr: &Expr<'_>) -> bool {
  function expr_block (line 298) | fn expr_block<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {
  function parens_around (line 307) | pub(super) fn parens_around(expr: &Expr<'_>) -> Vec<(Span, String)> {
  function span_extract_keyword (line 320) | fn span_extract_keyword(cx: &impl HasSession, span: Span, keyword: &str)...
  function peel_parens (line 336) | pub(super) fn peel_parens(cx: &impl HasSession, mut span: Span) -> (Span...
  function peel_parens_str (line 354) | fn peel_parens_str(snippet: &str) -> Option<(usize, &str, usize)> {

FILE: clippy_lints/src/collection_is_never_read.rs
  method check_local (line 47) | fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx LetStmt<'...
  function match_acceptable_type (line 59) | fn match_acceptable_type(cx: &LateContext<'_>, local: &LetStmt<'_>) -> b...
  function has_no_read_access (line 77) | fn has_no_read_access<'tcx, T: Visitable<'tcx>>(cx: &LateContext<'tcx>, ...

FILE: clippy_lints/src/comparison_chain.rs
  method check_expr (line 59) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function kind_is_cmp (line 143) | fn kind_is_cmp(kind: BinOpKind) -> bool {

FILE: clippy_lints/src/copy_iterator.rs
  method check_item (line 38) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {

FILE: clippy_lints/src/crate_in_macro_def.rs
  method check_item (line 56) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
  function is_macro_export (line 74) | fn is_macro_export(attr: &Attribute) -> bool {
  function contains_unhygienic_crate_reference (line 84) | fn contains_unhygienic_crate_reference(tts: &TokenStream) -> Option<Span> {
  function is_crate_keyword (line 106) | fn is_crate_keyword(tt: &TokenTree) -> Option<Span> {
  function is_token (line 121) | fn is_token(tt: &TokenTree, kind: &TokenKind) -> bool {

FILE: clippy_lints/src/create_dir.rs
  method check_expr (line 35) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/dbg_macro.rs
  type DbgMacro (line 38) | pub struct DbgMacro {
    method new (line 47) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 57) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
    method check_crate_post (line 131) | fn check_crate_post(&mut self, _: &LateContext<'_>) {
  function is_coroutine_desugar (line 136) | fn is_coroutine_desugar(expr: &Expr<'_>) -> bool {
  function is_async_move_desugar (line 146) | fn is_async_move_desugar<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx E...
  function first_dbg_macro_in_expansion (line 165) | fn first_dbg_macro_in_expansion(cx: &LateContext<'_>, span: Span) -> Opt...
  function collect_vals (line 183) | fn collect_vals<'hir>(first: &'hir Expr<'hir>, mut arms: &'hir [Arm<'hir...

FILE: clippy_lints/src/default.rs
  type Default (line 75) | pub struct Default {
    method check_expr (line 81) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
    method check_block (line 111) | fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) {
  function field_reassigned_by_stmt (line 254) | fn field_reassigned_by_stmt<'tcx>(this: &Stmt<'tcx>, binding_name: Symbo...
  function is_update_syntax_base (line 272) | fn is_update_syntax_base<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<...

FILE: clippy_lints/src/default_constructed_unit_structs.rs
  function is_alias (line 53) | fn is_alias(ty: hir::Ty<'_>) -> bool {
  method check_expr (line 62) | fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::...

FILE: clippy_lints/src/default_instead_of_iter_empty.rs
  method check_expr (line 35) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function make_sugg (line 62) | fn make_sugg(

FILE: clippy_lints/src/default_numeric_fallback.rs
  method check_body (line 54) | fn check_body(&mut self, cx: &LateContext<'tcx>, body: &Body<'tcx>) {
  type NumericFallbackVisitor (line 66) | struct NumericFallbackVisitor<'a, 'tcx> {
  function new (line 74) | fn new(cx: &'a LateContext<'tcx>, is_parent_const: bool) -> Self {
  function check_lit (line 86) | fn check_lit(&self, lit: Lit, lit_ty: Ty<'tcx>, emit_hir_id: HirId) {
  function visit_expr (line 125) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
  function visit_pat (line 223) | fn visit_pat(&mut self, pat: &'tcx Pat<'_>) {
  function visit_stmt (line 237) | fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
  function fn_sig_opt (line 250) | fn fn_sig_opt<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<Pol...
  type ExplicitTyBound (line 262) | struct ExplicitTyBound(pub bool);
    method from (line 265) | fn from(v: Ty<'tcx>) -> Self {
    method from (line 271) | fn from(v: Option<Ty<'tcx>>) -> Self {

FILE: clippy_lints/src/default_union_representation.rs
  method check_item (line 55) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
  function is_union_with_two_non_zst_fields (line 81) | fn is_union_with_two_non_zst_fields<'tcx>(cx: &LateContext<'tcx>, item: ...
  function is_zst (line 91) | fn is_zst<'tcx>(cx: &LateContext<'tcx>, field: &FieldDef, args: ty::Gene...
  function has_c_repr_attr (line 100) | fn has_c_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {

FILE: clippy_lints/src/dereference.rs
  type Dereferencing (line 153) | pub struct Dereferencing<'tcx> {
  type StateData (line 180) | struct StateData<'tcx> {
  type DerefedBorrow (line 186) | struct DerefedBorrow {
  type State (line 194) | enum State {
  type RefOp (line 220) | enum RefOp {
  type RefPat (line 226) | struct RefPat {
  function check_expr (line 241) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function check_pat (line 614) | fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
  function check_body_post (line 657) | fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &Body<'_>) {
  function check_item (line 682) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
  function check_item_post (line 689) | fn check_item_post(&mut self, _cx: &LateContext<'_>, item: &Item<'_>) {
  function is_deref_or_derefmut_impl (line 697) | fn is_deref_or_derefmut_impl(cx: &LateContext<'_>, item: &Item<'_>) -> b...
  function try_parse_ref_op (line 708) | fn try_parse_ref_op<'tcx>(
  function deref_method_same_type (line 748) | fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -...
  function is_in_method_chain (line 759) | fn is_in_method_chain<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>)...
  type TyCoercionStability (line 784) | enum TyCoercionStability {
    method is_deref_stable (line 790) | fn is_deref_stable(self) -> bool {
    method is_reborrow_stable (line 794) | fn is_reborrow_stable(self) -> bool {
    method for_defined_ty (line 798) | fn for_defined_ty<'tcx>(cx: &LateContext<'tcx>, ty: DefinedTy<'tcx>, f...
    method for_hir_ty (line 819) | fn for_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Self {
    method for_mir_ty (line 872) | fn for_mir_ty<'tcx>(tcx: TyCtxt<'tcx>, def_site_def_id: Option<DefId>,...
  function ty_contains_infer (line 933) | fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
  function ty_contains_field (line 956) | fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
  function in_deref_impl (line 965) | fn in_deref_impl(&self) -> bool {
  function check_local_usage (line 969) | fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &Expr<'tcx>, ...
  function report (line 1029) | fn report(

FILE: clippy_lints/src/derivable_impls.rs
  type DerivableImpls (line 61) | pub struct DerivableImpls {
    method new (line 66) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 230) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
  function is_path_self (line 71) | fn is_path_self(e: &Expr<'_>) -> bool {
  function contains_trait_object (line 79) | fn contains_trait_object(ty: Ty<'_>) -> bool {
  function determine_derive_macro (line 88) | fn determine_derive_macro(cx: &LateContext<'_>, is_const: bool) -> Optio...
  function check_struct (line 95) | fn check_struct<'tcx>(
  function extract_enum_variant (line 160) | fn extract_enum_variant<'tcx>(
  function check_enum (line 187) | fn check_enum<'tcx>(

FILE: clippy_lints/src/derive/derive_ord_xor_partial_ord.rs
  function check (line 11) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/derive/derive_partial_eq_without_eq.rs
  function check (line 14) | pub(super) fn check<'tcx>(
  function ty_implements_eq_trait (line 53) | fn ty_implements_eq_trait<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, eq_trai...
  function typing_env_for_derived_eq (line 58) | fn typing_env_for_derived_eq(tcx: TyCtxt<'_>, did: DefId, eq_trait_id: D...

FILE: clippy_lints/src/derive/derived_hash_with_manual_eq.rs
  function check (line 10) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/derive/expl_impl_clone_on_copy.rs
  function check (line 11) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/derive/mod.rs
  method check_item (line 196) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {

FILE: clippy_lints/src/derive/unsafe_derive_deserialize.rs
  function check (line 16) | pub(super) fn check<'tcx>(
  type UnsafeVisitor (line 54) | struct UnsafeVisitor<'a, 'tcx> {
  type Result (line 59) | type Result = ControlFlow<()>;
  type NestedFilter (line 60) | type NestedFilter = nested_filter::All;
  function visit_fn (line 62) | fn visit_fn(
  function visit_expr (line 79) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> Self::Result {
  function maybe_tcx (line 94) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {

FILE: clippy_lints/src/disallowed_fields.rs
  type DisallowedFields (line 61) | pub struct DisallowedFields {
    method new (line 66) | pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
    method check_expr (line 80) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
    method check_pat (line 108) | fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {

FILE: clippy_lints/src/disallowed_macros.rs
  type DisallowedMacros (line 68) | pub struct DisallowedMacros {
    method new (line 81) | pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf, early_macro_cache: At...
    method check (line 98) | fn check(&mut self, cx: &LateContext<'_>, span: Span, derive_src: Opti...
    method check_crate (line 131) | fn check_crate(&mut self, cx: &LateContext<'_>) {
    method check_expr (line 140) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
    method check_stmt (line 148) | fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
    method check_ty (line 152) | fn check_ty(&mut self, cx: &LateContext<'_>, ty: &Ty<'_, AmbigArg>) {
    method check_pat (line 156) | fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
    method check_item (line 160) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
    method check_foreign_item (line 173) | fn check_foreign_item(&mut self, cx: &LateContext<'_>, item: &ForeignI...
    method check_impl_item (line 178) | fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &ImplItem<'_...
    method check_trait_item (line 185) | fn check_trait_item(&mut self, cx: &LateContext<'_>, item: &TraitItem<...
    method check_path (line 189) | fn check_path(&mut self, cx: &LateContext<'_>, path: &Path<'_>, _: Hir...

FILE: clippy_lints/src/disallowed_methods.rs
  type DisallowedMethods (line 66) | pub struct DisallowedMethods {
    method new (line 71) | pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
    method check_expr (line 90) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/disallowed_names.rs
  type DisallowedNames (line 31) | pub struct DisallowedNames {
    method new (line 36) | pub fn new(conf: &'static Conf) -> Self {
    method check_pat (line 44) | fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {

FILE: clippy_lints/src/disallowed_script_idents.rs
  type DisallowedScriptIdents (line 50) | pub struct DisallowedScriptIdents {
    method new (line 55) | pub fn new(conf: &'static Conf) -> Self {
  method check_crate (line 68) | fn check_crate(&mut self, cx: &EarlyContext<'_>, _: &ast::Crate) {

FILE: clippy_lints/src/disallowed_types.rs
  type DisallowedTypes (line 62) | pub struct DisallowedTypes {
    method new (line 68) | pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
    method check_res_emit (line 80) | fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
    method check_item (line 110) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx...
    method check_ty (line 118) | fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx Ty<'tcx, Ambi...
    method check_poly_trait_ref (line 124) | fn check_poly_trait_ref(&mut self, cx: &LateContext<'tcx>, poly: &'tcx...
  function def_kind_predicate (line 96) | pub fn def_kind_predicate(def_kind: DefKind) -> bool {

FILE: clippy_lints/src/doc/broken_link.rs
  function check (line 17) | pub fn check(cx: &LateContext<'_>, bl: &PullDownBrokenLink<'_>, doc: &st...
  function warn_if_broken_link (line 21) | fn warn_if_broken_link(cx: &LateContext<'_>, bl: &PullDownBrokenLink<'_>...
  function report_broken_link (line 71) | fn report_broken_link(cx: &LateContext<'_>, frag_span: Span, offset: usi...

FILE: clippy_lints/src/doc/doc_comment_double_space_linebreaks.rs
  function check (line 8) | pub fn check(cx: &LateContext<'_>, collected_breaks: &[Span]) {

FILE: clippy_lints/src/doc/doc_paragraphs_missing_punctuation.rs
  constant MSG (line 9) | const MSG: &str = "doc paragraphs should end with a terminal punctuation...
  constant PUNCTUATION_SUGGESTION (line 10) | const PUNCTUATION_SUGGESTION: char = '.';
  function check (line 12) | pub fn check(cx: &LateContext<'_>, doc: &str, fragments: Fragments<'_>) {
  function is_missing_punctuation (line 48) | fn is_missing_punctuation(doc_string: &str) -> Vec<MissingPunctuation> {
  function trim_trailing_symbols (line 125) | fn trim_trailing_symbols(s: &str) -> &str {
  type MissingPunctuation (line 141) | enum MissingPunctuation {

FILE: clippy_lints/src/doc/doc_suspicious_footnotes.rs
  function check (line 13) | pub fn check(cx: &LateContext<'_>, doc: &str, range: Range<usize>, fragm...
  function all_numbers_upto_brace (line 117) | fn all_numbers_upto_brace(text: &str, i: usize) -> Option<usize> {

FILE: clippy_lints/src/doc/include_in_doc_without_cfg.rs
  function check (line 9) | pub fn check(cx: &EarlyContext<'_>, attrs: &[Attribute]) {

FILE: clippy_lints/src/doc/lazy_continuation.rs
  function map_container_to_text (line 10) | fn map_container_to_text(c: &super::Container) -> &'static str {
  function check (line 18) | pub(super) fn check(

FILE: clippy_lints/src/doc/link_with_quotes.rs
  function check (line 8) | pub fn check(cx: &LateContext<'_>, trimmed_text: &str, range: Range<usiz...

FILE: clippy_lints/src/doc/markdown.rs
  function check (line 12) | pub fn check(
  function check_word (line 85) | fn check_word(

FILE: clippy_lints/src/doc/missing_headers.rs
  function check (line 14) | pub fn check(
  function find_panic (line 99) | fn find_panic(cx: &LateContext<'_>, body_id: BodyId) -> Option<Span> {

FILE: clippy_lints/src/doc/mod.rs
  type Documentation (line 730) | pub struct Documentation {
    method new (line 736) | pub fn new(conf: &'static Conf) -> Self {
    method check_attributes (line 751) | fn check_attributes(&mut self, cx: &LateContext<'tcx>, attrs: &'tcx [A...
  method check_attributes (line 745) | fn check_attributes(&mut self, cx: &EarlyContext<'_>, attrs: &[rustc_ast...
  type Fragments (line 818) | struct Fragments<'a> {
  function span (line 827) | fn span(self, cx: &LateContext<'_>, range: Range<usize>) -> Option<Span> {
  type DocHeaders (line 833) | struct DocHeaders {
  function check_attrs (line 847) | fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, a...
  type Container (line 941) | enum Container {
  function check_for_code_clusters (line 950) | fn check_for_code_clusters<'a, Events: Iterator<Item = (pulldown_cmark::...
  type CodeTags (line 1007) | struct CodeTags {
    method parse (line 1031) | fn parse(lang: &str) -> Self {
  method default (line 1017) | fn default() -> Self {
  function check_doc (line 1080) | fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Ran...
  function looks_like_refdef (line 1324) | fn looks_like_refdef(doc: &str, range: Range<usize>) -> Option<Range<usi...

FILE: clippy_lints/src/doc/needless_doctest_main.rs
  function returns_unit (line 9) | fn returns_unit<'a>(mut tokens: impl Iterator<Item = (TokenKind, &'a str...
  function check (line 26) | pub fn check(cx: &LateContext<'_>, text: &str, offset: usize, fragments:...

FILE: clippy_lints/src/doc/suspicious_doc_comments.rs
  function check (line 12) | pub fn check(cx: &LateContext<'_>, attrs: &[Attribute]) -> bool {
  function collect_doc_replacements (line 36) | fn collect_doc_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {

FILE: clippy_lints/src/doc/test_attr_in_doctest.rs
  function check (line 8) | pub fn check(cx: &LateContext<'_>, text: &str, offset: usize, fragments:...

FILE: clippy_lints/src/doc/too_long_first_doc_paragraph.rs
  function check (line 12) | pub(super) fn check(

FILE: clippy_lints/src/double_parens.rs
  method check_expr (line 44) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  function check_source (line 104) | fn check_source(cx: &EarlyContext<'_>, inner: &Expr) -> bool {

FILE: clippy_lints/src/drop_forget_ref.rs
  constant DROP_NON_DROP_SUMMARY (line 75) | const DROP_NON_DROP_SUMMARY: &str = "call to `std::mem::drop` with a val...
  constant FORGET_NON_DROP_SUMMARY (line 77) | const FORGET_NON_DROP_SUMMARY: &str = "call to `std::mem::forget` with a...
  method check_expr (line 81) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function is_single_call_in_arm (line 143) | fn is_single_call_in_arm<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'...

FILE: clippy_lints/src/duplicate_mod.rs
  type Modules (line 51) | struct Modules {
  type DuplicateMod (line 58) | pub struct DuplicateMod {
  method check_item (line 65) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
  method check_crate_post (line 81) | fn check_crate_post(&mut self, cx: &EarlyContext<'_>, _: &Crate) {

FILE: clippy_lints/src/duration_suboptimal_units.rs
  type DurationSuboptimalUnits (line 53) | pub struct DurationSuboptimalUnits {
    method new (line 59) | pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
    method check_expr (line 70) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
    method promote (line 117) | fn promote(&self, cx: &LateContext<'_>, constructor_name: Symbol, valu...
  type Unit (line 143) | struct Unit {
  constant UNITS (line 159) | const UNITS: [Unit; 6] = [
  constant EXTENDED_UNITS (line 194) | const EXTENDED_UNITS: [Unit; 2] = [

FILE: clippy_lints/src/else_if_without_else.rs
  method check_expr (line 49) | fn check_expr(&mut self, cx: &EarlyContext<'_>, item: &Expr) {

FILE: clippy_lints/src/empty_drop.rs
  method check_item (line 38) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {

FILE: clippy_lints/src/empty_enums.rs
  method check_item (line 61) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {

FILE: clippy_lints/src/empty_line_after.rs
  type ItemInfo (line 97) | struct ItemInfo {
  type EmptyLineAfter (line 104) | pub struct EmptyLineAfter {
    method new (line 109) | pub fn new() -> Self {
    method check_gaps (line 308) | fn check_gaps(&self, cx: &EarlyContext<'_>, gaps: &[Gap<'_>], id: Node...
    method suggest_inner (line 401) | fn suggest_inner(&self, diag: &mut Diag<'_, ()>, kind: StopKind, gaps:...
    method check_item_kind (line 428) | fn check_item_kind(
  type StopKind (line 115) | enum StopKind {
    method is_doc (line 121) | fn is_doc(self) -> bool {
  type Stop (line 127) | struct Stop {
    method is_outer_attr_only (line 136) | fn is_outer_attr_only(&self) -> bool {
    method convert_to_inner (line 177) | fn convert_to_inner(&self) -> Option<(Span, String)> {
    method comment_out (line 191) | fn comment_out(&self, cx: &EarlyContext<'_>, suggestions: &mut Vec<(Sp...
    method from_attr (line 213) | fn from_attr(cx: &EarlyContext<'_>, attr: &Attribute) -> Option<Self> {
  type Gap (line 242) | struct Gap<'a> {
  function new (line 253) | fn new(cx: &EarlyContext<'_>, prev_chunk: &'a [Stop], next_chunk: &'a [S...
  function contiguous_empty_lines (line 293) | fn contiguous_empty_lines(&self) -> impl Iterator<Item = Span> + '_ {
  method check_crate (line 500) | fn check_crate(&mut self, _: &EarlyContext<'_>, krate: &Crate) {
  method check_item_post (line 514) | fn check_item_post(&mut self, _: &EarlyContext<'_>, _: &Item) {
  method check_impl_item_post (line 517) | fn check_impl_item_post(&mut self, _: &EarlyContext<'_>, _: &Item<AssocI...
  method check_trait_item_post (line 520) | fn check_trait_item_post(&mut self, _: &EarlyContext<'_>, _: &Item<Assoc...
  method check_impl_item (line 524) | fn check_impl_item(&mut self, cx: &EarlyContext<'_>, item: &Item<AssocIt...
  method check_trait_item (line 535) | fn check_trait_item(&mut self, cx: &EarlyContext<'_>, item: &Item<AssocI...
  method check_item (line 546) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {

FILE: clippy_lints/src/empty_with_brackets.rs
  type Usage (line 86) | enum Usage {
  type EmptyWithBrackets (line 93) | pub struct EmptyWithBrackets {
    method check_item (line 99) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
    method check_variant (line 125) | fn check_variant(&mut self, cx: &LateContext<'_>, variant: &Variant<'_...
    method check_expr (line 147) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
    method check_pat (line 168) | fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
    method check_crate_post (line 176) | fn check_crate_post(&mut self, cx: &LateContext<'_>) {
    method add_enum_variant (line 232) | fn add_enum_variant(&mut self, local_def_id: LocalDefId) {
    method update_enum_variant_usage (line 250) | fn update_enum_variant_usage(&mut self, def_id: LocalDefId, parenthese...
  function has_brackets (line 268) | fn has_brackets(var_data: &VariantData<'_>) -> bool {
  function has_no_fields (line 272) | fn has_no_fields(cx: &LateContext<'_>, var_data: &VariantData<'_>, brace...
  function call_parentheses_span (line 281) | fn call_parentheses_span(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> Option<Spa...
  function check_expr_for_enum_as_function (line 293) | fn check_expr_for_enum_as_function(cx: &LateContext<'_>, expr: &Expr<'_>...
  function check_pat_for_enum_as_function (line 317) | fn check_pat_for_enum_as_function(cx: &LateContext<'_>, pat: &Pat<'_>) -...

FILE: clippy_lints/src/endian_bytes.rs
  constant HOST_NAMES (line 72) | const HOST_NAMES: [Symbol; 2] = [sym::from_ne_bytes, sym::to_ne_bytes];
  constant LITTLE_NAMES (line 73) | const LITTLE_NAMES: [Symbol; 2] = [sym::from_le_bytes, sym::to_le_bytes];
  constant BIG_NAMES (line 74) | const BIG_NAMES: [Symbol; 2] = [sym::from_be_bytes, sym::to_be_bytes];
  type LintKind (line 77) | enum LintKind {
    method allowed (line 90) | fn allowed(&self, cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
    method as_lint (line 94) | fn as_lint(&self) -> &'static Lint {
    method as_name (line 102) | fn as_name(&self, prefix: Prefix) -> Symbol {
  type Prefix (line 84) | enum Prefix {
  method check_expr (line 114) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  function maybe_lint_endian_bytes (line 135) | fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix...

FILE: clippy_lints/src/entry.rs
  method check_expr (line 67) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type MapType (line 218) | enum MapType {
    method name (line 223) | fn name(self) -> &'static str {
    method entry_path (line 229) | fn entry_path(self) -> &'static str {
  type ContainsExpr (line 247) | struct ContainsExpr<'tcx> {
  function try_parse_contains (line 262) | fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) ...
  type InsertExpr (line 307) | struct InsertExpr<'tcx> {
  function try_parse_insert (line 319) | fn try_parse_insert<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ...
  type Edit (line 336) | enum Edit<'tcx> {
  function as_insertion (line 343) | fn as_insertion(self) -> Option<Insertion<'tcx>> {
  type Insertion (line 348) | struct Insertion<'tcx> {
  type InsertSearcher (line 362) | struct InsertSearcher<'cx, 'tcx> {
  function visit_cond_arm (line 397) | fn visit_cond_arm(&mut self, e: &'tcx Expr<'_>) -> bool {
  function visit_non_tail_expr (line 409) | fn visit_non_tail_expr(&mut self, e: &'tcx Expr<'_>) {
  function visit_insert_expr_arguments (line 418) | fn visit_insert_expr_arguments(&mut self, e: &InsertExpr<'tcx>) {
  function visit_stmt (line 430) | fn visit_stmt(&mut self, stmt: &'tcx Stmt<'_>) {
  function visit_block (line 466) | fn visit_block(&mut self, block: &'tcx Block<'_>) {
  function visit_expr (line 495) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
  function visit_pat (line 590) | fn visit_pat(&mut self, p: &'tcx Pat<'tcx>) {
  function is_any_expr_in_map_used (line 600) | fn is_any_expr_in_map_used<'tcx>(
  type InsertSearchResults (line 615) | struct InsertSearchResults<'tcx> {
  function as_single_insertion (line 622) | fn as_single_insertion(&self) -> Option<Insertion<'tcx>> {
  function snippet (line 626) | fn snippet(
  function snippet_occupied (line 657) | fn snippet_occupied(&self, cx: &LateContext<'_>, span: Span, app: &mut A...
  function snippet_vacant (line 671) | fn snippet_vacant(&self, cx: &LateContext<'_>, span: Span, app: &mut App...
  function snippet_closure (line 694) | fn snippet_closure(&self, cx: &LateContext<'_>, mut span: Span, app: &mu...
  function find_insert_calls (line 722) | fn find_insert_calls<'tcx>(
  function is_mutex_guard (line 765) | fn is_mutex_guard(cx: &LateContext<'_>, def_id: DefId) -> bool {

FILE: clippy_lints/src/enum_clike.rs
  method check_item (line 37) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {

FILE: clippy_lints/src/equatable_if_let.rs
  function is_unary_pattern (line 44) | fn is_unary_pattern(pat: &Pat<'_>) -> bool {
  function is_structural_partial_eq (line 64) | fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, ...
  function contains_type_mismatch (line 75) | fn contains_type_mismatch(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
  method check_expr (line 105) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {

FILE: clippy_lints/src/error_impl_error.rs
  method check_item (line 39) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
  function is_visible_outside_module (line 82) | fn is_visible_outside_module(cx: &LateContext<'_>, def_id: LocalDefId) -...

FILE: clippy_lints/src/escape.rs
  type BoxedLocal (line 16) | pub struct BoxedLocal {
    method new (line 21) | pub fn new(conf: &'static Conf) -> Self {
    method check_fn (line 67) | fn check_fn(
  function is_non_trait_box (line 55) | fn is_non_trait_box(ty: Ty<'_>) -> bool {
  type EscapeDelegate (line 59) | struct EscapeDelegate<'a, 'tcx> {
  function is_argument (line 124) | fn is_argument(tcx: TyCtxt<'_>, id: HirId) -> bool {
  function consume (line 137) | fn consume(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
  function use_cloned (line 146) | fn use_cloned(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
  function borrow (line 148) | fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::Borrow...
  function mutate (line 157) | fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
  function fake_read (line 180) | fn fake_read(&mut self, _: &PlaceWithHirId<'tcx>, _: FakeReadCause, _: H...
  function is_large_box (line 184) | fn is_large_box(&self, ty: Ty<'tcx>) -> bool {

FILE: clippy_lints/src/eta_reduction.rs
  method check_expr (line 74) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
  function check_closure (line 90) | fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&E...
  function check_inputs (line 299) | fn check_inputs(
  function check_sig (line 320) | fn check_sig<'tcx>(closure_sig: FnSig<'tcx>, call_sig: FnSig<'tcx>) -> b...
  function has_late_bound_to_non_late_bound_regions (line 328) | fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig:...
  function ty_has_static (line 384) | fn ty_has_static(ty: Ty<'_>) -> bool {

FILE: clippy_lints/src/excessive_bools.rs
  type ExcessiveBools (line 96) | pub struct ExcessiveBools {
    method new (line 102) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 132) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx...
    method check_trait_item (line 153) | fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'t...
    method check_fn (line 163) | fn check_fn(
  function has_n_bools (line 110) | fn has_n_bools<'tcx>(iter: impl Iterator<Item = &'tcx Ty<'tcx>>, mut cou...
  function check_fn_decl (line 118) | fn check_fn_decl(cx: &LateContext<'_>, decl: &FnDecl<'_>, sp: Span, max:...

FILE: clippy_lints/src/excessive_nesting.rs
  type ExcessiveNesting (line 67) | pub struct ExcessiveNesting {
    method new (line 73) | pub fn new(conf: &'static Conf) -> Self {
    method check_node_id (line 80) | pub fn check_node_id(&self, cx: &EarlyContext<'_>, span: Span, node_id...
  method check_crate (line 95) | fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &Crate) {
  method check_block (line 111) | fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
  method check_item (line 115) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
  type NestingVisitor (line 120) | struct NestingVisitor<'conf, 'cx> {
  function check_indent (line 127) | fn check_indent(&mut self, span: Span, id: NodeId) -> bool {
  function visit_block (line 141) | fn visit_block(&mut self, block: &Block) {
  function visit_item (line 162) | fn visit_item(&mut self, item: &Item) {

FILE: clippy_lints/src/exhaustive_items.rs
  method check_item (line 71) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {

FILE: clippy_lints/src/exit.rs
  method check_expr (line 58) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {

FILE: clippy_lints/src/explicit_write.rs
  type ExplicitWrite (line 44) | pub struct ExplicitWrite {
    method new (line 49) | pub fn new(format_args: FormatArgsStorage) -> Self {
    method check_expr (line 55) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function look_in_block (line 118) | fn look_in_block<'tcx, 'hir>(cx: &LateContext<'tcx>, kind: &'tcx ExprKin...

FILE: clippy_lints/src/extra_unused_type_parameters.rs
  type ExtraUnusedTypeParameters (line 45) | pub struct ExtraUnusedTypeParameters {
    method new (line 50) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 259) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx...
    method check_impl_item (line 277) | fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Impl...
  type TypeWalker (line 59) | struct TypeWalker<'cx, 'tcx> {
  function new (line 73) | fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'tcx>) -> Se...
  function get_bound_span (line 92) | fn get_bound_span(&self, param: &'tcx GenericParam<'tcx>) -> Span {
  function emit_help (line 98) | fn emit_help(&self, spans: Vec<Span>, msg: String, help: &'static str) {
  function emit_sugg (line 102) | fn emit_sugg(&self, spans: Vec<Span>, msg: String, help: &'static str) {
  function emit_lint (line 109) | fn emit_lint(&self) {
  function bound_to_trait_def_id (line 196) | fn bound_to_trait_def_id(bound: &GenericBound<'_>) -> Option<LocalDefId> {
  type NestedFilter (line 201) | type NestedFilter = nested_filter::OnlyBodies;
  function visit_ty (line 203) | fn visit_ty(&mut self, t: &'tcx Ty<'tcx, AmbigArg>) {
  function visit_where_predicate (line 211) | fn visit_where_predicate(&mut self, predicate: &'tcx WherePredicate<'tcx...
  function maybe_tcx (line 249) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
  function is_empty_body (line 254) | fn is_empty_body(cx: &LateContext<'_>, body: BodyId) -> bool {

FILE: clippy_lints/src/fallible_impl_from.rs
  method check_item (line 53) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'...
  function lint_impl_body (line 64) | fn lint_impl_body(cx: &LateContext<'_>, item_def_id: hir::OwnerId, impl_...

FILE: clippy_lints/src/field_scoped_visibility_modifiers.rs
  method check_item (line 55) | fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {

FILE: clippy_lints/src/float_literal.rs
  type FloatLiteral (line 66) | pub struct FloatLiteral {
    method new (line 71) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 79) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr...
  function max_digits (line 177) | fn max_digits(fty: FloatTy) -> u32 {
  function count_digits (line 188) | fn count_digits(s: &str) -> usize {
  type FloatFormat (line 199) | enum FloatFormat {
    method new (line 206) | fn new(s: &str) -> Self {
    method format (line 215) | fn format<T>(&self, f: T) -> String
  function maybe_let_stmt (line 227) | fn maybe_let_stmt<'a>(cx: &LateContext<'a>, expr: &hir::Expr<'_>) -> Opt...

FILE: clippy_lints/src/floating_point_arithmetic/custom_abs.rs
  function is_testing_positive (line 18) | fn is_testing_positive(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Exp...
  function is_testing_negative (line 31) | fn is_testing_negative(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Exp...
  function is_zero (line 44) | fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -...
  function are_negated (line 59) | fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a...
  function check (line 73) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/floating_point_arithmetic/expm1.rs
  function check (line 15) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/floating_point_arithmetic/hypot.rs
  function detect (line 13) | pub(super) fn detect(cx: &LateContext<'_>, receiver: &Expr<'_>, app: &mu...
  function check (line 69) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Ex...

FILE: clippy_lints/src/floating_point_arithmetic/lib.rs
  function prepare_receiver_sugg (line 9) | pub(super) fn prepare_receiver_sugg<'a>(

FILE: clippy_lints/src/floating_point_arithmetic/ln1p.rs
  function check (line 13) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Ex...

FILE: clippy_lints/src/floating_point_arithmetic/log_base.rs
  function get_specialized_log_method (line 16) | fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>, ctx...
  function check (line 30) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Ex...

FILE: clippy_lints/src/floating_point_arithmetic/log_division.rs
  function are_same_base_logs (line 11) | fn are_same_base_logs(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &...
  function check (line 24) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/floating_point_arithmetic/mod.rs
  method check_expr (line 109) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/floating_point_arithmetic/mul_add.rs
  function is_float_mul_expr (line 12) | fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Op...
  function check (line 29) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/floating_point_arithmetic/powf.rs
  function get_integer_from_float_constant (line 19) | fn get_integer_from_float_constant(value: &Constant) -> Option<i32> {
  function check (line 39) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Ex...

FILE: clippy_lints/src/floating_point_arithmetic/powi.rs
  function check (line 13) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Ex...

FILE: clippy_lints/src/floating_point_arithmetic/radians.rs
  function check (line 15) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/format.rs
  type UselessFormat (line 44) | pub struct UselessFormat {
    method new (line 49) | pub fn new(format_args: FormatArgsStorage) -> Self {
    method check_expr (line 55) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function span_useless_format_empty (line 107) | fn span_useless_format_empty(cx: &LateContext<'_>, span: Span, sugg: Str...
  function span_useless_format (line 119) | fn span_useless_format(cx: &LateContext<'_>, span: Span, sugg: String, a...

FILE: clippy_lints/src/format_args.rs
  type FormatArgs (line 271) | pub struct FormatArgs<'tcx> {
  function new (line 281) | pub fn new(tcx: TyCtxt<'tcx>, conf: &'static Conf, format_args: FormatAr...
  function check_expr (line 295) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
  type FormatArgsExpr (line 322) | struct FormatArgsExpr<'a, 'tcx> {
  function check_trailing_comma (line 336) | fn check_trailing_comma(&self) {
  function check_templates (line 358) | fn check_templates(&mut self) {
  function check_unused_format_specifier (line 395) | fn check_unused_format_specifier(&self, placeholder: &FormatPlaceholder,...
  function check_uninlined_args (line 445) | fn check_uninlined_args(&self) {
  function check_one_arg (line 499) | fn check_one_arg(&self, pos: &FormatArgPosition, usage: FormatParamUsage...
  function check_format_in_format_args (line 527) | fn check_format_in_format_args(&self, name: Symbol, arg: &Expr<'_>) {
  function check_to_string_in_format_args (line 550) | fn check_to_string_in_format_args(&self, name: Symbol, value: &Expr<'_>) {
  function check_unnecessary_debug_formatting (line 596) | fn check_unnecessary_debug_formatting(&self, name: Symbol, value: &Expr<...
  function format_arg_positions (line 634) | fn format_arg_positions(&self) -> impl Iterator<Item = (&FormatArgPositi...
  function is_aliased (line 654) | fn is_aliased(&self, index: usize) -> bool {
  function can_display_format (line 661) | fn can_display_format(&self, ty: Ty<'tcx>) -> bool {
  function has_pointer_debug (line 684) | fn has_pointer_debug(&mut self, ty: Ty<'tcx>, depth: usize) -> bool {
  function make_ty_msrv_map (line 737) | fn make_ty_msrv_map(tcx: TyCtxt<'_>) -> FxHashMap<Ty<'_>, Option<RustcVe...
  function count_needed_derefs (line 749) | fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize...

FILE: clippy_lints/src/format_impl.rs
  type FormatTraitNames (line 96) | struct FormatTraitNames {
  type FormatImpl (line 103) | pub struct FormatImpl {
    method new (line 110) | pub fn new(format_args: FormatArgsStorage) -> Self {
    method check_impl_item (line 119) | fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &ImplIt...
    method check_impl_item_post (line 123) | fn check_impl_item_post(&mut self, cx: &LateContext<'_>, impl_item: &I...
    method check_expr (line 130) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type FormatImplExpr (line 145) | struct FormatImplExpr<'a, 'tcx> {
  function check_to_string_in_display (line 153) | fn check_to_string_in_display(&self) {
  function check_self_in_format_args (line 181) | fn check_self_in_format_args(&self) {
  function check_format_arg_self (line 212) | fn check_format_arg_self(&self, arg: &Expr<'_>) {
  function check_print_in_format_impl (line 229) | fn check_print_in_format_impl(&self) {
  function is_format_trait_impl (line 258) | fn is_format_trait_impl(cx: &LateContext<'_>, impl_item: &ImplItem<'_>) ...

FILE: clippy_lints/src/format_push_string.rs
  type FormatPushString (line 47) | pub(crate) struct FormatPushString {
    method new (line 72) | pub(crate) fn new(format_args: FormatArgsStorage) -> Self {
    method find_formats (line 76) | fn find_formats<'tcx>(&self, cx: &LateContext<'_>, e: &'tcx Expr<'tcx>...
    method check_expr (line 123) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type FormatSearchResults (line 51) | enum FormatSearchResults {
  function is_string (line 192) | fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {

FILE: clippy_lints/src/formatting.rs
  method check_block (line 149) | fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
  method check_expr (line 157) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  function check_assign (line 166) | fn check_assign(cx: &EarlyContext<'_>, expr: &Expr) {
  function check_unop (line 195) | fn check_unop(cx: &EarlyContext<'_>, expr: &Expr) {
  function check_else (line 227) | fn check_else(cx: &EarlyContext<'_>, expr: &Expr) {
  function has_unary_equivalent (line 279) | fn has_unary_equivalent(bin_op: BinOpKind) -> bool {
  function indentation (line 284) | fn indentation(cx: &EarlyContext<'_>, span: Span) -> usize {
  function check_array (line 289) | fn check_array(cx: &EarlyContext<'_>, expr: &Expr) {
  function check_missing_else (line 314) | fn check_missing_else(cx: &EarlyContext<'_>, first: &Expr, second: &Expr) {
  function is_block (line 345) | fn is_block(expr: &Expr) -> bool {
  function is_if (line 350) | fn is_if(expr: &Expr) -> bool {

FILE: clippy_lints/src/four_forward_slashes.rs
  method check_item (line 42) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
  function contains_bare_cr (line 113) | fn contains_bare_cr(text: &str) -> bool {

FILE: clippy_lints/src/from_over_into.rs
  type FromOverInto (line 57) | pub struct FromOverInto {
    method new (line 62) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 68) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
  type SelfFinder (line 125) | struct SelfFinder<'a, 'tcx> {
  type Result (line 134) | type Result = ControlFlow<()>;
  type NestedFilter (line 135) | type NestedFilter = OnlyBodies;
  function maybe_tcx (line 137) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
  function visit_path (line 141) | fn visit_path(&mut self, path: &Path<'tcx>, _id: HirId) -> Self::Result {
  function visit_name (line 157) | fn visit_name(&mut self, name: Symbol) -> Self::Result {
  function convert_to_from (line 166) | fn convert_to_from(

FILE: clippy_lints/src/from_raw_with_void_ptr.rs
  method check_expr (line 42) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  function def_id_matches_type (line 66) | fn def_id_matches_type(cx: &LateContext<'_>, def_id: DefId) -> Option<&'...

FILE: clippy_lints/src/from_str_radix_10.rs
  method check_expr (line 46) | fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
  function is_ty_stringish (line 91) | fn is_ty_stringish(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {

FILE: clippy_lints/src/functions/duplicate_underscore_argument.rs
  function check (line 10) | pub(super) fn check(cx: &EarlyContext<'_>, fn_kind: FnKind<'_>) {

FILE: clippy_lints/src/functions/impl_trait_in_params.rs
  function report (line 12) | fn report(cx: &LateContext<'_>, param: &GenericParam<'_>, generics: &Gen...
  function check_fn (line 40) | pub(super) fn check_fn<'tcx>(cx: &LateContext<'_>, kind: &'tcx FnKind<'_...
  function check_impl_item (line 53) | pub(super) fn check_impl_item(cx: &LateContext<'_>, impl_item: &ImplItem...
  function check_trait_item (line 70) | pub(super) fn check_trait_item(cx: &LateContext<'_>, trait_item: &TraitI...

FILE: clippy_lints/src/functions/misnamed_getters.rs
  function check_fn (line 14) | pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_...

FILE: clippy_lints/src/functions/mod.rs
  method check_fn (line 494) | fn check_fn(&mut self, cx: &EarlyContext<'_>, fn_kind: visit::FnKind<'_>...
  type Functions (line 499) | pub struct Functions {
    method new (line 512) | pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
    method check_fn (line 534) | fn check_fn(
    method check_item (line 561) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item...
    method check_impl_item (line 572) | fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir:...
    method check_trait_item (line 585) | fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir...
    method check_expr (line 600) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr...

FILE: clippy_lints/src/functions/must_use.rs
  function check_item (line 25) | pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::...
  function check_impl_item (line 63) | pub(super) fn check_impl_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx ...
  function check_trait_item (line 95) | pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx...
  function check_needless_must_use (line 133) | fn check_needless_must_use(
  function check_must_use_candidate (line 195) | fn check_must_use_candidate<'tcx>(
  function returns_unit (line 233) | fn returns_unit(decl: &hir::FnDecl<'_>) -> bool {
  function has_mutable_arg (line 244) | fn has_mutable_arg(cx: &LateContext<'_>, body: &hir::Body<'_>) -> bool {
  function is_mutable_pat (line 249) | fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut De...
  function is_mutable_ty (line 260) | fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, tys: &mut D...
  function is_mutated_static (line 278) | fn is_mutated_static(e: &hir::Expr<'_>) -> bool {
  function mutates_static (line 289) | fn mutates_static<'tcx>(cx: &LateContext<'tcx>, body: &'tcx hir::Body<'_...

FILE: clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs
  function check_fn (line 16) | pub(super) fn check_fn<'tcx>(
  function check_trait_item (line 32) | pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx...
  function check_raw_ptr (line 39) | fn check_raw_ptr<'tcx>(
  function raw_ptr_arg (line 78) | fn raw_ptr_arg(cx: &LateContext<'_>, arg: &hir::Param<'_>) -> Option<Hir...
  function check_arg (line 90) | fn check_arg(cx: &LateContext<'_>, raw_ptrs: &HirIdSet, arg: &hir::Expr<...

FILE: clippy_lints/src/functions/ref_option.rs
  function check_ty (line 14) | fn check_ty<'a>(cx: &LateContext<'a>, param: &hir::Ty<'a>, param_ty: Ty<...
  function check_fn_sig (line 42) | fn check_fn_sig<'a>(cx: &LateContext<'a>, decl: &FnDecl<'a>, span: Span,...
  function check_fn (line 66) | pub(crate) fn check_fn<'a>(
  function check_trait_item (line 120) | pub(super) fn check_trait_item<'a>(

FILE: clippy_lints/src/functions/renamed_function_params.rs
  function check_impl_item (line 12) | pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &ImplItem<'_>,...
  type RenamedFnArgs (line 48) | struct RenamedFnArgs(Vec<(Span, String)>);
    method new (line 53) | fn new<I1, I2>(default_idents: &mut I1, current_idents: &mut I2) -> Self
    method multi_span (line 79) | fn multi_span(&self) -> MultiSpan {
  function is_from_ignored_trait (line 89) | fn is_from_ignored_trait(of_trait: &TraitRef<'_>, ignored_traits: &DefId...

FILE: clippy_lints/src/functions/result.rs
  function result_err_ty (line 18) | fn result_err_ty<'tcx>(
  function check_item (line 39) | pub(super) fn check_item<'tcx>(
  function check_impl_item (line 57) | pub(super) fn check_impl_item<'tcx>(
  function check_trait_item (line 77) | pub(super) fn check_trait_item<'tcx>(
  function check_result_unit_err (line 95) | fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header...
  function check_result_large_err (line 108) | fn check_result_large_err<'tcx>(
  function check_expr (line 177) | pub(super) fn check_expr<'tcx>(

FILE: clippy_lints/src/functions/too_many_arguments.rs
  function check_fn (line 13) | pub(super) fn check_fn(
  function check_trait_item (line 30) | pub(super) fn check_trait_item(cx: &LateContext<'_>, item: &hir::TraitIt...
  function check_arg_number (line 44) | fn check_arg_number(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, fn_spa...

FILE: clippy_lints/src/functions/too_many_lines.rs
  function check_fn (line 11) | pub(super) fn check_fn(

FILE: clippy_lints/src/future_not_send.rs
  method check_fn (line 65) | fn check_fn(
  type TyParamAtTopLevelVisitor (line 145) | struct TyParamAtTopLevelVisitor;
    type Result (line 147) | type Result = ControlFlow<bool>;
    method visit_ty (line 148) | fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {

FILE: clippy_lints/src/if_let_mutex.rs
  method check_expr (line 53) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
  function mutex_lock_call (line 90) | fn mutex_lock_call<'tcx>(

FILE: clippy_lints/src/if_not_else.rs
  method check_expr (line 52) | fn check_expr(&mut self, cx: &LateContext<'_>, e: &Expr<'_>) {
  function make_sugg (line 107) | fn make_sugg<'a>(

FILE: clippy_lints/src/if_then_some_else_none.rs
  type IfThenSomeElseNone (line 55) | pub struct IfThenSomeElseNone {
    method new (line 60) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 66) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...

FILE: clippy_lints/src/ifs/branches_sharing_code.rs
  function check (line 20) | pub(super) fn check<'tcx>(
  type BlockEq (line 103) | struct BlockEq {
    method start_span (line 113) | fn start_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
    method end_span (line 121) | fn end_span(&self, b: &Block<'_>, sm: &SourceMap) -> Option<Span> {
  function eq_binding_names (line 133) | fn eq_binding_names(cx: &LateContext<'_>, s: &Stmt<'_>, names: &[(HirId,...
  function modifies_any_local (line 164) | fn modifies_any_local<'tcx>(cx: &LateContext<'tcx>, s: &'tcx Stmt<'_>, l...
  function eq_stmts (line 180) | fn eq_stmts(
  function scan_block_for_eq (line 203) | fn scan_block_for_eq<'tcx>(
  function adjust_by_closest_callsite (line 380) | fn adjust_by_closest_callsite<'tcx>(
  function check_for_warn_of_moved_symbol (line 398) | fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &[(HirI...
  function is_expr_parent_assignment (line 426) | fn is_expr_parent_assignment(cx: &LateContext<'_>, expr: &Expr<'_>) -> b...

FILE: clippy_lints/src/ifs/if_same_then_else.rs
  function check (line 9) | pub(super) fn check(cx: &LateContext<'_>, conds: &[&Expr<'_>], blocks: &...

FILE: clippy_lints/src/ifs/ifs_same_cond.rs
  function method_caller_is_mutable (line 10) | fn method_caller_is_mutable<'tcx>(
  function check (line 26) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, conds: &[&Expr<'_>], i...

FILE: clippy_lints/src/ifs/mod.rs
  type CopyAndPaste (line 157) | pub struct CopyAndPaste<'tcx> {
  function new (line 162) | pub fn new(tcx: TyCtxt<'tcx>, conf: &'static Conf) -> Self {
  function check_expr (line 170) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/ifs/same_functions_in_if_cond.rs
  function check (line 9) | pub(super) fn check(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {

FILE: clippy_lints/src/ignored_unit_patterns.rs
  method check_pat (line 40) | fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx hir::Pat<'tcx...

FILE: clippy_lints/src/impl_hash_with_borrow_str_and_bytes.rs
  method check_item (line 79) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {

FILE: clippy_lints/src/implicit_hasher.rs
  method check_item (line 62) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
  type ImplicitHasherType (line 204) | enum ImplicitHasherType<'tcx> {
  function new (line 211) | fn new(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Option<Self> {
  function type_name (line 246) | fn type_name(&self) -> &'static str {
  function type_arguments (line 253) | fn type_arguments(&self) -> String {
  function ty (line 260) | fn ty(&self) -> Ty<'tcx> {
  function span (line 266) | fn span(&self) -> Span {
  type ImplicitHasherTypeVisitor (line 273) | struct ImplicitHasherTypeVisitor<'a, 'tcx> {
  function new (line 279) | fn new(cx: &'a LateContext<'tcx>) -> Self {
  function visit_ty (line 285) | fn visit_ty(&mut self, t: &'tcx hir::Ty<'_, AmbigArg>) {
  type ImplicitHasherConstructorVisitor (line 295) | struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> {
  function new (line 303) | fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) ...
  type NestedFilter (line 314) | type NestedFilter = nested_filter::OnlyBodies;
  function visit_body (line 316) | fn visit_body(&mut self, body: &Body<'tcx>) {
  function visit_expr (line 322) | fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
  function maybe_tcx (line 365) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {

FILE: clippy_lints/src/implicit_return.rs
  function lint_return (line 46) | fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
  function lint_break (line 61) | fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: S...
  type LintLocation (line 82) | enum LintLocation {
    method still_parent (line 89) | fn still_parent(self, b: bool) -> Self {
    method is_parent (line 93) | fn is_parent(self) -> bool {
  function get_call_site (line 99) | fn get_call_site(span: Span, ctxt: SyntaxContext) -> Option<Span> {
  function lint_implicit_returns (line 103) | fn lint_implicit_returns(
  method check_fn (line 222) | fn check_fn(

FILE: clippy_lints/src/implicit_saturating_add.rs
  method check_expr (line 43) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
  function get_int_max (line 99) | fn get_int_max(ty: Ty<'_>) -> Option<u128> {
  function get_const (line 118) | fn get_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<...
  function invert_op (line 132) | fn invert_op(op: BinOpKind) -> Option<BinOpKind> {

FILE: clippy_lints/src/implicit_saturating_sub.rs
  type ImplicitSaturatingSub (line 87) | pub struct ImplicitSaturatingSub {
    method new (line 92) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 98) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...
  function check_manual_check (line 123) | fn check_manual_check<'tcx>(
  function check_gt (line 176) | fn check_gt(
  function is_side_effect_free (line 202) | fn is_side_effect_free(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function check_subtraction (line 207) | fn check_subtraction(
  function check_with_condition (line 306) | fn check_with_condition<'tcx>(
  function subtracts_one (line 381) | fn subtracts_one<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option...
  function print_lint_and_sugg (line 402) | fn print_lint_and_sugg(cx: &LateContext<'_>, var_name: Symbol, expr: &Ex...

FILE: clippy_lints/src/implied_bounds_in_impls.rs
  function emit_lint (line 53) | fn emit_lint(
  function try_resolve_type (line 143) | fn try_resolve_type<'tcx>(
  function is_same_generics (line 179) | fn is_same_generics<'tcx>(
  type ImplTraitBound (line 216) | struct ImplTraitBound<'tcx> {
  function collect_supertrait_bounds (line 235) | fn collect_supertrait_bounds<'tcx>(cx: &LateContext<'tcx>, bounds: Gener...
  function find_bound_in_supertraits (line 264) | fn find_bound_in_supertraits<'a, 'tcx>(
  function check (line 290) | fn check<'tcx>(cx: &LateContext<'tcx>, bounds: GenericBounds<'tcx>) {
  method check_generics (line 328) | fn check_generics(&mut self, cx: &LateContext<'tcx>, generics: &rustc_hi...
  method check_ty (line 341) | fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &rustc_hir::Ty<'tcx, ...

FILE: clippy_lints/src/incompatible_msrv.rs
  type Availability (line 77) | enum Availability {
  type StdCrates (line 83) | struct StdCrates([Option<CrateNum>; 6]);
    method new (line 85) | fn new(tcx: TyCtxt<'_>) -> Self {
    method contains (line 102) | fn contains(&self, krate: CrateNum) -> bool {
  type IncompatibleMsrv (line 107) | pub struct IncompatibleMsrv {
    method new (line 119) | pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
    method get_def_id_availability (line 132) | fn get_def_id_availability(&mut self, tcx: TyCtxt<'_>, def_id: DefId, ...
    method emit_lint_if_under_msrv (line 168) | fn emit_lint_if_under_msrv(
    method check_expr (line 220) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...
    method check_ty (line 256) | fn check_ty(&mut self, cx: &LateContext<'tcx>, hir_ty: &'tcx hir::Ty<'...
  function is_under_cfg_attribute (line 269) | fn is_under_cfg_attribute(cx: &LateContext<'_>, hir_id: HirId) -> bool {

FILE: clippy_lints/src/inconsistent_struct_constructor.rs
  type InconsistentStructConstructor (line 71) | pub struct InconsistentStructConstructor {
    method new (line 76) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 84) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr...
  function is_consistent_order (line 139) | fn is_consistent_order<'tcx>(fields: &'tcx [hir::ExprField<'tcx>], def_o...
  function suggestion (line 152) | fn suggestion<'tcx>(
  function field_with_attrs_span (line 186) | fn field_with_attrs_span(tcx: TyCtxt<'_>, field: &hir::ExprField<'_>) ->...

FILE: clippy_lints/src/index_refutable_slice.rs
  type IndexRefutableSlice (line 58) | pub struct IndexRefutableSlice {
    method new (line 64) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 73) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr...
  function find_slice_values (line 90) | fn find_slice_values(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> FxInde...
  function lint_slice (line 129) | fn lint_slice(cx: &LateContext<'_>, slice: &SliceLintInformation) {
  type SliceLintInformation (line 180) | struct SliceLintInformation {
    method new (line 188) | fn new(ident: Ident, needs_ref: bool) -> Self {
  function filter_lintable_slices (line 198) | fn filter_lintable_slices<'tcx>(
  type SliceIndexLintingVisitor (line 215) | struct SliceIndexLintingVisitor<'a, 'tcx> {
  type NestedFilter (line 222) | type NestedFilter = nested_filter::OnlyBodies;
  function maybe_tcx (line 224) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
  function visit_expr (line 228) | fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {

FILE: clippy_lints/src/indexing_slicing.rs
  type IndexingSlicing (line 97) | pub struct IndexingSlicing {
    method new (line 103) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 112) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function to_const_range (line 236) | fn to_const_range(cx: &LateContext<'_>, range: higher::Range<'_>, array_...
  function ty_has_applicable_get_function (line 263) | fn ty_has_applicable_get_function<'tcx>(

FILE: clippy_lints/src/ineffective_open_options.rs
  method check_expr (line 46) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/infallible_try_from.rs
  method check_item (line 47) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {

FILE: clippy_lints/src/infinite_iter.rs
  method check_expr (line 56) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type Finiteness (line 69) | enum Finiteness {
    method and (line 79) | fn and(self, b: Self) -> Self {
    method or (line 88) | fn or(self, b: Self) -> Self {
    method from (line 98) | fn from(b: bool) -> Self {
  type Heuristic (line 106) | enum Heuristic {
  constant HEURISTICS (line 124) | const HEURISTICS: [(Symbol, usize, Heuristic, Finiteness); 19] = [
  function is_infinite (line 146) | fn is_infinite(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
  constant POSSIBLY_COMPLETING_METHODS (line 188) | const POSSIBLY_COMPLETING_METHODS: [(Symbol, usize); 6] = [
  constant COMPLETING_METHODS (line 199) | const COMPLETING_METHODS: [(Symbol, usize); 12] = [
  function complete_infinite_iter (line 214) | fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Fini...

FILE: clippy_lints/src/inherent_impl.rs
  type MultipleInherentImpl (line 52) | pub struct MultipleInherentImpl {
    method new (line 57) | pub fn new(conf: &'static Conf) -> Self {
    method check_crate_post (line 72) | fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
  type Criterion (line 65) | enum Criterion {
  function get_impl_span (line 166) | fn get_impl_span(cx: &LateContext<'_>, id: LocalDefId) -> Option<Span> {
  type IdOrSpan (line 180) | enum IdOrSpan {

FILE: clippy_lints/src/inherent_to_string.rs
  method check_impl_item (line 97) | fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx I...
  function show_lint (line 120) | fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) {

FILE: clippy_lints/src/init_numbered_fields.rs
  method check_expr (line 45) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {

FILE: clippy_lints/src/inline_fn_without_body.rs
  method check_trait_item (line 32) | fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Trait...

FILE: clippy_lints/src/int_plus_one.rs
  type LeOrGe (line 47) | enum LeOrGe {
    type Error (line 53) | type Error = ();
    method try_from (line 54) | fn try_from(value: BinOpKind) -> Result<Self, Self::Error> {
  method is_one (line 64) | fn is_one(expr: &Expr) -> bool {
  method is_neg_one (line 73) | fn is_neg_one(expr: &Expr) -> bool {
  method as_x_plus_one (line 82) | fn as_x_plus_one(expr: &Expr) -> Option<&Expr> {
  method as_x_minus_one (line 98) | fn as_x_minus_one(expr: &Expr) -> Option<&Expr> {
  method check_binop (line 111) | fn check_binop<'tcx>(le_or_ge: LeOrGe, lhs: &'tcx Expr, rhs: &'tcx Expr)...
  method emit_warning (line 128) | fn emit_warning(cx: &EarlyContext<'_>, expr: &Expr, new_lhs: &Expr, le_o...
  method check_expr (line 151) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {

FILE: clippy_lints/src/item_name_repetitions.rs
  type ItemNameRepetitions (line 166) | pub struct ItemNameRepetitions {
    method new (line 189) | pub fn new(conf: &'static Conf) -> Self {
    method is_allowed_prefix (line 201) | fn is_allowed_prefix(&self, prefix: &str) -> bool {
    method check_variants (line 213) | fn check_variants(&self, cx: &LateContext<'_>, item: &Item<'_>, def: &...
    method check_fields (line 235) | fn check_fields(&self, cx: &LateContext<'_>, item: &Item<'_>, fields: ...
    method check_enum_common_affix (line 244) | fn check_enum_common_affix(cx: &LateContext<'_>, item: &Item<'_>, def:...
    method check_struct_common_affix (line 294) | fn check_struct_common_affix(&self, cx: &LateContext<'_>, item: &Item<...
    method check_struct_name_repetition (line 367) | fn check_struct_name_repetition(&self, cx: &LateContext<'_>, item: &It...
    method check_item_post (line 472) | fn check_item_post(&mut self, _: &LateContext<'_>, item: &Item<'_>) {
    method check_body (line 479) | fn check_body(&mut self, _: &LateContext<'_>, _: &Body<'_>) {
    method check_body_post (line 485) | fn check_body_post(&mut self, _: &LateContext<'_>, _: &Body<'_>) {
    method check_item (line 491) | fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) {
  type ModInfo (line 177) | struct ModInfo {
  function have_no_extra_prefix (line 207) | fn have_no_extra_prefix(prefixes: &[&str]) -> bool {
  function check_enum_start (line 414) | fn check_enum_start(cx: &LateContext<'_>, item_name: &str, variant: &Var...
  function check_enum_end (line 433) | fn check_enum_end(cx: &LateContext<'_>, item_name: &str, variant: &Varia...
  function check_enum_tuple_path_match (line 452) | fn check_enum_tuple_path_match(variant_name: &str, variant_data: Variant...

FILE: clippy_lints/src/items_after_statements.rs
  method check_block (line 53) | fn check_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>) {

FILE: clippy_lints/src/items_after_test_module.rs
  function cfg_test_module (line 46) | fn cfg_test_module<'tcx>(cx: &LateContext<'tcx>, item: &Item<'tcx>) -> b...
  method check_mod (line 60) | fn check_mod(&mut self, cx: &LateContext<'_>, module: &Mod<'_>, _: HirId) {

FILE: clippy_lints/src/iter_not_returning_iterator.rs
  method check_trait_item (line 45) | fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Trait...
  method check_impl_item (line 53) | fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplIt...
  function check_sig (line 66) | fn check_sig(cx: &LateContext<'_>, name: Symbol, sig: &FnSig<'_>, fn_id:...

FILE: clippy_lints/src/iter_over_hash_type.rs
  method check_expr (line 41) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ rustc_hir::Expr...

FILE: clippy_lints/src/iter_without_into_iter.rs
  function is_nameable_in_impl_trait (line 117) | fn is_nameable_in_impl_trait(ty: &rustc_hir::Ty<'_>) -> bool {
  function is_ty_exported (line 121) | fn is_ty_exported(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
  method check_item (line 128) | fn check_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::Item<'_...
  method check_impl_item (line 195) | fn check_impl_item(&mut self, cx: &LateContext<'_>, item: &rustc_hir::Im...

FILE: clippy_lints/src/large_const_arrays.rs
  type LargeConstArrays (line 37) | pub struct LargeConstArrays {
    method new (line 42) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 50) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {

FILE: clippy_lints/src/large_enum_variant.rs
  type LargeEnumVariant (line 63) | pub struct LargeEnumVariant {
    method new (line 68) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 76) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &Item<'tcx>) {
  function maybe_copy (line 161) | fn maybe_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {

FILE: clippy_lints/src/large_futures.rs
  type LargeFuture (line 45) | pub struct LargeFuture {
    method new (line 50) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 58) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...

FILE: clippy_lints/src/large_include_file.rs
  type LargeIncludeFile (line 43) | pub struct LargeIncludeFile {
    method new (line 48) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 56) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
  method check_attribute (line 88) | fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {

FILE: clippy_lints/src/large_stack_arrays.rs
  type LargeStackArrays (line 34) | pub struct LargeStackArrays {
    method new (line 41) | pub fn new(conf: &'static Conf) -> Self {
    method is_from_vec_macro (line 50) | fn is_from_vec_macro(&mut self, cx: &LateContext<'_>, span: Span) -> b...
    method check_item (line 67) | fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
    method check_item_post (line 73) | fn check_item_post(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<...
    method check_expr (line 79) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
  function might_be_expanded (line 128) | fn might_be_expanded<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ->...

FILE: clippy_lints/src/large_stack_frames.rs
  type LargeStackFrames (line 87) | pub struct LargeStackFrames {
    method new (line 93) | pub fn new(conf: &'static Conf) -> Self {
    method check_fn (line 140) | fn check_fn(
  type Space (line 102) | enum Space {
    method exceeds_limit (line 108) | pub fn exceeds_limit(self, limit: u64) -> bool {
    method fmt (line 117) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 127) | type Output = Self;
    method add (line 128) | fn add(self, rhs: u64) -> Self {

FILE: clippy_lints/src/legacy_numeric_constants.rs
  type LegacyNumericConstants (line 40) | pub struct LegacyNumericConstants {
    method new (line 45) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 51) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx...
    method check_expr (line 106) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir...
  function is_integer_module (line 149) | fn is_integer_module(cx: &LateContext<'_>, did: DefId) -> bool {
  function is_numeric_const (line 169) | fn is_numeric_const(cx: &LateContext<'_>, did: DefId) -> bool {
  function is_numeric_const_path_canonical (line 230) | fn is_numeric_const_path_canonical(expr_path: &hir::Path<'_>, [mod_name,...
  function is_integer_method (line 246) | fn is_integer_method(cx: &LateContext<'_>, did: DefId) -> bool {

FILE: clippy_lints/src/len_without_is_empty.rs
  method check_item (line 46) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
  method check_impl_item (line 54) | fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplIt...
  function check_trait_items (line 94) | fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, ide...
  function extract_future_output (line 139) | fn extract_future_output<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> ...
  function is_first_generic_integral (line 157) | fn is_first_generic_integral<'tcx>(segment: &'tcx PathSegment<'tcx>) -> ...
  type LenOutput (line 171) | enum LenOutput {
    method new (line 178) | fn new<'tcx>(cx: &LateContext<'tcx>, sig: FnSig<'tcx>) -> Option<Self> {
    method matches_is_empty_output (line 211) | fn matches_is_empty_output<'tcx>(self, cx: &LateContext<'tcx>, is_empt...
  function expected_is_empty_sig (line 231) | fn expected_is_empty_sig(len_output: LenOutput, len_self_kind: ImplicitS...
  function check_is_empty_sig (line 249) | fn check_is_empty_sig<'tcx>(
  function check_for_is_empty (line 275) | fn check_for_is_empty(

FILE: clippy_lints/src/len_zero.rs
  type LenZero (line 94) | pub struct LenZero {
    method new (line 99) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 105) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
    method check_cmp (line 184) | fn check_cmp(
    method check_len (line 210) | fn check_len(
    method check_empty_expr (line 244) | fn check_empty_expr(&self, cx: &LateContext<'_>, span: Span, lit1: &Ex...
  function span_without_enclosing_paren (line 264) | fn span_without_enclosing_paren(cx: &LateContext<'_>, span: Span) -> Span {
  function is_empty_string (line 278) | fn is_empty_string(expr: &Expr<'_>) -> bool {
  function is_empty_array (line 288) | fn is_empty_array(expr: &Expr<'_>) -> bool {
  function has_is_empty (line 296) | fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Msrv) -> bo...

FILE: clippy_lints/src/let_if_seq.rs
  method check_block (line 60) | fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Bloc...
  function check_block_inner (line 75) | fn check_block_inner<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt...
  function check_assign (line 147) | fn check_assign<'tcx>(

FILE: clippy_lints/src/let_underscore.rs
  method check_local (line 138) | fn check_local(&mut self, cx: &LateContext<'tcx>, local: &LetStmt<'tcx>) {

FILE: clippy_lints/src/let_with_type_underscore.rs
  method check_local (line 31) | fn check_local(&mut self, cx: &EarlyContext<'_>, local: &Local) {

FILE: clippy_lints/src/lib.rs
  function explain (line 416) | pub fn explain(name: &str) -> i32 {
  function register_lint_passes (line 442) | pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'s...

FILE: clippy_lints/src/lifetimes.rs
  type Lifetimes (line 133) | pub struct Lifetimes {
    method new (line 138) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 144) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
    method check_impl_item (line 163) | fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Impl...
    method check_trait_item (line 180) | fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Tra...
  function check_fn_inner (line 202) | fn check_fn_inner<'tcx>(
  function could_use_elision (line 287) | fn could_use_elision<'tcx>(
  function allowed_lts_from (line 397) | fn allowed_lts_from(named_generics: &[GenericParam<'_>]) -> FxIndexSet<L...
  function non_elidable_self_type (line 411) | fn non_elidable_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'t...
  function named_lifetime_occurrences (line 430) | fn named_lifetime_occurrences(lts: &[Lifetime]) -> Vec<(LocalDefId, usiz...
  function named_lifetime (line 447) | fn named_lifetime(lt: &Lifetime) -> Option<LocalDefId> {
  type RefVisitor (line 454) | struct RefVisitor<'a, 'tcx> {
  function new (line 462) | fn new(cx: &'a LateContext<'tcx>) -> Self {
  function all_lts (line 471) | fn all_lts(&self) -> Vec<Lifetime> {
  function abort (line 479) | fn abort(&self) -> bool {
  function visit_lifetime (line 486) | fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
  function visit_poly_trait_ref (line 490) | fn visit_poly_trait_ref(&mut self, poly_tref: &'tcx PolyTraitRef<'tcx>) {
  function visit_ty (line 505) | fn visit_ty(&mut self, ty: &'tcx Ty<'_, AmbigArg>) {
  function has_where_lifetimes (line 527) | fn has_where_lifetimes<'tcx>(cx: &LateContext<'tcx>, generics: &'tcx Gen...
  type Usage (line 568) | struct Usage {
  type LifetimeChecker (line 576) | struct LifetimeChecker<'cx, 'tcx, F> {
  function new (line 590) | fn new(cx: &'cx LateContext<'tcx>, generics: &'tcx Generics<'_>) -> Life...
  function visit_where_bound_predicate (line 614) | fn visit_where_bound_predicate(
  type MaybeTyCtxt (line 636) | type MaybeTyCtxt = TyCtxt<'tcx>;
  type NestedFilter (line 637) | type NestedFilter = F;
  function visit_lifetime (line 640) | fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
  function visit_where_predicate (line 654) | fn visit_where_predicate(&mut self, predicate: &'tcx WherePredicate<'tcx...
  function visit_generic_args (line 670) | fn visit_generic_args(&mut self, generic_args: &'tcx GenericArgs<'tcx>) ...
  function visit_fn_decl (line 676) | fn visit_fn_decl(&mut self, fd: &'tcx FnDecl<'tcx>) -> Self::Result {
  function maybe_tcx (line 682) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
  function is_candidate_for_elision (line 689) | fn is_candidate_for_elision(fd: &FnDecl<'_>) -> bool {
  function report_extra_lifetimes (line 714) | fn report_extra_lifetimes<'tcx>(cx: &LateContext<'tcx>, func: &'tcx FnDe...
  function report_extra_impl_lifetimes (line 735) | fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tc...
  function report_elidable_impl_lifetimes (line 767) | fn report_elidable_impl_lifetimes<'tcx>(
  type ElidableUsage (line 799) | enum ElidableUsage {
  function report_elidable_lifetimes (line 808) | fn report_elidable_lifetimes(
  function elision_suggestions (line 871) | fn elision_suggestions(
  type BodyLifetimeChecker (line 947) | struct BodyLifetimeChecker<'tcx> {
  function new (line 952) | fn new(cx: &LateContext<'tcx>) -> Self {
  type Result (line 958) | type Result = ControlFlow<()>;
  type NestedFilter (line 959) | type NestedFilter = middle_nested_filter::OnlyBodies;
  function maybe_tcx (line 961) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
  function visit_lifetime (line 965) | fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) -> ControlFlow<()> {

FILE: clippy_lints/src/literal_representation.rs
  type WarningType (line 158) | enum WarningType {
    method lint_and_text (line 168) | fn lint_and_text(&self) -> (&'static Lint, &'static str, &'static str) {
    method display (line 195) | fn display(&self, num_lit: &NumericLiteral<'_>, cx: &EarlyContext<'_>,...
  type LiteralDigitGrouping (line 204) | pub struct LiteralDigitGrouping {
    method new (line 222) | pub fn new(conf: &'static Conf) -> Self {
    method check_lit (line 228) | fn check_lit(&self, cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
    method check_for_mistyped_suffix (line 277) | fn check_for_mistyped_suffix(cx: &EarlyContext<'_>, span: Span, num_li...
    method is_literal_uuid_formatted (line 341) | fn is_literal_uuid_formatted(num_lit: &NumericLiteral<'_>) -> bool {
    method parts_consistent (line 363) | fn parts_consistent(
    method get_group_size (line 383) | fn get_group_size<'a>(
  method check_expr (line 209) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
  constant UUID_GROUP_LENS (line 219) | const UUID_GROUP_LENS: [usize; 5] = [8, 4, 4, 4, 12];
  type DecimalLiteralRepresentation (line 415) | pub struct DecimalLiteralRepresentation {
    method new (line 430) | pub fn new(conf: &'static Conf) -> Self {
    method check_lit (line 435) | fn check_lit(&self, cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
    method do_lint (line 452) | fn do_lint(digits: &str) -> Result<(), WarningType> {
  method check_expr (line 420) | fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {

FILE: clippy_lints/src/literal_string_with_formatting_args.rs
  function emit_lint (line 43) | fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, spans: &[(Span, Opti...
  method check_expr (line 85) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {

FILE: clippy_lints/src/loops/char_indices_as_byte_indices.rs
  constant BYTE_INDEX_METHODS (line 19) | const BYTE_INDEX_METHODS: &[Symbol] = &[
  constant CONTINUE (line 37) | const CONTINUE: ControlFlow<!, ()> = ControlFlow::Continue(());
  function check (line 39) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>, iterabl...
  function check_index_usage (line 72) | fn check_index_usage<'tcx>(
  function index_consumed_at (line 131) | fn index_consumed_at<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...

FILE: clippy_lints/src/loops/empty_loop.rs
  function check (line 8) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, loop_block: &...

FILE: clippy_lints/src/loops/explicit_counter_loop.rs
  function check (line 17) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/loops/explicit_into_iter_loop.rs
  type AdjustKind (line 12) | enum AdjustKind {
    method borrow (line 20) | fn borrow(mutbl: AutoBorrowMutability) -> Self {
    method reborrow (line 27) | fn reborrow(mutbl: AutoBorrowMutability) -> Self {
    method display (line 34) | fn display(self) -> &'static str {
  function check (line 45) | pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr...

FILE: clippy_lints/src/loops/explicit_iter_loop.rs
  function check (line 17) | pub(super) fn check(
  type AdjustKind (line 54) | enum AdjustKind {
    method borrow (line 63) | fn borrow(mutbl: Mutability) -> Self {
    method auto_borrow (line 70) | fn auto_borrow(mutbl: AutoBorrowMutability) -> Self {
    method reborrow (line 77) | fn reborrow(mutbl: Mutability) -> Self {
    method auto_reborrow (line 84) | fn auto_reborrow(mutbl: AutoBorrowMutability) -> Self {
    method display (line 91) | fn display(self) -> &'static str {
  function is_ref_iterable (line 106) | fn is_ref_iterable<'tcx>(

FILE: clippy_lints/src/loops/for_kv_map.rs
  function check (line 13) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/loops/infinite_loop.rs
  function check (line 15) | pub(super) fn check<'tcx>(
  function is_inside_unawaited_async_block (line 75) | fn is_inside_unawaited_async_block(cx: &LateContext<'_>, expr: &Expr<'_>...
  function is_async_block_awaited (line 97) | fn is_async_block_awaited(cx: &LateContext<'_>, async_expr: &Expr<'_>) -...
  function get_parent_fn_ret_ty (line 110) | fn get_parent_fn_ret_ty<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -...
  type LoopVisitor (line 149) | struct LoopVisitor<'hir, 'tcx> {
  function visit_expr (line 158) | fn visit_expr(&mut self, ex: &'hir Expr<'_>) {
  function is_never_return (line 206) | fn is_never_return(ret_ty: FnRetTy<'_>) -> bool {

FILE: clippy_lints/src/loops/iter_next_loop.rs
  function check (line 8) | pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>) {

FILE: clippy_lints/src/loops/manual_find.rs
  function check (line 15) | pub(super) fn check<'tcx>(
  function get_binding (line 109) | fn get_binding(pat: &Pat<'_>) -> Option<HirId> {
  function last_stmt_and_ret (line 126) | fn last_stmt_and_ret<'tcx>(

FILE: clippy_lints/src/loops/manual_flatten.rs
  function check (line 18) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/loops/manual_memcpy.rs
  function check (line 20) | pub(super) fn check<'tcx>(
  function build_manual_memcpy_suggestion (line 113) | fn build_manual_memcpy_suggestion<'tcx>(
  type MinifyingSugg (line 221) | struct MinifyingSugg<'a>(Sugg<'a>);
  method fmt (line 224) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function into_sugg (line 230) | fn into_sugg(self) -> Sugg<'a> {
  function from (line 236) | fn from(sugg: Sugg<'a>) -> Self {
  type Output (line 242) | type Output = MinifyingSugg<'static>;
  function add (line 243) | fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
  type Output (line 253) | type Output = MinifyingSugg<'static>;
  function sub (line 254) | fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
  type Output (line 265) | type Output = MinifyingSugg<'static>;
  function add (line 266) | fn add(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
  type Output (line 276) | type Output = MinifyingSugg<'static>;
  function sub (line 277) | fn sub(self, rhs: &MinifyingSugg<'static>) -> MinifyingSugg<'static> {
  type Offset (line 289) | struct Offset {
    method negative (line 301) | fn negative(value: Sugg<'static>) -> Self {
    method positive (line 308) | fn positive(value: Sugg<'static>) -> Self {
    method empty (line 315) | fn empty() -> Self {
  type OffsetSign (line 295) | enum OffsetSign {
  function apply_offset (line 320) | fn apply_offset(lhs: &MinifyingSugg<'static>, rhs: &Offset) -> Minifying...
  type StartKind (line 328) | enum StartKind<'hir> {
  type IndexExpr (line 333) | struct IndexExpr<'hir> {
  type Start (line 339) | struct Start<'hir> {
  function get_slice_like_element_ty (line 344) | fn get_slice_like_element_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>)...
  function fetch_cloned_expr (line 353) | fn fetch_cloned_expr<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
  function get_details_from_idx (line 363) | fn get_details_from_idx<'tcx>(
  function get_assignment (line 403) | fn get_assignment<'tcx>(e: &'tcx Expr<'tcx>) -> Option<(&'tcx Expr<'tcx>...
  function get_assignments (line 415) | fn get_assignments<'a, 'tcx>(
  function get_loop_counters (line 445) | fn get_loop_counters<'a, 'tcx>(
  function is_array_length_equal_to_range (line 472) | fn is_array_length_equal_to_range(cx: &LateContext<'_>, start: &Expr<'_>...

FILE: clippy_lints/src/loops/manual_slice_fill.rs
  function check (line 21) | pub(super) fn check<'tcx>(
  function sugg (line 90) | fn sugg<'tcx>(

FILE: clippy_lints/src/loops/manual_while_let_some.rs
  type PopStmt (line 17) | enum PopStmt<'hir> {
  function report_lint (line 28) | fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopS...
  function match_method_call (line 50) | fn match_method_call<const ARGS_COUNT: usize>(cx: &LateContext<'_>, expr...
  function is_vec_pop_unwrap (line 61) | fn is_vec_pop_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>, is_empty_rec...
  function check_local (line 74) | fn check_local(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_recv: &Ex...
  function check_call_arguments (line 83) | fn check_call_arguments(cx: &LateContext<'_>, stmt: &Stmt<'_>, is_empty_...
  function check (line 97) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, full_cond: &'tcx Expr<...

FILE: clippy_lints/src/loops/missing_spin_loop.rs
  function unpack_cond (line 10) | fn unpack_cond<'tcx>(cond: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
  function check (line 33) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, ...

FILE: clippy_lints/src/loops/mod.rs
  type Loops (line 815) | pub struct Loops {
    method new (line 820) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 829) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
    method check_for_loop (line 929) | fn check_for_loop<'tcx>(
    method check_for_loop_arg (line 956) | fn check_for_loop_arg(&self, cx: &LateContext<'_>, _: &Pat<'_>, arg: &...

FILE: clippy_lints/src/loops/mut_range_bound.rs
  function check (line 14) | pub(super) fn check(cx: &LateContext<'_>, arg: &Expr<'_>, body: &Expr<'_...
  function mut_warn_with_span (line 29) | fn mut_warn_with_span(cx: &LateContext<'_>, span: Option<Span>) {
  function check_for_mutability (line 42) | fn check_for_mutability(cx: &LateContext<'_>, bound: &Expr<'_>) -> Optio...
  function check_for_mutation (line 52) | fn check_for_mutation(
  type MutatePairDelegate (line 72) | struct MutatePairDelegate<'a, 'tcx> {
  function consume (line 81) | fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
  function use_cloned (line 83) | fn use_cloned(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
  function borrow (line 85) | fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId, bk...
  function mutate (line 98) | fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, diag_expr_id: HirId) {
  function fake_read (line 109) | fn fake_read(&mut self, _: &PlaceWithHirId<'tcx>, _: FakeReadCause, _: H...
  function mutation_span (line 113) | fn mutation_span(&self) -> (Option<Span>, Option<Span>) {
  type BreakAfterExprVisitor (line 118) | struct BreakAfterExprVisitor {
    method is_found (line 125) | pub fn is_found(cx: &LateContext<'_>, hir_id: HirId) -> bool {
    type Result (line 140) | type Result = ControlFlow<()>;
    method visit_expr (line 141) | fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> ControlFlow<()> {

FILE: clippy_lints/src/loops/needless_range_loop.rs
  function check (line 22) | pub(super) fn check<'tcx>(
  function is_len_call (line 191) | fn is_len_call(expr: &Expr<'_>, var: Symbol) -> bool {
  function is_end_eq_array_len (line 204) | fn is_end_eq_array_len<'tcx>(
  type VarVisitor (line 225) | struct VarVisitor<'a, 'tcx> {
  function check (line 253) | fn check(&mut self, idx: &'tcx Expr<'_>, seqexpr: &'tcx Expr<'_>, expr: ...
  function visit_expr (line 337) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/loops/never_loop.rs
  function check (line 20) | pub(super) fn check<'tcx>(
  function check_iterator_reduction (line 78) | pub(super) fn check_iterator_reduction<'tcx>(
  function contains_any_break_or_continue (line 103) | fn contains_any_break_or_continue(block: &Block<'_>) -> bool {
  function contains_label (line 113) | fn contains_label(asm: &InlineAsm<'_>) -> bool {
  type NeverLoopResult (line 130) | enum NeverLoopResult {
  function absorb_break (line 145) | fn absorb_break(arg: &NeverLoopResult) -> NeverLoopResult {
  function combine_seq (line 154) | fn combine_seq(first: NeverLoopResult, second: impl FnOnce() -> NeverLoo...
  function combine_seq_many (line 163) | fn combine_seq_many(iter: impl IntoIterator<Item = NeverLoopResult>) -> ...
  function combine_branches (line 174) | fn combine_branches(b1: NeverLoopResult, b2: NeverLoopResult) -> NeverLo...
  function never_loop_block (line 200) | fn never_loop_block<'tcx>(
  function stmt_to_expr (line 228) | fn stmt_to_expr<'tcx>(stmt: &Stmt<'tcx>) -> Option<(&'tcx Expr<'tcx>, Op...
  function stmt_source_span (line 237) | fn stmt_source_span(stmt: &Stmt<'_>) -> Span {
  function all_spans_after_expr (line 253) | fn all_spans_after_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> Vec<Sp...
  function is_label_for_block (line 273) | fn is_label_for_block(cx: &LateContext<'_>, dest: &Destination) -> bool {
  function never_loop_expr (line 279) | fn never_loop_expr<'tcx>(
  function never_loop_expr_all (line 460) | fn never_loop_expr_all<'tcx, T: Iterator<Item = &'tcx Expr<'tcx>>>(
  function for_to_if_let_sugg (line 469) | fn for_to_if_let_sugg(cx: &LateContext<'_>, iterator: &Expr<'_>, pat: &P...
  function mark_block_as_reachable (line 476) | fn mark_block_as_reachable(expr: &Expr<'_>, local_labels: &mut [(HirId, ...

FILE: clippy_lints/src/loops/same_item_push.rs
  function check (line 17) | pub(super) fn check<'tcx>(
  type SameItemPushVisitor (line 105) | struct SameItemPushVisitor<'a, 'tcx> {
  function new (line 115) | fn new(cx: &'a LateContext<'tcx>) -> Self {
  function should_lint (line 125) | fn should_lint(&self) -> bool {
  function visit_expr (line 139) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
  function visit_block (line 153) | fn visit_block(&mut self, b: &'tcx Block<'_>) {
  function visit_stmt (line 159) | fn visit_stmt(&mut self, s: &'tcx Stmt<'_>) {
  function get_vec_push (line 181) | fn get_vec_push<'tcx>(

FILE: clippy_lints/src/loops/single_element_loop.rs
  function check (line 13) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/loops/unused_enumerate_index.rs
  function check (line 11) | pub(super) fn check<'tcx>(
  function check_method (line 61) | pub(super) fn check_method<'tcx>(

FILE: clippy_lints/src/loops/utils.rs
  type IncrementVisitorVarState (line 15) | enum IncrementVisitorVarState {
  type IncrementVisitor (line 22) | pub(super) struct IncrementVisitor<'a, 'tcx> {
  function new (line 29) | pub(super) fn new(cx: &'a LateContext<'tcx>) -> Self {
  function into_results (line 37) | pub(super) fn into_results(self) -> impl Iterator<Item = HirId> {
  function visit_expr (line 49) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
  type InitializeVisitorState (line 97) | enum InitializeVisitorState<'hir> {
  type InitializeVisitor (line 110) | pub(super) struct InitializeVisitor<'a, 'tcx> {
  function new (line 120) | pub(super) fn new(cx: &'a LateContext<'tcx>, end_expr: &'tcx Expr<'tcx>,...
  function get_result (line 131) | pub(super) fn get_result(&self) -> Option<(Symbol, Option<Ty<'tcx>>, &'t...
  type NestedFilter (line 141) | type NestedFilter = nested_filter::OnlyBodies;
  function visit_local (line 143) | fn visit_local(&mut self, l: &'tcx LetStmt<'_>) {
  function visit_expr (line 162) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
  function maybe_tcx (line 242) | fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
  function is_loop (line 247) | fn is_loop(expr: &Expr<'_>) -> bool {
  function is_conditional (line 251) | fn is_conditional(expr: &Expr<'_>) -> bool {
  function make_iterator_snippet (line 257) | pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>...

FILE: clippy_lints/src/loops/while_float.rs
  function check (line 4) | pub(super) fn check(cx: &rustc_lint::LateContext<'_>, condition: &rustc_...
  function is_float_type (line 18) | fn is_float_type(cx: &rustc_lint::LateContext<'_>, expr: &rustc_hir::Exp...

FILE: clippy_lints/src/loops/while_immutable_condition.rs
  function check (line 12) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, ...
  type HasBreakOrReturnVisitor (line 58) | struct HasBreakOrReturnVisitor;
    type Result (line 61) | type Result = ControlFlow<()>;
    method visit_expr (line 62) | fn visit_expr(&mut self, expr: &'tcx Expr<'_>) -> ControlFlow<()> {
  type VarCollectorVisitor (line 78) | struct VarCollectorVisitor<'a, 'tcx> {
  function insert_def_id (line 85) | fn insert_def_id(&mut self, ex: &'tcx Expr<'_>) {
  type Result (line 104) | type Result = ControlFlow<()>;
  function visit_expr (line 105) | fn visit_expr(&mut self, ex: &'tcx Expr<'_>) -> Self::Result {

FILE: clippy_lints/src/loops/while_let_loop.rs
  function check (line 12) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ...
  function is_simple_break_block (line 66) | fn is_simple_break_block(block: &Block<'_>) -> bool {
  function is_simple_break_expr (line 76) | fn is_simple_break_expr(expr: &Expr<'_>) -> bool {
  function could_be_while_let (line 84) | fn could_be_while_let<'tcx>(
  function is_trivial_assignment (line 139) | fn is_trivial_assignment(pat: &Pat<'_>, init: &Expr<'_>) -> bool {

FILE: clippy_lints/src/loops/while_let_on_iterator.rs
  function check (line 19) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type IterExpr (line 72) | struct IterExpr {
  function try_parse_iter_expr (line 83) | fn try_parse_iter_expr(cx: &LateContext<'_>, mut e: &Expr<'_>) -> Option...
  function is_expr_same_field (line 132) | fn is_expr_same_field(cx: &LateContext<'_>, mut e: &Expr<'_>, mut fields...
  function is_expr_same_child_or_parent_field (line 152) | fn is_expr_same_child_or_parent_field(cx: &LateContext<'_>, expr: &Expr<...
  function skip_fields_and_path (line 192) | fn skip_fields_and_path<'tcx>(expr: &'tcx Expr<'_>) -> (Option<&'tcx Exp...
  function uses_iter (line 205) | fn uses_iter<'tcx>(cx: &LateContext<'tcx>, iter_expr: &IterExpr, contain...
  function needs_mutable_borrow (line 238) | fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop...
  function make_iterator_snippet (line 362) | fn make_iterator_snippet<'tcx>(cx: &LateContext<'tcx>, iter_expr: &Expr<...

FILE: clippy_lints/src/macro_metavars_in_unsafe.rs
  type MetavarState (line 90) | pub enum MetavarState {
  type ExprMetavarsInUnsafe (line 95) | pub struct ExprMetavarsInUnsafe {
    method new (line 114) | pub fn new(conf: &'static Conf) -> Self {
    method check_body (line 216) | fn check_body(&mut self, cx: &LateContext<'tcx>, body: &rustc_hir::Bod...
    method check_crate_post (line 234) | fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
  type BodyVisitor (line 122) | struct BodyVisitor<'a, 'tcx> {
  function is_public_macro (line 149) | fn is_public_macro(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
  function visit_stmt (line 155) | fn visit_stmt(&mut self, s: &'tcx Stmt<'tcx>) {
  function visit_expr (line 166) | fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {

FILE: clippy_lints/src/macro_use.rs
  type MacroRefData (line 50) | pub struct MacroRefData {
    method new (line 55) | pub fn new(name: String) -> Self {
  type MacroUseImports (line 61) | pub struct MacroUseImports {
    method push_unique_macro (line 71) | fn push_unique_macro(&mut self, cx: &LateContext<'_>, span: Span) {
    method push_unique_macro_pat_ty (line 86) | fn push_unique_macro_pat_ty(&mut self, cx: &LateContext<'_>, span: Spa...
    method check_item (line 97) | fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) {
    method check_expr (line 116) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
    method check_stmt (line 121) | fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &hir::Stmt<'_>) {
    method check_pat (line 126) | fn check_pat(&mut self, cx: &LateContext<'_>, pat: &hir::Pat<'_>) {
    method check_ty (line 131) | fn check_ty(&mut self, cx: &LateContext<'_>, ty: &hir::Ty<'_, AmbigArg...
    method check_crate_post (line 136) | fn check_crate_post(&mut self, cx: &LateContext<'_>) {

FILE: clippy_lints/src/main_recursion.rs
  type MainRecursion (line 31) | pub struct MainRecursion {
    method check_crate (line 36) | fn check_crate(&mut self, cx: &LateContext<'_>) {
    method check_expr_post (line 40) | fn check_expr_post(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/manual_abs_diff.rs
  type ManualAbsDiff (line 46) | pub struct ManualAbsDiff {
    method new (line 51) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 57) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...
    method are_ty_eligible (line 100) | fn are_ty_eligible<'tcx>(&self, cx: &LateContext<'tcx>, a: &Expr<'_>, ...
  function is_sub_expr (line 117) | fn is_sub_expr(
  function is_unsuffixed_numeral_lit (line 149) | fn is_unsuffixed_numeral_lit(expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/manual_assert.rs
  method check_expr (line 38) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {

FILE: clippy_lints/src/manual_async_fn.rs
  method check_fn (line 42) | fn check_fn(
  function future_trait_ref (line 107) | fn future_trait_ref<'tcx>(cx: &LateContext<'tcx>, opaque: &'tcx OpaqueTy...
  function future_output_ty (line 122) | fn future_output_ty<'tcx>(trait_ref: &'tcx TraitRef<'tcx>) -> Option<&'t...
  function captures_all_lifetimes (line 135) | fn captures_all_lifetimes(cx: &LateContext<'_>, fn_def_id: LocalDefId, o...
  function desugared_async_block (line 168) | fn desugared_async_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Bloc...
  function suggested_ret (line 182) | fn suggested_ret(cx: &LateContext<'_>, output: &Ty<'_>) -> Option<(&'sta...

FILE: clippy_lints/src/manual_bits.rs
  type ManualBits (line 39) | pub struct ManualBits {
    method new (line 44) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 50) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function get_one_size_of_ty (line 80) | fn get_one_size_of_ty<'tcx>(
  function get_size_of_ty (line 92) | fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) ->...
  function create_sugg (line 112) | fn create_sugg(cx: &LateContext<'_>, expr: &Expr<'_>, base_sugg: String)...
  function is_ty_conversion (line 131) | fn is_ty_conversion(expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/manual_checked_ops.rs
  type NonZeroBranch (line 42) | enum NonZeroBranch {
  method check_expr (line 48) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  type UseKind (line 129) | enum UseKind {
  function divisor_from_condition (line 134) | fn divisor_from_condition<'tcx>(cond: &'tcx Expr<'tcx>) -> Option<(&'tcx...
  function branch_block (line 148) | fn branch_block<'tcx>(
  function is_zero (line 165) | fn is_zero(expr: &Expr<'_>) -> bool {
  function is_unsigned_integer (line 169) | fn is_unsigned_integer(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/manual_clamp.rs
  type ManualClamp (line 94) | pub struct ManualClamp {
    method new (line 99) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 142) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...
    method check_block (line 157) | fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'...
  type ClampSuggestion (line 105) | struct ClampSuggestion<'tcx> {
  function min_less_than_max (line 115) | fn min_less_than_max(&self, cx: &LateContext<'tcx>) -> bool {
  type InputMinMax (line 134) | struct InputMinMax<'tcx> {
  function maybe_emit_suggestion (line 167) | fn maybe_emit_suggestion<'tcx>(cx: &LateContext<'tcx>, suggestion: &Clam...
  type TypeClampability (line 211) | enum TypeClampability {
    method is_clampable (line 217) | fn is_clampable<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<...
    method is_float (line 231) | fn is_float(self) -> bool {
  function is_if_elseif_else_pattern (line 250) | fn is_if_elseif_else_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx E...
  function is_max_min_pattern (line 293) | fn is_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tc...
  function is_call_max_min_pattern (line 331) | fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Exp...
  function is_match_pattern (line 422) | fn is_match_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>...
  function is_two_if_pattern (line 479) | fn is_two_if_pattern<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'t...
  function is_if_elseif_pattern (line 540) | fn is_if_elseif_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'...
  type BinaryOp (line 579) | struct BinaryOp<'tcx> {
  function new (line 586) | fn new(e: &'tcx Expr<'tcx>) -> Option<BinaryOp<'tcx>> {
  function flip (line 597) | fn flip(&self) -> Self {
  function is_clamp_meta_pattern (line 632) | fn is_clamp_meta_pattern<'tcx>(
  function block_stmt_with_last (line 716) | fn block_stmt_with_last<'tcx>(block: &'tcx Block<'tcx>) -> impl Iterator...
  function is_ord_op (line 729) | fn is_ord_op(op: BinOpKind) -> bool {
  type MaybeBorrowedStmtKind (line 735) | enum MaybeBorrowedStmtKind<'a> {
  method clone (line 741) | fn clone(&self) -> Self {
  type Target (line 751) | type Target = StmtKind<'a>;
  method deref (line 753) | fn deref(&self) -> &Self::Target {

FILE: clippy_lints/src/manual_float_methods.rs
  type Variant (line 69) | enum Variant {
    method lint (line 75) | pub fn lint(self) -> &'static Lint {
    method msg (line 82) | pub fn msg(self) -> &'static str {
  type ManualFloatMethods (line 90) | pub struct ManualFloatMethods {
    method new (line 95) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 137) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...
  function is_not_const (line 100) | fn is_not_const(tcx: TyCtxt<'_>, def_id: DefId) -> bool {

FILE: clippy_lints/src/manual_hash_one.rs
  type ManualHashOne (line 52) | pub struct ManualHashOne {
    method new (line 57) | pub fn new(conf: &'static Conf) -> Self {
    method check_local (line 63) | fn check_local(&mut self, cx: &LateContext<'_>, local: &LetStmt<'_>) {

FILE: clippy_lints/src/manual_ignore_case_cmp.rs
  type MatchType (line 44) | enum MatchType<'a> {
  function get_ascii_type (line 49) | fn get_ascii_type<'a>(cx: &LateContext<'a>, kind: rustc_hir::ExprKind<'_...
  function needs_ref_to_cmp (line 72) | fn needs_ref_to_cmp(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
  method check_expr (line 80) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {

FILE: clippy_lints/src/manual_ilog2.rs
  type ManualIlog2 (line 42) | pub struct ManualIlog2 {
    method new (line 47) | pub fn new(conf: &Conf) -> Self {
    method check_expr (line 53) | fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tc...
  function emit (line 103) | fn emit(cx: &LateContext<'_>, recv: &Expr<'_>, full_expr: &Expr<'_>) {

FILE: clippy_lints/src/manual_is_ascii_check.rs
  type ManualIsAsciiCheck (line 63) | pub struct ManualIsAsciiCheck {
    method new (line 68) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 93) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type CharRange (line 74) | enum CharRange {
  function get_ty_sugg (line 130) | fn get_ty_sugg<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'_>) -> Option<(...
  function check_is_ascii (line 142) | fn check_is_ascii(
  function check_pat (line 175) | fn check_pat(pat_kind: &PatKind<'_>) -> CharRange {
  function check_expr_range (line 197) | fn check_expr_range(start: &Expr<'_>, end: &Expr<'_>) -> CharRange {
  function check_range (line 207) | fn check_range(start: &PatExpr<'_>, end: &PatExpr<'_>) -> CharRange {
  function check_lit_range (line 223) | fn check_lit_range(start_lit: &Lit, end_lit: &Lit) -> CharRange {

FILE: clippy_lints/src/manual_is_power_of_two.rs
  type ManualIsPowerOfTwo (line 39) | pub struct ManualIsPowerOfTwo {
    method new (line 44) | pub fn new(conf: &'static Conf) -> Self {
    method build_sugg (line 48) | fn build_sugg(&self, cx: &LateContext<'_>, expr: &Expr<'_>, receiver: ...
    method check_expr (line 69) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
  function count_ones_receiver (line 96) | fn count_ones_receiver<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) ...
  function is_one_less (line 110) | fn is_one_less<'tcx>(
  function is_and_minus_one (line 127) | fn is_and_minus_one<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> ...
  function unexpanded_binop_operands (line 134) | fn unexpanded_binop_operands<'hir>(expr: &Expr<'hir>, op: BinOpKind) -> ...

FILE: clippy_lints/src/manual_let_else.rs
  method check_manual_let_else (line 52) | pub(crate) fn check_manual_let_else(&self, cx: &LateContext<'tcx>, stmt:...
  function is_arms_disjointed (line 120) | fn is_arms_disjointed(cx: &LateContext<'_>, arm1: &Arm<'_>, arm2: &Arm<'...
  function is_enum_variant (line 133) | pub fn is_enum_variant(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
  function emit_manual_let_else (line 159) | fn emit_manual_let_else(
  function replace_in_pattern (line 223) | fn replace_in_pattern(
  function pat_allowed_for_else (line 344) | fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_ty...
  function expr_simple_identity_map (line 410) | fn expr_simple_identity_map<'a, 'hir>(

FILE: clippy_lints/src/manual_main_separator_str.rs
  type ManualMainSeparatorStr (line 38) | pub struct ManualMainSeparatorStr {
    method new (line 43) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 49) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {

FILE: clippy_lints/src/manual_non_exhaustive.rs
  type ManualNonExhaustive (line 66) | pub struct ManualNonExhaustive {
    method new (line 73) | pub fn new(conf: &'static Conf) -> Self {
    method check_item (line 83) | fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
    method check_expr (line 137) | fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
    method check_crate_post (line 147) | fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {

FILE: clippy_lints/src/manual_option_as_slice.rs
  type ManualOptionAsSlice (line 45) | pub struct ManualOptionAsSlice {
    method new (line 50) | pub fn new(conf: &Conf) -> Self {
    method check_expr (line 56) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  function check_map (line 103) | fn check_map(cx: &LateContext<'_>, map: &Expr<'_>, span: Span, msrv: Msr...
  function check_as_ref (line 112) | fn check_as_ref(cx: &LateContext<'_>, expr: &Expr<'_>, span: Span, msrv:...
  function extract_ident_from_some_pat (line 144) | fn extract_ident_from_some_pat(cx: &LateContext<'_>, pat: &Pat<'_>) -> O...
  function check_some_body (line 155) | fn check_some_body(cx: &LateContext<'_>, name: Symbol, expr: &Expr<'_>) ...
  function check_arms (line 167) | fn check_arms(cx: &LateContext<'_>, none_arm: &Arm<'_>, some_arm: &Arm<'...
  function returns_empty_slice (line 179) | fn returns_empty_slice(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function is_empty_slice (line 192) | fn is_empty_slice(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function is_slice_from_ref (line 211) | fn is_slice_from_ref(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/manual_pop_if.rs
  type ManualPopIf (line 62) | pub struct ManualPopIf {
    method new (line 67) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 408) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type ManualPopIfKind (line 74) | enum ManualPopIfKind {
    method check_method (line 81) | fn check_method(self) -> Symbol {
    method pop_method (line 89) | fn pop_method(self) -> Symbol {
    method pop_if_method (line 97) | fn pop_if_method(self) -> Symbol {
    method is_diag_item (line 105) | fn is_diag_item(self, cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
    method msrv (line 113) | fn msrv(self) -> RustcVersion {
    method fmt (line 123) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ManualPopIfPattern (line 132) | struct ManualPopIfPattern<'tcx> {
  function emit_lint (line 149) | fn emit_lint(&self, cx: &LateContext<'_>) {
  function pop_value_is_used (line 171) | fn pop_value_is_used(then_block: &Expr<'_>) -> bool {
  function check_is_some_and_pattern (line 193) | fn check_is_some_and_pattern<'tcx>(
  function check_if_let_pattern (line 239) | fn check_if_let_pattern<'tcx>(
  function check_let_chain_pattern (line 298) | fn check_let_chain_pattern<'tcx>(
  function check_map_unwrap_or_pattern (line 349) | fn check_map_unwrap_or_pattern<'tcx>(
  function check_pop_unwrap (line 393) | fn check_pop_unwrap<'tcx>(expr: &'tcx Expr<'_>, pop_method: Symbol) -> O...

FILE: clippy_lints/src/manual_range_patterns.rs
  function expr_as_i128 (line 41) | fn expr_as_i128(expr: &PatExpr<'_>) -> Option<i128> {
  type Num (line 54) | struct Num {
    method new (line 60) | fn new(expr: &PatExpr<'_>) -> Option<Self> {
    method dummy (line 67) | fn dummy(val: i128) -> Self {
    method min (line 71) | fn min(self, other: Self) -> Self {
  method check_pat (line 77) | fn check_pat(&mut self, cx: &LateContext<'_>, pat: &'_ rustc_hir::Pat<'_...

FILE: clippy_lints/src/manual_rem_euclid.rs
  type ManualRemEuclid (line 40) | pub struct ManualRemEuclid {
    method new (line 45) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 51) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function check_for_either_unsigned_int_constant (line 106) | fn check_for_either_unsigned_int_constant<'a>(
  function check_for_unsigned_int_constant (line 117) | fn check_for_unsigned_int_constant<'a>(

FILE: clippy_lints/src/manual_retain.rs
  constant ACCEPTABLE_METHODS (line 16) | const ACCEPTABLE_METHODS: [Symbol; 5] = [
  type ManualRetain (line 49) | pub struct ManualRetain {
    method new (line 54) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 60) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr...
  function check_into_iter (line 74) | fn check_into_iter(
  function check_iter (line 117) | fn check_iter(
  function check_to_owned (line 175) | fn check_to_owned(
  function make_sugg (line 216) | fn make_sugg(
  function match_acceptable_sym (line 245) | fn match_acceptable_sym(cx: &LateContext<'_>, collect_def_id: DefId) -> ...
  function match_acceptable_type (line 251) | fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msr...
  function match_map_type (line 265) | fn match_map_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
  function make_span_lint_and_sugg (line 270) | fn make_span_lint_and_sugg(cx: &LateContext<'_>, span: Span, sugg: Strin...

FILE: clippy_lints/src/manual_rotate.rs
  type ShiftDirection (line 45) | enum ShiftDirection {
  method fmt (line 51) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function parse_shift (line 59) | fn parse_shift<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<(ShiftDirection, ...
  method check_expr (line 72) | fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {

FILE: clippy_lints/src/manual_slice_size_calculation.rs
  type ManualSliceSizeCalculation (line 44) | pub struct ManualSliceSizeCalculation {
    method new (line 49) | pub fn new(conf: &Conf) -> Self {
    method check_expr (line 55) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx...
  function simplify (line 85) | fn simplify<'tcx>(
  function simplify_half (line 96) | fn simplify_half<'tcx>(

FILE: clippy_lints/src/manual_string_new.rs
  method check_expr (line 41) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  function is_expr_kind_empty_str (line 69) | fn is_expr_kind_empty_str(expr_kind: &ExprKind<'_>) -> bool {
  function warn_then_suggest (line 80) | fn warn_then_suggest(cx: &LateContext<'_>, span: Span) {
  function parse_method_call (line 93) | fn parse_method_call(cx: &LateContext<'_>, span: Span, path_segment: &Pa...
  function parse_call (line 107) | fn parse_call(cx: &LateContext<'_>, span: Span, func: &Expr<'_>, arg: &E...

FILE: clippy_lints/src/manual_strip.rs
  type ManualStrip (line 55) | pub struct ManualStrip {
    method new (line 60) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 72) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  type StripKind (line 66) | enum StripKind {
  function len_arg (line 157) | fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option...
  function constant_length (line 169) | fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxCo...
  function eq_pattern_length (line 179) | fn eq_pattern_length<'tcx>(
  function is_ref_str (line 197) | fn is_ref_str(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function peel_ref (line 205) | fn peel_ref<'a>(expr: &'a Expr<'_>) -> &'a Expr<'a> {
  function find_stripping (line 217) | fn find_stripping<'tcx>(

FILE: clippy_lints/src/manual_take.rs
  type ManualTake (line 44) | pub struct ManualTake {
    method new (line 49) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 55) | fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
  function as_const_bool (line 107) | fn as_const_bool(e: &Expr<'_>) -> Option<bool> {

FILE: clippy_lints/src/map_unit_fn.rs
  function is_unit_type (line 97) | fn is_unit_type(ty: Ty<'_>) -> bool {
  function is_unit_function (line 101) | fn is_unit_function(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
  function is_unit_expression (line 112) | fn is_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
  function reduce_unit_expression (line 122) | fn reduce_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) ->...
  function unit_closure (line 165) | fn unit_closure<'tcx>(
  function let_binding_name (line 187) | fn let_binding_name(cx: &LateContext<'_>, var_arg: &hir::Expr<'_>) -> St...
  function suggestion_msg (line 196) | fn suggestion_msg(function_type: &str, article: &str, map_type: &str) ->...
  function lint_map_unit_fn (line 202) | fn lint_map_unit_fn(
  method check_stmt (line 265) | fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &hir::Stmt<'_>) {

FILE: clippy_lints/src/match_result_ok.rs
  method check_expr (line 47) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/matches/collapsible_match.rs
  function check_match (line 20) | pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr...
  function check_if_let (line 28) | pub(super) fn check_if_let<'tcx>(
  function check_arm (line 40) | fn check_arm<'tcx>(
  function arm_is_wild_like (line 193) | fn arm_is_wild_like(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
  function find_pat_binding_and_is_innermost_parent_pat_struct (line 211) | fn find_pat_binding_and_is_innermost_parent_pat_struct(pat: &Pat<'_>, hi...
  function build_ref_method_chain (line 234) | fn build_ref_method_chain(expr: Vec<&Expr<'_>>) -> Option<String> {

FILE: clippy_lints/src/matches/infallible_destructuring_match.rs
  function check (line 11) | pub(crate) fn check(cx: &LateContext<'_>, local: &LetStmt<'_>) -> bool {

FILE: clippy_lints/src/matches/manual_filter.rs
  function get_cond_expr (line 18) | fn get_cond_expr<'tcx>(
  function peels_blocks_incl_unsafe_opt (line 41) | fn peels_blocks_incl_unsafe_opt<'a>(expr: &'a Expr<'a>) -> Option<&'a Ex...
  function peels_blocks_incl_unsafe (line 52) | fn peels_blocks_incl_unsafe<'a>(expr: &'a Expr<'a>) -> &'a Expr<'a> {
  function is_some_expr (line 63) | fn is_some_expr(cx: &LateContext<'_>, target: HirId, ctxt: SyntaxContext...
  function is_none_expr (line 73) | fn is_none_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function add_ampersand_if_copy (line 82) | fn add_ampersand_if_copy(body_str: String, has_copy_trait: bool) -> Stri...
  function check_match (line 92) | pub(super) fn check_match<'tcx>(
  function check_if_let (line 116) | pub(super) fn check_if_let<'tcx>(
  function check (line 127) | fn check<'tcx>(

FILE: clippy_lints/src/matches/manual_map.rs
  function check_match (line 11) | pub(super) fn check_match<'tcx>(
  function check_if_let (line 25) | pub(super) fn check_if_let<'tcx>(
  function check (line 36) | fn check<'tcx>(
  function get_some_expr (line 78) | fn get_some_expr<'tcx>(

FILE: clippy_lints/src/matches/manual_ok_err.rs
  function check_if_let (line 18) | pub(crate) fn check_if_let(
  function check_match (line 35) | pub(crate) fn check_match(cx: &LateContext<'_>, expr: &Expr<'_>, scrutin...
  function is_variant_or_wildcard (line 63) | fn is_variant_or_wildcard(cx: &LateContext<'_>, pat: &Pat<'_>, can_be_wi...
  function is_ok_or_err (line 90) | fn is_ok_or_err<'hir>(cx: &LateContext<'_>, pat: &Pat<'hir>) -> Option<(...
  function is_some_ident (line 108) | fn is_some_ident<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, ident: &...
  function is_none (line 125) | fn is_none(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
  function apply_lint (line 131) | fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_...

FILE: clippy_lints/src/matches/manual_unwrap_or.rs
  function get_some (line 20) | fn get_some(cx: &LateContext<'_>, pat: &Pat<'_>) -> Option<HirId> {
  function get_none (line 36) | fn get_none<'tcx>(cx: &LateContext<'_>, arm: &Arm<'tcx>, allow_wildcard:...
  function get_some_and_none_bodies (line 63) | fn get_some_and_none_bodies<'tcx>(
  function handle (line 81) | fn handle(
  function find_type_name (line 183) | fn find_type_name<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<...
  function safe_to_move_scrutinee (line 201) | fn safe_to_move_scrutinee(cx: &LateContext<'_>, expr: &Expr<'_>, scrutin...
  function check_match (line 214) | pub fn check_match<'tcx>(
  function check_if_let (line 231) | pub fn check_if_let<'tcx>(

FILE: clippy_lints/src/matches/manual_utils.rs
  function check_with (line 20) | pub(super) fn check_with<'tcx, F>(
  type SuggInfo (line 178) | pub struct SuggInfo<'a> {
  function can_pass_as_func (line 189) | fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: ...
  type OptionPat (line 203) | pub(super) enum OptionPat<'a> {
  type SomeExpr (line 215) | pub(super) struct SomeExpr<'tcx> {
  function new_no_negated (line 222) | pub fn new_no_negated(expr: &'tcx Expr<'tcx>, needs_unsafe_block: bool) ...
  function to_snippet_with_context (line 230) | pub fn to_snippet_with_context(
  function try_parse_pattern (line 243) | pub(super) fn try_parse_pattern<'tcx>(
  function is_none_arm_body (line 270) | fn is_none_arm_body(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/matches/match_as_ref.rs
  function check (line 12) | pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>...
  function as_ref_some_arm (line 84) | fn as_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutabi...

FILE: clippy_lints/src/matches/match_bool.rs
  function check (line 13) | pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[...

FILE: clippy_lints/src/matches/match_like_matches.rs
  function check_if_let (line 17) | pub(crate) fn check_if_let<'tcx>(
  function check_match (line 66) | pub(super) fn check_match<'tcx>(
  function find_bool_lit (line 202) | fn find_bool_lit(ex: &Expr<'_>) -> Option<bool> {
  function is_some_wild (line 229) | fn is_some_wild(pat_kind: PatKind<'_>) -> bool {

FILE: clippy_lints/src/matches/match_ref_pats.rs
  function check (line 11) | pub(crate) fn check<'a, 'b, I>(cx: &LateContext<'_>, scrutinee: &Expr<'_...
  function has_multiple_ref_pats (line 71) | fn has_multiple_ref_pats<'a, 'b, I>(pats: I) -> bool

FILE: clippy_lints/src/matches/match_same_arms.rs
  function check (line 21) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
  function adjusted_arm_span (line 177) | fn adjusted_arm_span(cx: &LateContext<'_>, span: Span) -> Span {
  type NormalizedPat (line 185) | enum NormalizedPat<'a> {
  type PatRange (line 207) | struct PatRange {
    method contains (line 213) | fn contains(&self, x: u128) -> bool {
    method overlaps (line 221) | fn overlaps(&self, other: &Self) -> bool {
  function iter_matching_struct_fields (line 235) | fn iter_matching_struct_fields<'a>(
  function from_pat (line 263) | fn from_pat(cx: &LateContext<'_>, arena: &'a DroplessArena, pat: &'a Pat...
  function has_overlapping_values (line 380) | fn has_overlapping_values(&self, other: &Self) -> bool {
  function pat_contains_local (line 439) | fn pat_contains_local(pat: &Pat<'_>, id: HirId) -> bool {
  function bindings_eq (line 449) | fn bindings_eq(pat: &Pat<'_>, mut ids: HirIdSet) -> bool {
  function is_wildcard_arm (line 456) | fn is_wildcard_arm(pat: &Pat<'_>) -> bool {

FILE: clippy_lints/src/matches/match_single_binding.rs
  type AssignmentExpr (line 18) | enum AssignmentExpr {
  function check (line 24) | pub(crate) fn check<'a>(cx: &LateContext<'a>, ex: &Expr<'a>, arms: &[Arm...
  type VarBindingVisitor (line 160) | struct VarBindingVisitor<'a, 'tcx> {
  type Result (line 166) | type Result = ControlFlow<()>;
  function visit_path (line 168) | fn visit_path(&mut self, path: &Path<'tcx>, _: HirId) -> Self::Result {
  function visit_block (line 179) | fn visit_block(&mut self, block: &'tcx Block<'tcx>) -> Self::Result {
  function visit_stmt (line 186) | fn visit_stmt(&mut self, stmt: &'tcx Stmt<'tcx>) -> Self::Result {
  function visit_expr (line 199) | fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) -> Self::Result {
  function is_var_binding_used_later (line 254) | fn is_var_binding_used_later(cx: &LateContext<'_>, expr: &Expr<'_>, arm:...
  function opt_parent_assign_span (line 280) | fn opt_parent_assign_span<'a>(cx: &LateContext<'a>, ex: &Expr<'a>) -> Op...
  function expr_in_nested_block (line 301) | fn expr_in_nested_block(cx: &LateContext<'_>, match_expr: &Expr<'_>) -> ...
  function indent_of_nth_line (line 310) | fn indent_of_nth_line(snippet: &str, nth: usize) -> Option<usize> {
  function reindent_snippet_if_in_block (line 317) | fn reindent_snippet_if_in_block(snippet_body: &str, has_assignment: bool...
  function sugg_with_curlies (line 331) | fn sugg_with_curlies<'a>(

FILE: clippy_lints/src/matches/match_str_case_mismatch.rs
  type CaseMethod (line 18) | enum CaseMethod {
  function check (line 25) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<...
  type MatchExprVisitor (line 38) | struct MatchExprVisitor<'a, 'tcx> {
  type Result (line 43) | type Result = ControlFlow<CaseMethod>;
  function visit_expr (line 44) | fn visit_expr(&mut self, ex: &'tcx Expr<'_>) -> Self::Result {
  function case_altered (line 57) | fn case_altered(&self, segment_ident: Symbol, receiver: &Expr<'_>) -> Co...
  function get_case_method (line 70) | fn get_case_method(segment_ident: Symbol) -> Option<CaseMethod> {
  function verify_case (line 80) | fn verify_case<'a>(case_method: &'a CaseMethod, arms: &'a [Arm<'_>]) -> ...
  function lint (line 104) | fn lint(cx: &LateContext<'_>, case_method: &CaseMethod, bad_case_span: S...

FILE: clippy_lints/src/matches/match_wild_enum.rs
  function check (line 15) | pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>...
  type CommonPrefixSearcher (line 184) | enum CommonPrefixSearcher<'a> {
  function with_path (line 190) | fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
  function with_prefix (line 196) | fn with_prefix(&mut self, path: &'a [PathSegment<'a>]) {
  function is_hidden (line 210) | fn is_hidden(cx: &LateContext<'_>, variant_def: &VariantDef) -> bool {

FILE: clippy_lints/src/matches/match_wild_err_arm.rs
  function check (line 12) | pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms:...

FILE: clippy_lints/src/matches/mod.rs
  type Matches (line 1039) | pub struct Matches {
    method new (line 1045) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 1055) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
    method check_local (line 1208) | fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx LetStmt...
    method check_pat (line 1213) | fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
  function contains_cfg_arm (line 1219) | fn contains_cfg_arm(cx: &LateContext<'_>, e: &Expr<'_>, scrutinee: &Expr...
  function pat_contains_disallowed_or (line 1280) | fn pat_contains_disallowed_or(cx: &LateContext<'_>, pat: &Pat<'_>, msrv:...

FILE: clippy_lints/src/matches/needless_match.rs
  function check_match (line 17) | pub(crate) fn check_match(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[A...
  function check_if_let (line 51) | pub(crate) fn check_if_let<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'_>, ...
  function check_all_arms (line 66) | fn check_all_arms(cx: &LateContext<'_>, match_expr: &Expr<'_>, arms: &[A...
  function check_if_let_inner (line 88) | fn check_if_let_inner(cx: &LateContext<'_>, if_let: &higher::IfLet<'_>) ...
  function expr_ty_matches_p_ty (line 120) | fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &...
  function pat_same_as_expr (line 154) | fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
  function same_non_ref_symbols (line 205) | fn same_non_ref_symbols(pats: &[Pat<'_>], exprs: &[Expr<'_>]) -> bool {

FILE: clippy_lints/src/matches/overlapping_arms.rs
  function check (line 11) | pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, ar...
  function all_ranges (line 30) | fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: T...
  type EndBound (line 73) | pub enum EndBound<T> {
  type SpannedRange (line 79) | struct SpannedRange<T> {
  function overlapping (line 84) | fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T...
  function test_overlapping (line 149) | fn test_overlapping() {

FILE: clippy_lints/src/matches/redundant_guards.rs
  function check (line 20) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>...
  function check_method_calls (line 104) | fn check_method_calls<'tcx>(
  type PatBindingInfo (line 157) | struct PatBindingInfo {
  function get_pat_binding (line 163) | fn get_pat_binding<'tcx>(
  function emit_redundant_guards (line 204) | fn emit_redundant_guards<'tcx>(
  function expr_can_be_pat (line 247) | fn expr_can_be_pat(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {

FILE: clippy_lints/src/matches/redundant_pattern_match.rs
  function check (line 19) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
  function check_if_let (line 32) | pub(super) fn check_if_let<'tcx>(
  function check_matches_true (line 46) | pub fn check_matches_true<'tcx>(
  function find_if_let_true (line 65) | fn find_if_let_true<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, sc...
  function find_match_true (line 70) | fn find_match_true<'tcx>(
  function try_get_generic_ty (line 108) | fn try_get_generic_ty(ty: Ty<'_>, index: usize) -> Option<Ty<'_>> {
  function find_method_and_type (line 119) | fn find_method_and_type<'tcx>(
  function find_method_sugg_for_if_let (line 177) | fn find_method_sugg_for_if_let<'tcx>(
  function check_match (line 266) | pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr...
  function found_good_method (line 316) | fn found_good_method<'tcx>(
  function get_ident (line 408) | fn get_ident(path: &QPath<'_>) -> Option<rustc_span::symbol::Ident> {
  function get_good_method (line 418) | fn get_good_method<'tcx>(
  type Item (line 440) | enum Item {
  function is_pat_variant (line 445) | fn is_pat_variant(cx: &LateContext<'_>, pat: &Pat<'_>, path: &QPath<'_>,...
  function find_good_method_for_match (line 474) | fn find_good_method_for_match<'a, 'tcx>(
  function find_good_method_for_matches_macro (line 509) | fn find_good_method_for_matches_macro<'a, 'tcx>(

FILE: clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
  function check (line 8) | pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {

FILE: clippy_lints/src/matches/significant_drop_in_scrutinee.rs
  function check_match (line 20) | pub(super) fn check_match<'tcx>(
  function check_if_let (line 47) | pub(super) fn check_if_let<'tcx>(
  function check_while_let (line 68) | pub(super) fn check_while_let<'tcx>(
  type Suggestion (line 91) | enum Suggestion {
  function check (line 96) | fn check<'tcx>(
  function set_suggestion (line 124) | fn set_suggestion<'tcx>(diag: &mut Diag<'_, ()>, cx: &LateContext<'tcx>,...
  type SigDropChecker (line 162) | struct SigDropChecker<'a, 'tcx> {
  function new (line 168) | fn new(cx: &'a LateContext<'tcx>) -> SigDropChecker<'a, 'tcx> {
  function is_sig_drop_expr (line 175) | fn is_sig_drop_expr(&mut self, ex: &'tcx Expr<'_>) -> bool {
  function has_sig_drop_attr (line 179) | fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
  function has_sig_drop_attr_impl (line 184) | fn has_sig_drop_attr_impl(&mut self, ty: Ty<'tcx>) -> bool {
  type SigDropHolder (line 231) | enum SigDropHolder {
  type SigDropHelper (line 249) | struct SigDropHelper<'a, 'tcx> {
  type FoundSigDrop (line 258) | struct FoundSigDrop {
  function new (line 265) | fn new(cx: &'a LateContext<'tcx>) -> SigDropHelper<'a, 'tcx> {
  function find_sig_drop (line 275) | fn find_sig_drop(&mut self, match_expr: &'tcx Expr<'_>) -> Vec<FoundSigD...
  function replace_current_sig_drop (line 281) | fn replace_current_sig_drop(&mut self, found_span: Span, is_unit_return_...
  function try_move_sig_drop (line 290) | fn try_move_sig_drop(&mut self, expr: &'tcx Expr<'_>, parent_expr: &'tcx...
  function try_move_sig_drop_direct_ref (line 320) | fn try_move_sig_drop_direct_ref(&mut self, expr: &'tcx Expr<'_>, parent_...
  function ty_peel_refs (line 394) | fn ty_peel_refs(mut ty: Ty<'_>) -> (Ty<'_>, usize) {
  function visit_expr (line 404) | fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
  type ArmSigDropHelper (line 453) | struct ArmSigDropHelper<'a, 'tcx> {
  function new (line 459) | fn new(cx: &'a LateContext<'tcx>) -> ArmSigDropHelper<'a, 'tcx> {
  function has_significant_drop_in_arms (line 467) | fn has_significant_drop_in_arms<'tcx>(cx: &LateContext<'tcx>, arms: &[&'...
  function visit_expr (line 476) | fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {

FILE: clippy_lints/src/matches/single_match.rs
  function empty_arm_has_comment (line 24) | fn empty_arm_has_comment(cx: &LateContext<'_>, span: Span) -> bool {
  function check (line 28) | pub(crate) fn check<'tcx>(
  function report_single_pattern (line 83) | fn report_single_pattern(
  type PatVisitor (line 191) | struct PatVisitor<'tcx> {
  type Result (line 196) | type Result = ControlFlow<()>;
  function visit_pat (line 197) | fn visit_pat(&mut self, pat: &'tcx Pat<'_>) -> Self::Result {
  type PatCtxt (line 208) | struct PatCtxt<'tcx> {
  type PatState (line 218) | enum PatState<'a> {
  function add_product_pat (line 242) | fn add_product_pat<'tcx>(
  function get_std_enum_variant (line 263) | fn get_std_enum_variant<'tcx>(
  function check_all_wild_enum (line 292) | fn check_all_wild_enum(&mut self) -> bool {
  function add_struct_pats (line 304) | fn add_struct_pats<'tcx>(
  function add_pat (line 355) | fn add_pat<'tcx>(&mut self, cx: &'a PatCtxt<'tcx>, pat: &'tcx Pat<'_>) -...

FILE: clippy_lints/src/matches/try_err.rs
  function check (line 15) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ...
  function find_return_type (line 69) | fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'...
  function result_error_type (line 81) | fn result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Opti...
  function poll_result_error_type (line 92) | fn poll_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->...
  function poll_option_result_error_type (line 104) | fn poll_option_result_error_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'t...

FILE: clippy_lints/src/matches/wild_in_or_pats.rs
  function check (line 9) | pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arms: &[Arm<'...

FILE: clippy_lints/src/mem_replace.rs
  function check_replace_option_with_none (line 134) | fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, ...
  function check_replace_option_with_some (line 161) | fn check_replace_option_with_some(
  function check_replace_with_uninit (line 194) | fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest:...
  function check_replace_with_default (line 249) | fn check_replace_with_default(
  type MemReplace (line 288) | pub struct MemReplace {
    method new (line 293) | pub fn new(conf: &'static Conf) -> Self {
    method check_expr (line 299) | fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {

FILE: clippy_lints/src/methods/bind_instead_of_map.rs
  function check_and_then_some (line 13) | pub(super) fn check_and_then_some(
  function check_and_then_ok (line 27) | pub(super) fn check_and_then_ok(
  function check_or_else_err (line 41) | pub(super) fn check_or_else_err(
  type BindInsteadOfMap (line 55) | struct BindInsteadOfMap {
    method no_op_msg (line 62) | fn no_op_msg(&self, cx: &LateContext<'_>) -> Option<String> {
    method lint_msg (line 73) | fn lint_msg(&self, cx: &LateContext<'_>) -> Option<String> {
    method lint_closure_autofixable (line 85) | fn lint_closure_autofixable(
    method lint_closure (line 115) | fn lint_closure(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>, clo...
    method check (line 155) | fn check(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir...
    method is_variant (line 194) | fn is_variant(&self, cx: &LateContext<'_>, res: Res) -> bool {

FILE: clippy_lints/src/methods/bytecount.rs
  function check (line 13) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/methods/bytes_count_to_len.rs
  function check (line 10) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/methods/bytes_nth.rs
  function check (line 13) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv:...

FILE: clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
  function check (line 15) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/methods/chars_cmp.rs
  function check (line 12) | pub(super) fn check(

FILE: clippy_lints/src/methods/chars_cmp_with_unwrap.rs
  function check (line 11) | pub(super) fn check(

FILE: clippy_lints/src/methods/chars_last_cmp.rs
  function check (line 8) | pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryE...

FILE: clippy_lints/src/methods/chars_last_cmp_with_unwrap.rs
  function check (line 8) | pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryE...

FILE: clippy_lints/src/methods/chars_next_cmp.rs
  function check (line 7) | pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryE...

FILE: clippy_lints/src/methods/chars_next_cmp_with_unwrap.rs
  function check (line 7) | pub(super) fn check(cx: &LateContext<'_>, info: &crate::methods::BinaryE...

FILE: clippy_lints/src/methods/clear_with_drain.rs
  constant ACCEPTABLE_TYPES_WITH_ARG (line 12) | const ACCEPTABLE_TYPES_WITH_ARG: [rustc_span::Symbol; 2] = [sym::Vec, sy...
  constant ACCEPTABLE_TYPES_WITHOUT_ARG (line 14) | const ACCEPTABLE_TYPES_WITHOUT_ARG: [rustc_span::Symbol; 3] = [sym::Bina...
  function check (line 16) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'...
  function match_acceptable_type (line 29) | fn match_acceptable_type(cx: &LateContext<'_>, expr: &Expr<'_>, types: &...
  function suggest (line 36) | fn suggest(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span:...

FILE: clippy_lints/src/methods/clone_on_copy.rs
  function check (line 14) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Ex...

FILE: clippy_lints/src/methods/clone_on_ref_ptr.rs
  function check (line 12) | pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver...

FILE: clippy_lints/src/methods/cloned_instead_of_copied.rs
  function check (line 13) | pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, spa...

FILE: clippy_lints/src/methods/collapsible_str_replace.rs
  function check (line 13) | pub(super) fn check<'tcx>(
  type ReplaceMethods (line 36) | struct ReplaceMethods<'tcx> {
  function collect_replace_calls (line 41) | fn collect_replace_calls<'tcx>(
  function check_consecutive_replace_calls (line 67) | fn check_consecutive_replace_calls<'tcx>(

FILE: clippy_lints/src/methods/double_ended_iterator_last.rs
  function check (line 13) | pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, self_expr:...

FILE: clippy_lints/src/methods/drain_collect.rs
  function types_match_diagnostic_item (line 19) | fn types_match_diagnostic_item(cx: &LateContext<'_>, expr: Ty<'_>, recv:...
  function check_vec (line 30) | fn check_vec(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, recv...
  function check_string (line 37) | fn check_string(cx: &LateContext<'_>, args: &[Expr<'_>], expr: Ty<'_>, r...
  function check_collections (line 44) | fn check_collections(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>) -...
  function check (line 51) | pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], expr: &Expr...

FILE: clippy_lints/src/methods/err_expect.rs
  function check (line 11) | pub(super) fn check(
  function get_data_type (line 39) | fn get_data_type<'a>(cx: &LateContext<'_>, ty: Ty<'a>) -> Option<Ty<'a>> {

FILE: clippy_lints/src/methods/expect_fun_call.rs
  function check (line 17) | pub(super) fn check<'tcx>(
  function get_arg_root (line 74) | fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a...
  function contains_call (line 96) | fn contains_call<'a>(cx: &LateContext<'a>, arg: &'a hir::Expr<'a>) -> bo...

FILE: clippy_lints/src/methods/extend_with_drain.rs
  function check (line 11) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'...

FILE: clippy_lints/src/methods/filetype_is_file.rs
  function check (line 10) | pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &h...

FILE: clippy_lints/src/methods/filter_map.rs
  function is_method (line 19) | fn is_method(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symbol)...
  function is_option_filter_map (line 46) | fn is_option_filter_map(cx: &LateContext<'_>, filter_arg: &Expr<'_>, map...
  function is_ok_filter_map (line 49) | fn is_ok_filter_map(cx: &LateContext<'_>, filter_arg: &Expr<'_>, map_arg...
  type OffendingFilterExpr (line 54) | enum OffendingFilterExpr<'tcx> {
  type CalledMethod (line 82) | enum CalledMethod {
  type CheckResult (line 89) | enum CheckResult<'tcx> {
  function check_map_call (line 109) | pub fn check_map_call(
  function hir (line 226) | fn hir(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, filter_param_id: ...
  function is_filter_some_map_unwrap (line 265) | fn is_filter_some_map_unwrap(
  function is_filter_ok_map_unwrap (line 279) | fn is_filter_ok_map_unwrap(cx: &LateContext<'_>, expr: &Expr<'_>, filter...
  function check (line 287) | pub(super) fn check(
  function is_find_or_filter (line 398) | fn is_find_or_filter<'a>(
  function acceptable_methods (line 432) | fn acceptable_methods(method: &PathSegment<'_>) -> bool {

FILE: clippy_lints/src/methods/filter_map_bool_then.rs
  function check (line 16) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>...
  function find_bindings_from_pat (line 77) | fn find_bindings_from_pat(pat: &Pat<'_>) -> FxHashSet<HirId> {
  function can_filter_and_then_move_to_closure (line 93) | fn can_filter_and_then_move_to_closure<'tcx>(

FILE: clippy_lints/src/methods/filter_map_identity.rs
  function is_identity (line 12) | fn is_identity(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<App...
  function check (line 22) | pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_m...

FILE: clippy_lints/src/methods/filter_map_next.rs
  function check (line 12) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/methods/filter_next.rs
  type Direction (line 13) | pub(super) enum Direction {
  function check (line 20) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/methods/flat_map_identity.rs
  function check (line 12) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/methods/flat_map_option.rs
  function check (line 11) | pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<...

FILE: clippy_lints/src/methods/format_collect.rs
  function peel_non_expn_blocks (line 12) | fn peel_non_expn_blocks<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Ex...
  function check (line 19) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, map_arg: &Exp...

FILE: clippy_lints/src/methods/from_iter_instead_of_collect.rs
  function check (line 17) | pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, args: &[Expr<...
  function build_full_type (line 46) | fn build_full_type(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, app: &mut...

FILE: clippy_lints/src/methods/get_first.rs
  function check (line 14) | pub(super) fn check<'tcx>(

FILE: clippy_lints/src/methods/get_last_with_len.rs
  function check 

[
  {
    "path": ".cargo/config.toml",
    "chars": 1237,
    "preview": "[alias]\nbless = \"test --config env.RUSTC_BLESS='1'\"\nuitest = \"test --test compile-test\"\nuibless = \"bless --test compile-"
  },
  {
    "path": ".editorconfig",
    "chars": 439,
    "preview": "# EditorConfig helps developers define and maintain consistent\n# coding styles between different editors and IDEs\n# edit"
  },
  {
    "path": ".gitattributes",
    "chars": 118,
    "preview": "* text=auto eol=lf\n*.rs text eol=lf whitespace=tab-in-indent,trailing-space,tabwidth=4\n*.fixed linguist-language=Rust\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/blank_issue.yml",
    "chars": 1226,
    "preview": "name: Blank Issue\ndescription: Create a blank issue.\nbody:\n  - type: markdown\n    attributes:\n      value: Thank you for"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.yml",
    "chars": 1465,
    "preview": "name: Bug Report\ndescription: Create a bug report for Clippy\nlabels: [\"C-bug\"]\nbody:\n  - type: markdown\n    attributes:\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/config.yml",
    "chars": 181,
    "preview": "blank_issues_enabled: true\ncontact_links:\n  - name: Rust Programming Language Forum\n    url: https://users.rust-lang.org"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/false_negative.yml",
    "chars": 1347,
    "preview": "name: Bug Report (False Negative)\ndescription: Create a bug report about missing warnings from a lint\nlabels: [\"C-bug\", "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/false_positive.yml",
    "chars": 1779,
    "preview": "name: Bug Report (False Positive)\ndescription: Create a bug report about a wrongly emitted lint warning\nlabels: [\"C-bug\""
  },
  {
    "path": ".github/ISSUE_TEMPLATE/ice.yml",
    "chars": 1491,
    "preview": "name: Internal Compiler Error\ndescription: Create a report for an internal compiler error (ICE) in Clippy.\nlabels: [\"C-b"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/new_lint.yml",
    "chars": 2580,
    "preview": "name: New lint suggestion\ndescription: Suggest a new Clippy lint.\nlabels: [\"A-lint\"]\nbody:\n  - type: markdown\n    attrib"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 1321,
    "preview": "Thank you for making Clippy better!\n\nWe're collecting our changelog from pull request descriptions.\nIf your PR only incl"
  },
  {
    "path": ".github/deploy.sh",
    "chars": 1789,
    "preview": "#!/bin/bash\n\nset -ex\n\necho \"Removing the current docs for master\"\nrm -rf out/master/ || exit 0\n\necho \"Making the docs fo"
  },
  {
    "path": ".github/driver.sh",
    "chars": 2540,
    "preview": "#!/bin/bash\n\nset -ex\n\nsysroot=\"$(rustc --print sysroot)\"\ncase $OS in\n    Linux) export LD_LIBRARY_PATH=\"$sysroot/lib\" ;;"
  },
  {
    "path": ".github/workflows/clippy_changelog.yml",
    "chars": 2000,
    "preview": "name: Clippy changelog check\n\non:\n  merge_group:\n  pull_request:\n    types: [opened, reopened, synchronize, edited]\n\ncon"
  },
  {
    "path": ".github/workflows/clippy_dev.yml",
    "chars": 1772,
    "preview": "name: Clippy Dev Test\n\non:\n  merge_group:\n  pull_request:\n\nenv:\n  RUST_BACKTRACE: 1\n  CARGO_INCREMENTAL: 0\n  RUSTFLAGS: "
  },
  {
    "path": ".github/workflows/clippy_mq.yml",
    "chars": 5872,
    "preview": "name: Clippy Test (merge queue)\n\non:\n  merge_group:\n\nenv:\n  RUST_BACKTRACE: 1\n  CARGO_TARGET_DIR: '${{ github.workspace "
  },
  {
    "path": ".github/workflows/clippy_pr.yml",
    "chars": 2612,
    "preview": "name: Clippy Test\n\non:\n  pull_request:\n\nenv:\n  RUST_BACKTRACE: 1\n  CARGO_TARGET_DIR: '${{ github.workspace }}/target'\n  "
  },
  {
    "path": ".github/workflows/deploy.yml",
    "chars": 2170,
    "preview": "name: Deploy\n\non:\n  push:\n    branches:\n      - master\n      - beta\n    tags:\n      - rust-1.**\n\nconcurrency:\n  group: $"
  },
  {
    "path": ".github/workflows/lintcheck.yml",
    "chars": 4831,
    "preview": "name: Lintcheck\n\non:\n  pull_request:\n    paths-ignore:\n      - 'book/**'\n      - 'util/**'\n      - 'tests/**'\n      - '*"
  },
  {
    "path": ".github/workflows/lintcheck_summary.yml",
    "chars": 4035,
    "preview": "name: Lintcheck summary\n\n# The workflow_run event runs in the context of the Clippy repo giving it write\n# access, neede"
  },
  {
    "path": ".github/workflows/remark.yml",
    "chars": 2219,
    "preview": "name: Remark\n\non:\n  merge_group:\n  pull_request:\n\nenv:\n  MDBOOK_VERSION: 0.5.1\n\njobs:\n  remark:\n    runs-on: ubuntu-late"
  },
  {
    "path": ".gitignore",
    "chars": 673,
    "preview": "# Generated by ui-test\nrustc-ice-*\n\n# Used by CI to be able to push:\n/.github/deploy_key\nout\n\n# Compiled files\n*.o\n*.d\n*"
  },
  {
    "path": ".remarkrc",
    "chars": 312,
    "preview": "{\n  \"plugins\": [\n    \"remark-preset-lint-recommended\",\n    \"remark-gfm\",\n    [\"remark-lint-list-item-indent\", false],\n  "
  },
  {
    "path": "CHANGELOG.md",
    "chars": 423328,
    "preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\nSee [Changelog Update](book/src/develo"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 140,
    "preview": "# The Rust Code of Conduct\n\nThe Code of Conduct for this repository [can be found online](https://rust-lang.org/policies"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 13278,
    "preview": "# Contributing to Clippy\n\nHello fellow Rustacean! Great to see your interest in compiler internals and lints!\n\n**First**"
  },
  {
    "path": "COPYRIGHT",
    "chars": 408,
    "preview": "// REUSE-IgnoreStart\n\nCopyright (c) The Rust Project Contributors\n\nLicensed under the Apache License, Version 2.0 <LICEN"
  },
  {
    "path": "Cargo.toml",
    "chars": 1988,
    "preview": "[package]\nname = \"clippy\"\nversion = \"0.1.96\"\ndescription = \"A bunch of helpful lints to avoid common pitfalls in Rust\"\nr"
  },
  {
    "path": "LICENSE-APACHE",
    "chars": 10848,
    "preview": "                              Apache License\n                        Version 2.0, January 2004\n                     http"
  },
  {
    "path": "LICENSE-MIT",
    "chars": 1081,
    "preview": "MIT License\n\nCopyright (c) The Rust Project Contributors\n\nPermission is hereby granted, free of charge, to any\nperson ob"
  },
  {
    "path": "README.md",
    "chars": 10787,
    "preview": "# Clippy\n\n[![License: MIT OR Apache-2.0](https://img.shields.io/crates/l/clippy.svg)](#license)\n\nA collection of lints t"
  },
  {
    "path": "askama.toml",
    "chars": 60,
    "preview": "[general]\ndirs = [\"util/gh-pages/\"]\nwhitespace = \"suppress\"\n"
  },
  {
    "path": "book/README.md",
    "chars": 132,
    "preview": "# Clippy Book\n\nThis is the source for the Clippy Book. See the\n[book](src/development/infrastructure/book.md) for more i"
  },
  {
    "path": "book/book.toml",
    "chars": 573,
    "preview": "[book]\nauthors = [\"The Rust Clippy Developers\"]\nlanguage = \"en\"\ntitle = \"Clippy Documentation\"\n\n[rust]\nedition = \"2024\"\n"
  },
  {
    "path": "book/src/README.md",
    "chars": 3210,
    "preview": "# Clippy\n\n[![License: MIT OR Apache-2.0](https://img.shields.io/crates/l/clippy.svg)](https://github.com/rust-lang/rust-"
  },
  {
    "path": "book/src/SUMMARY.md",
    "chars": 1865,
    "preview": "# Summary\n\n[Introduction](README.md)\n\n- [Installation](installation.md)\n- [Usage](usage.md)\n- [Configuration](configurat"
  },
  {
    "path": "book/src/attribs.md",
    "chars": 1633,
    "preview": "# Attributes for Crate Authors\n\nIn some cases it is possible to extend Clippy coverage to 3rd party libraries.\nTo do thi"
  },
  {
    "path": "book/src/configuration.md",
    "chars": 5146,
    "preview": "# Configuring Clippy\n\n> **Note:** The configuration file is unstable and may be deprecated in the future.\n\nSome lints ca"
  },
  {
    "path": "book/src/continuous_integration/README.md",
    "chars": 891,
    "preview": "# Continuous Integration\n\nIt is recommended to run Clippy on CI with `-Dwarnings`, so that Clippy lints\nprevent CI from "
  },
  {
    "path": "book/src/continuous_integration/github_actions.md",
    "chars": 492,
    "preview": "# GitHub Actions\n\nGitHub hosted runners using the latest stable version of Rust have Clippy pre-installed.\nIt is as simp"
  },
  {
    "path": "book/src/continuous_integration/gitlab.md",
    "chars": 430,
    "preview": "# GitLab CI\n\nYou can add Clippy to GitLab CI by using the latest stable [rust docker image](https://hub.docker.com/_/rus"
  },
  {
    "path": "book/src/continuous_integration/travis.md",
    "chars": 462,
    "preview": "# Travis CI\n\nYou can add Clippy to Travis CI in the same way you use it locally:\n\n```yml\nlanguage: rust\nrust:\n  - stable"
  },
  {
    "path": "book/src/development/README.md",
    "chars": 3005,
    "preview": "# Clippy Development\n\nHello fellow Rustacean! If you made it here, you're probably interested in\nmaking Clippy better by"
  },
  {
    "path": "book/src/development/adding_lints.md",
    "chars": 29657,
    "preview": "# Adding a new lint\n\nYou are probably here because you want to add a new lint to Clippy. If this is\nthe first time you'r"
  },
  {
    "path": "book/src/development/basics.md",
    "chars": 5828,
    "preview": "# Basics for hacking on Clippy\n\nThis document explains the basics for hacking on Clippy. Besides others, this\nincludes h"
  },
  {
    "path": "book/src/development/common_tools_writing_lints.md",
    "chars": 10475,
    "preview": "# Common tools for writing lints\n\nYou may need following tooltips to catch up with common operations.\n\n- [Common tools f"
  },
  {
    "path": "book/src/development/defining_lints.md",
    "chars": 6811,
    "preview": "# Define New Lints\n\nThe first step in the journey of a new lint is the definition\nand registration of the lint in Clippy"
  },
  {
    "path": "book/src/development/emitting_lints.md",
    "chars": 8969,
    "preview": "# Emitting a lint\n\nOnce we have [defined a lint](defining_lints.md), written [UI\ntests](writing_tests.md) and chosen [th"
  },
  {
    "path": "book/src/development/infrastructure/README.md",
    "chars": 922,
    "preview": "# Infrastructure\n\nIn order to deploy Clippy over `rustup`, some infrastructure is necessary. This\nchapter describes the "
  },
  {
    "path": "book/src/development/infrastructure/backport.md",
    "chars": 3865,
    "preview": "# Backport Changes\n\nSometimes it is necessary to backport changes to the beta release of Clippy.\nBackports in Clippy are"
  },
  {
    "path": "book/src/development/infrastructure/benchmarking.md",
    "chars": 1991,
    "preview": "# Benchmarking Clippy\n\nBenchmarking Clippy is similar to using our Lintcheck tool, in fact, it even\nuses the same tool! "
  },
  {
    "path": "book/src/development/infrastructure/book.md",
    "chars": 1461,
    "preview": "# The Clippy Book\n\nThis document explains how to make additions and changes to the Clippy book, the\nguide to Clippy that"
  },
  {
    "path": "book/src/development/infrastructure/changelog_update.md",
    "chars": 4721,
    "preview": "# Changelog Update\n\nIf you want to help with updating the [changelog], you're in the right place.\n\n## When to update\n\nTy"
  },
  {
    "path": "book/src/development/infrastructure/release.md",
    "chars": 4019,
    "preview": "# Release a new Clippy Version\n\n> _NOTE:_ This document is probably only relevant to you, if you're a member of\n> the Cl"
  },
  {
    "path": "book/src/development/infrastructure/sync.md",
    "chars": 5004,
    "preview": "# Syncing changes between Clippy and [`rust-lang/rust`]\n\nClippy currently gets built with a pinned nightly version.\n\nIn "
  },
  {
    "path": "book/src/development/lint_passes.md",
    "chars": 4980,
    "preview": "# Lint passes\n\nBefore working on the logic of a new lint, there is an important decision\nthat every Clippy developer mus"
  },
  {
    "path": "book/src/development/macro_expansions.md",
    "chars": 9457,
    "preview": "# Dealing with macros and expansions\n\nSometimes we might encounter Rust macro expansions while working with Clippy.\nWhil"
  },
  {
    "path": "book/src/development/method_checking.md",
    "chars": 4511,
    "preview": "# Method Checking\n\nIn some scenarios we might want to check for methods when developing\na lint. There are two kinds of q"
  },
  {
    "path": "book/src/development/proposals/README.md",
    "chars": 557,
    "preview": "# Proposals\n\nThis chapter is about accepted proposals for changes that should be worked on in\nor around Clippy in the lo"
  },
  {
    "path": "book/src/development/proposals/roadmap-2021.md",
    "chars": 10050,
    "preview": "# Roadmap 2021\n\n# Summary\n\nThis Roadmap lays out the plans for Clippy in 2021:\n\n- Improving usability and reliability\n- "
  },
  {
    "path": "book/src/development/proposals/syntax-tree-patterns.md",
    "chars": 32646,
    "preview": "- Feature Name: syntax-tree-patterns\n- Start Date: 2019-03-12\n- RFC PR: [#3875](https://github.com/rust-lang/rust-clippy"
  },
  {
    "path": "book/src/development/speedtest.md",
    "chars": 781,
    "preview": "# Speedtest\n`SPEEDTEST` is the tool we use to measure lint's performance, it works by executing the same test several ti"
  },
  {
    "path": "book/src/development/the_team.md",
    "chars": 5053,
    "preview": "# The team\n\nEveryone who contributes to Clippy makes the project what it is. Collaboration\nand discussions are the lifeb"
  },
  {
    "path": "book/src/development/trait_checking.md",
    "chars": 6843,
    "preview": "# Trait Checking\n\nBesides [type checking](type_checking.md), we might want to examine if\na specific type `Ty` implements"
  },
  {
    "path": "book/src/development/type_checking.md",
    "chars": 7136,
    "preview": "# Type Checking\n\nWhen we work on a new lint or improve an existing lint, we might want\nto retrieve the type `Ty` of an e"
  },
  {
    "path": "book/src/development/writing_tests.md",
    "chars": 7707,
    "preview": "# Testing\n\nDeveloping lints for Clippy is a Test-Driven Development (TDD) process because\nour first task before implemen"
  },
  {
    "path": "book/src/installation.md",
    "chars": 698,
    "preview": "# Installation\n\nIf you're using `rustup` to install and manage your Rust toolchains, Clippy is\nusually **already install"
  },
  {
    "path": "book/src/lint_configuration.md",
    "chars": 44011,
    "preview": "<!--\nThis file is generated by `cargo bless --test config-metadata`.\nPlease use that command to update the file and do n"
  },
  {
    "path": "book/src/lints.md",
    "chars": 5226,
    "preview": "# Clippy's Lints\n\nClippy offers a bunch of additional lints, to help its users write more correct\nand idiomatic Rust cod"
  },
  {
    "path": "book/src/usage.md",
    "chars": 5086,
    "preview": "# Usage\n\nThis chapter describes how to use Clippy to get the most out of it. Clippy can\nbe used as a `cargo` subcommand "
  },
  {
    "path": "build.rs",
    "chars": 283,
    "preview": "fn main() {\n    // Forward the profile to the main compilation\n    println!(\"cargo:rustc-env=PROFILE={}\", std::env::var("
  },
  {
    "path": "clippy.toml",
    "chars": 773,
    "preview": "avoid-breaking-exported-api = false\n\ncheck-inconsistent-struct-field-initializers = true\n\nlint-commented-code = true\n\n[["
  },
  {
    "path": "clippy_config/Cargo.toml",
    "chars": 463,
    "preview": "[package]\nname = \"clippy_config\"\nversion = \"0.1.96\"\nedition = \"2024\"\npublish = false\n\n# See more keys and their definiti"
  },
  {
    "path": "clippy_config/src/conf.rs",
    "chars": 53261,
    "preview": "use crate::ClippyConfiguration;\nuse crate::types::{\n    DisallowedPath, DisallowedPathWithoutReplacement, InherentImplLi"
  },
  {
    "path": "clippy_config/src/lib.rs",
    "chars": 613,
    "preview": "#![feature(rustc_private)]\n#![warn(\n    trivial_casts,\n    trivial_numeric_casts,\n    rust_2018_idioms,\n    unused_lifet"
  },
  {
    "path": "clippy_config/src/metadata.rs",
    "chars": 1323,
    "preview": "use itertools::Itertools;\nuse std::fmt;\n\n#[derive(Debug, Clone, Default)]\npub struct ClippyConfiguration {\n    pub name:"
  },
  {
    "path": "clippy_config/src/types.rs",
    "chars": 24292,
    "preview": "use clippy_utils::paths::{PathNS, find_crates, lookup_path};\nuse rustc_data_structures::fx::FxHashMap;\nuse rustc_errors:"
  },
  {
    "path": "clippy_dev/Cargo.toml",
    "chars": 449,
    "preview": "[package]\nname = \"clippy_dev\"\ndescription = \"Clippy developer tooling\"\nversion = \"0.0.1\"\nedition = \"2024\"\n\n[dependencies"
  },
  {
    "path": "clippy_dev/src/deprecate_lint.rs",
    "chars": 7712,
    "preview": "use crate::parse::{DeprecatedLint, Lint, ParseCx, RenamedLint};\nuse crate::update_lints::generate_lint_files;\nuse crate:"
  },
  {
    "path": "clippy_dev/src/dogfood.rs",
    "chars": 960,
    "preview": "use crate::utils::{cargo_cmd, run_exit_on_err};\nuse itertools::Itertools;\n\n/// # Panics\n///\n/// Panics if unable to run "
  },
  {
    "path": "clippy_dev/src/edit_lints.rs",
    "chars": 18301,
    "preview": "use crate::parse::cursor::{self, Capture, Cursor};\nuse crate::parse::{ActiveLint, DeprecatedLint, Lint, LintData, LintNa"
  },
  {
    "path": "clippy_dev/src/fmt.rs",
    "chars": 12174,
    "preview": "use crate::generate::gen_sorted_lints_file;\nuse crate::new_parse_cx;\nuse crate::parse::VecBuf;\nuse crate::utils::{\n    E"
  },
  {
    "path": "clippy_dev/src/generate.rs",
    "chars": 11938,
    "preview": "use crate::parse::cursor::Cursor;\nuse crate::parse::{Lint, LintData, LintPass, VecBuf};\nuse crate::utils::{FileUpdater, "
  },
  {
    "path": "clippy_dev/src/lib.rs",
    "chars": 801,
    "preview": "#![feature(\n    exit_status_error,\n    new_range,\n    new_range_api,\n    os_str_slice,\n    os_string_truncate,\n    patte"
  },
  {
    "path": "clippy_dev/src/lint.rs",
    "chars": 1767,
    "preview": "use crate::utils::{ErrAction, cargo_cmd, expect_action, run_exit_on_err};\nuse std::process::Command;\nuse std::{env, fs};"
  },
  {
    "path": "clippy_dev/src/main.rs",
    "chars": 12584,
    "preview": "#![feature(rustc_private)]\n// warn on lints, that are included in `rust-lang/rust`s bootstrap\n#![warn(rust_2018_idioms, "
  },
  {
    "path": "clippy_dev/src/new_lint.rs",
    "chars": 16633,
    "preview": "use crate::parse::cursor::{self, Capture, Cursor};\nuse crate::utils::Version;\nuse clap::ValueEnum;\nuse indoc::{formatdoc"
  },
  {
    "path": "clippy_dev/src/parse/cursor.rs",
    "chars": 12852,
    "preview": "use core::slice;\nuse rustc_lexer::{self as lex, LiteralKind, Token, TokenKind};\n\n/// A token pattern used for searching "
  },
  {
    "path": "clippy_dev/src/parse.rs",
    "chars": 18645,
    "preview": "pub mod cursor;\n\nuse self::cursor::{Capture, Cursor};\nuse crate::utils::{ErrAction, File, Scoped, expect_action, slice_g"
  },
  {
    "path": "clippy_dev/src/release.rs",
    "chars": 1041,
    "preview": "use crate::utils::{FileUpdater, UpdateStatus, Version, parse_cargo_package};\nuse std::fmt::Write;\n\nstatic CARGO_TOML_FIL"
  },
  {
    "path": "clippy_dev/src/serve.rs",
    "chars": 3736,
    "preview": "use crate::utils::{ErrAction, cargo_cmd, expect_action};\nuse core::fmt::Display;\nuse core::mem;\nuse std::path::Path;\nuse"
  },
  {
    "path": "clippy_dev/src/setup/git_hook.rs",
    "chars": 2885,
    "preview": "use std::fs;\nuse std::path::Path;\n\n/// Rusts setup uses `git rev-parse --git-common-dir` to get the root directory of th"
  },
  {
    "path": "clippy_dev/src/setup/intellij.rs",
    "chars": 6921,
    "preview": "use std::fs;\nuse std::fs::File;\nuse std::io::prelude::*;\nuse std::path::{Path, PathBuf};\n\n// This module takes an absolu"
  },
  {
    "path": "clippy_dev/src/setup/mod.rs",
    "chars": 71,
    "preview": "pub mod git_hook;\npub mod intellij;\npub mod toolchain;\npub mod vscode;\n"
  },
  {
    "path": "clippy_dev/src/setup/toolchain.rs",
    "chars": 2471,
    "preview": "use crate::utils::{cargo_cmd, run_exit_on_err};\nuse std::env::consts::EXE_SUFFIX;\nuse std::env::current_dir;\nuse std::ff"
  },
  {
    "path": "clippy_dev/src/setup/vscode.rs",
    "chars": 2962,
    "preview": "use std::fs;\nuse std::path::Path;\n\nconst VSCODE_DIR: &str = \".vscode\";\nconst TASK_SOURCE_FILE: &str = \"util/etc/vscode-t"
  },
  {
    "path": "clippy_dev/src/sync.rs",
    "chars": 853,
    "preview": "use crate::utils::{FileUpdater, update_text_region_fn};\nuse chrono::offset::Utc;\nuse std::fmt::Write;\n\npub fn update_nig"
  },
  {
    "path": "clippy_dev/src/utils.rs",
    "chars": 20557,
    "preview": "use core::fmt::{self, Display};\nuse core::marker::PhantomData;\nuse core::mem;\nuse core::num::NonZero;\nuse core::ops::{De"
  },
  {
    "path": "clippy_dummy/Cargo.toml",
    "chars": 462,
    "preview": "[package]\nname = \"clippy_dummy\" # rename to clippy before publishing\nversion = \"0.0.303\"\nedition = \"2024\"\nreadme = \"crat"
  },
  {
    "path": "clippy_dummy/PUBLISH.md",
    "chars": 303,
    "preview": "This is a dummy crate to publish to crates.io. It primarily exists to ensure\nthat folks trying to install Clippy from cr"
  },
  {
    "path": "clippy_dummy/build.rs",
    "chars": 876,
    "preview": "use term::color::{GREEN, RED, WHITE};\nuse term::{Attr, Error, Result};\n\nfn main() {\n    if foo().is_err() {\n        epri"
  },
  {
    "path": "clippy_dummy/crates-readme.md",
    "chars": 331,
    "preview": "Installing Clippy via crates.io is deprecated. Please use the following:\n\n```terminal\nrustup component add clippy\n```\n\no"
  },
  {
    "path": "clippy_dummy/src/main.rs",
    "chars": 56,
    "preview": "fn main() {\n    panic!(\"This shouldn't even compile\")\n}\n"
  },
  {
    "path": "clippy_lints/Cargo.toml",
    "chars": 1139,
    "preview": "[package]\nname = \"clippy_lints\"\nversion = \"0.1.96\"\ndescription = \"A bunch of helpful lints to avoid common pitfalls in R"
  },
  {
    "path": "clippy_lints/README.md",
    "chars": 112,
    "preview": "This crate contains Clippy lints. For the main crate, check [GitHub](https://github.com/rust-lang/rust-clippy).\n"
  },
  {
    "path": "clippy_lints/src/absolute_paths.rs",
    "chars": 4552,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint;\nuse clippy_utils::is_from_proc_macro;\nuse rustc_data_"
  },
  {
    "path": "clippy_lints/src/almost_complete_range.rs",
    "chars": 4298,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::msrvs::{self, MsrvStack};\n"
  },
  {
    "path": "clippy_lints/src/approx_const.rs",
    "chars": 5589,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_help;\nuse clippy_utils::msrvs::{self, Msrv};\nuse r"
  },
  {
    "path": "clippy_lints/src/arbitrary_source_item_ordering.rs",
    "chars": 23540,
    "preview": "use clippy_config::Conf;\nuse clippy_config::types::{\n    SourceItemOrderingCategory, SourceItemOrderingModuleItemGroupin"
  },
  {
    "path": "clippy_lints/src/arc_with_non_send_sync.rs",
    "chars": 3851,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::is_from_proc_macro;\nuse clippy_utils::res::MaybeDef"
  },
  {
    "path": "clippy_lints/src/as_conversions.rs",
    "chars": 2686,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::is_from_proc_macro;\nuse rustc_hir::{Expr, ExprKind}"
  },
  {
    "path": "clippy_lints/src/asm_syntax.rs",
    "chars": 4755,
    "preview": "use std::fmt;\n\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions}"
  },
  {
    "path": "clippy_lints/src/assertions_on_constants.rs",
    "chars": 3466,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::consts::{ConstEvalCtxt, Constant};\nuse clippy_utils::diagnostics::span_lint_a"
  },
  {
    "path": "clippy_lints/src/assertions_on_result_states.rs",
    "chars": 4465,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::macros::{find_assert_args, root_macro_call_first_no"
  },
  {
    "path": "clippy_lints/src/assigning_clones.rs",
    "chars": 13763,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::mir::{PossibleBorrowerMap,"
  },
  {
    "path": "clippy_lints/src/async_yields_async.rs",
    "chars": 4399,
    "preview": "use clippy_utils::diagnostics::span_lint_hir_and_then;\nuse clippy_utils::is_expr_async_block;\nuse clippy_utils::source::"
  },
  {
    "path": "clippy_lints/src/attrs/allow_attributes.rs",
    "chars": 883,
    "preview": "use super::ALLOW_ATTRIBUTES;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::is_from_proc_macro;\nus"
  },
  {
    "path": "clippy_lints/src/attrs/allow_attributes_without_reason.rs",
    "chars": 1210,
    "preview": "use super::{ALLOW_ATTRIBUTES_WITHOUT_REASON, Attribute};\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_u"
  },
  {
    "path": "clippy_lints/src/attrs/blanket_clippy_restriction_lints.rs",
    "chars": 1584,
    "preview": "use super::BLANKET_CLIPPY_RESTRICTION_LINTS;\nuse super::utils::extract_clippy_lint;\nuse clippy_utils::diagnostics::{span"
  },
  {
    "path": "clippy_lints/src/attrs/deprecated_cfg_attr.rs",
    "chars": 3239,
    "preview": "use super::{Attribute, DEPRECATED_CFG_ATTR, DEPRECATED_CLIPPY_CFG_ATTR, unnecessary_clippy_cfg};\nuse clippy_utils::diagn"
  },
  {
    "path": "clippy_lints/src/attrs/deprecated_semver.rs",
    "chars": 639,
    "preview": "use super::DEPRECATED_SEMVER;\nuse clippy_utils::diagnostics::span_lint;\nuse clippy_utils::sym;\nuse rustc_ast::{LitKind, "
  },
  {
    "path": "clippy_lints/src/attrs/duplicated_attributes.rs",
    "chars": 2992,
    "preview": "use super::DUPLICATED_ATTRIBUTES;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse itertools::Itertools;\nuse rustc"
  },
  {
    "path": "clippy_lints/src/attrs/inline_always.rs",
    "chars": 658,
    "preview": "use super::INLINE_ALWAYS;\nuse clippy_utils::diagnostics::span_lint;\nuse rustc_hir::attrs::InlineAttr;\nuse rustc_hir::{At"
  },
  {
    "path": "clippy_lints/src/attrs/mixed_attributes_style.rs",
    "chars": 2741,
    "preview": "use super::MIXED_ATTRIBUTES_STYLE;\nuse clippy_utils::diagnostics::span_lint;\nuse rustc_ast::{AttrKind, AttrStyle, Attrib"
  },
  {
    "path": "clippy_lints/src/attrs/mod.rs",
    "chars": 19632,
    "preview": "mod allow_attributes;\nmod allow_attributes_without_reason;\nmod blanket_clippy_restriction_lints;\nmod deprecated_cfg_attr"
  },
  {
    "path": "clippy_lints/src/attrs/non_minimal_cfg.rs",
    "chars": 1978,
    "preview": "use super::{Attribute, NON_MINIMAL_CFG};\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::source::Sp"
  },
  {
    "path": "clippy_lints/src/attrs/repr_attributes.rs",
    "chars": 1446,
    "preview": "use rustc_hir::attrs::ReprAttr;\nuse rustc_hir::{Attribute, find_attr};\nuse rustc_lint::LateContext;\nuse rustc_span::Span"
  },
  {
    "path": "clippy_lints/src/attrs/should_panic_without_expect.rs",
    "chars": 1816,
    "preview": "use super::{Attribute, SHOULD_PANIC_WITHOUT_EXPECT};\nuse clippy_utils::diagnostics::span_lint_and_sugg;\nuse rustc_ast::t"
  },
  {
    "path": "clippy_lints/src/attrs/unnecessary_clippy_cfg.rs",
    "chars": 2388,
    "preview": "use super::{Attribute, UNNECESSARY_CLIPPY_CFG};\nuse clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};"
  },
  {
    "path": "clippy_lints/src/attrs/useless_attribute.rs",
    "chars": 3958,
    "preview": "use super::USELESS_ATTRIBUTE;\nuse super::utils::{is_lint_level, is_word, namespace_and_lint};\nuse clippy_utils::diagnost"
  },
  {
    "path": "clippy_lints/src/attrs/utils.rs",
    "chars": 3381,
    "preview": "use clippy_utils::macros::{is_panic, macro_backtrace};\nuse rustc_ast::{AttrId, MetaItemInner};\nuse rustc_hir::{\n    Bloc"
  },
  {
    "path": "clippy_lints/src/await_holding_invalid.rs",
    "chars": 10165,
    "preview": "use clippy_config::Conf;\nuse clippy_config::types::{DisallowedPathWithoutReplacement, create_disallowed_map};\nuse clippy"
  },
  {
    "path": "clippy_lints/src/blocks_in_conditions.rs",
    "chars": 4927,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::source::snippet_block_with_applicability;\nuse clipp"
  },
  {
    "path": "clippy_lints/src/bool_assert_comparison.rs",
    "chars": 5727,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::macros::{find_assert_eq_args, root_macro_call_first"
  },
  {
    "path": "clippy_lints/src/bool_comparison.rs",
    "chars": 7063,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::sugg::Sugg;\nuse clippy_utils::{is_expn_of, peel_blo"
  },
  {
    "path": "clippy_lints/src/bool_to_int_with_if.rs",
    "chars": 3837,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::sugg::Sugg;\nuse clippy_utils::{higher, is_else_clau"
  },
  {
    "path": "clippy_lints/src/booleans.rs",
    "chars": 24182,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};\nuse clippy_utils::"
  },
  {
    "path": "clippy_lints/src/borrow_deref_ref.rs",
    "chars": 5696,
    "preview": "use crate::reference::DEREF_ADDROF;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::source::SpanRan"
  },
  {
    "path": "clippy_lints/src/box_default.rs",
    "chars": 5074,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::macros::macro_backtrace;\nuse clippy_utils::res::{Ma"
  },
  {
    "path": "clippy_lints/src/byte_char_slices.rs",
    "chars": 2288,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse rustc_ast::ast::{BorrowKind, Expr, ExprKind, Mutability};\nuse rus"
  },
  {
    "path": "clippy_lints/src/cargo/common_metadata.rs",
    "chars": 1981,
    "preview": "use cargo_metadata::Metadata;\nuse clippy_utils::diagnostics::span_lint;\nuse rustc_lint::LateContext;\nuse rustc_span::DUM"
  },
  {
    "path": "clippy_lints/src/cargo/feature_name.rs",
    "chars": 2925,
    "preview": "use cargo_metadata::Metadata;\nuse clippy_utils::diagnostics::span_lint_and_help;\nuse rustc_lint::LateContext;\nuse rustc_"
  },
  {
    "path": "clippy_lints/src/cargo/lint_groups_priority.rs",
    "chars": 5940,
    "preview": "use super::LINT_GROUPS_PRIORITY;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse rustc_data_structures::fx::FxHas"
  },
  {
    "path": "clippy_lints/src/cargo/mod.rs",
    "chars": 9073,
    "preview": "mod common_metadata;\nmod feature_name;\nmod lint_groups_priority;\nmod multiple_crate_versions;\nmod wildcard_dependencies;"
  },
  {
    "path": "clippy_lints/src/cargo/multiple_crate_versions.rs",
    "chars": 2633,
    "preview": "use cargo_metadata::{DependencyKind, Metadata, Node, Package, PackageId};\nuse clippy_utils::diagnostics::span_lint;\nuse "
  },
  {
    "path": "clippy_lints/src/cargo/wildcard_dependencies.rs",
    "chars": 736,
    "preview": "use cargo_metadata::Metadata;\nuse clippy_utils::diagnostics::span_lint;\nuse rustc_lint::LateContext;\nuse rustc_span::DUM"
  },
  {
    "path": "clippy_lints/src/casts/as_pointer_underscore.rs",
    "chars": 655,
    "preview": "use rustc_errors::Applicability;\nuse rustc_lint::LateContext;\nuse rustc_middle::ty::Ty;\n\npub fn check<'tcx>(cx: &LateCon"
  },
  {
    "path": "clippy_lints/src/casts/as_ptr_cast_mut.rs",
    "chars": 1540,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::source::SpanRangeExt;\nuse clippy_utils::sym;\nuse ru"
  },
  {
    "path": "clippy_lints/src/casts/as_underscore.rs",
    "chars": 920,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse rustc_errors::Applicability;\nuse rustc_hir::{Expr, Ty, TyKind};\nu"
  },
  {
    "path": "clippy_lints/src/casts/borrow_as_ptr.rs",
    "chars": 3420,
    "preview": "use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};\nuse clippy_utils::msrvs::Msrv;\nuse clippy_utils"
  },
  {
    "path": "clippy_lints/src/casts/cast_abs_to_unsigned.rs",
    "chars": 1366,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::msrvs::{self, Msrv};\nuse clippy_utils::sugg::Sugg;\n"
  },
  {
    "path": "clippy_lints/src/casts/cast_enum_constructor.rs",
    "chars": 726,
    "preview": "use clippy_utils::diagnostics::span_lint;\nuse rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};\nuse rustc_hir::{Expr, Ex"
  },
  {
    "path": "clippy_lints/src/casts/cast_lossless.rs",
    "chars": 4095,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::is_in_const_context;\nuse clippy_utils::msrvs::{self"
  },
  {
    "path": "clippy_lints/src/casts/cast_nan_to_int.rs",
    "chars": 963,
    "preview": "use super::CAST_NAN_TO_INT;\n\nuse clippy_utils::consts::{ConstEvalCtxt, Constant};\nuse clippy_utils::diagnostics::span_li"
  },
  {
    "path": "clippy_lints/src/casts/cast_possible_truncation.rs",
    "chars": 7726,
    "preview": "use clippy_utils::consts::{ConstEvalCtxt, Constant};\nuse clippy_utils::diagnostics::{span_lint, span_lint_and_then};\nuse"
  },
  {
    "path": "clippy_lints/src/casts/cast_possible_wrap.rs",
    "chars": 4224,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::msrvs::{self, Msrv};\nuse clippy_utils::sugg::Sugg;\n"
  },
  {
    "path": "clippy_lints/src/casts/cast_precision_loss.rs",
    "chars": 1303,
    "preview": "use clippy_utils::diagnostics::span_lint;\nuse clippy_utils::ty::is_isize_or_usize;\nuse rustc_hir::Expr;\nuse rustc_lint::"
  },
  {
    "path": "clippy_lints/src/casts/cast_ptr_alignment.rs",
    "chars": 3554,
    "preview": "use clippy_utils::diagnostics::span_lint;\nuse clippy_utils::ty::is_c_void;\nuse clippy_utils::{get_parent_expr, is_hir_ty"
  },
  {
    "path": "clippy_lints/src/casts/cast_sign_loss.rs",
    "chars": 13873,
    "preview": "use std::convert::Infallible;\nuse std::ops::ControlFlow;\n\nuse clippy_utils::consts::{ConstEvalCtxt, Constant};\nuse clipp"
  },
  {
    "path": "clippy_lints/src/casts/cast_slice_different_sizes.rs",
    "chars": 4999,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::msrvs::{self, Msrv};\nuse clippy_utils::source;\nuse "
  },
  {
    "path": "clippy_lints/src/casts/cast_slice_from_raw_parts.rs",
    "chars": 3990,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::msrvs::{self, Msrv};\nuse clippy_utils::source::snip"
  },
  {
    "path": "clippy_lints/src/casts/char_lit_as_u8.rs",
    "chars": 1305,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::source::snippet_with_applicability;\nuse rustc_ast::"
  },
  {
    "path": "clippy_lints/src/casts/confusing_method_to_numeric_cast.rs",
    "chars": 3013,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::source::snippet_with_applicability;\nuse clippy_util"
  },
  {
    "path": "clippy_lints/src/casts/fn_to_numeric_cast.rs",
    "chars": 1156,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::source::snippet_with_applicability;\nuse rustc_error"
  },
  {
    "path": "clippy_lints/src/casts/fn_to_numeric_cast_any.rs",
    "chars": 1169,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::source::snippet_with_applicability;\nuse rustc_error"
  },
  {
    "path": "clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs",
    "chars": 1186,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::source::snippet_with_applicability;\nuse rustc_error"
  },
  {
    "path": "clippy_lints/src/casts/manual_dangling_ptr.rs",
    "chars": 3095,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::res::{MaybeDef, MaybeResPath};\nuse clippy_utils::so"
  },
  {
    "path": "clippy_lints/src/casts/mod.rs",
    "chars": 32297,
    "preview": "mod as_pointer_underscore;\nmod as_ptr_cast_mut;\nmod as_underscore;\nmod borrow_as_ptr;\nmod cast_abs_to_unsigned;\nmod cast"
  },
  {
    "path": "clippy_lints/src/casts/needless_type_cast.rs",
    "chars": 11606,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::sugg::Sugg;\nuse clippy_utils::visitors::{Descend, f"
  },
  {
    "path": "clippy_lints/src/casts/ptr_as_ptr.rs",
    "chars": 3992,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::is_from_proc_macro;\nuse clippy_utils::msrvs::{self,"
  },
  {
    "path": "clippy_lints/src/casts/ptr_cast_constness.rs",
    "chars": 4350,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::msrvs::{self, Msrv};\nuse clippy_utils::source::snip"
  },
  {
    "path": "clippy_lints/src/casts/ref_as_ptr.rs",
    "chars": 2245,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::source::snippet_with_applicability;\nuse clippy_util"
  },
  {
    "path": "clippy_lints/src/casts/unnecessary_cast.rs",
    "chars": 11402,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::numeric_literal::NumericLiteral;\nuse clippy_utils::"
  },
  {
    "path": "clippy_lints/src/casts/utils.rs",
    "chars": 2745,
    "preview": "use clippy_utils::ty::{EnumValue, read_explicit_enum_value};\nuse rustc_middle::ty::{self, AdtDef, IntTy, Ty, TyCtxt, Uin"
  },
  {
    "path": "clippy_lints/src/casts/zero_ptr.rs",
    "chars": 1374,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::msrvs::{self, Msrv};\nuse clippy_utils::source::Span"
  },
  {
    "path": "clippy_lints/src/cfg_not_test.rs",
    "chars": 2360,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse rustc_ast::attr::data_structures::CfgEntry;\nuse rustc_ast::{AttrI"
  },
  {
    "path": "clippy_lints/src/checked_conversions.rs",
    "chars": 10508,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::msrvs::{self, Msrv};\nuse c"
  },
  {
    "path": "clippy_lints/src/cloned_ref_to_slice_refs.rs",
    "chars": 3228,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::msrvs::{self, Msrv};\nuse c"
  },
  {
    "path": "clippy_lints/src/coerce_container_to_any.rs",
    "chars": 4342,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::sugg::{self, Sugg};\nuse clippy_utils::sym;\nuse rust"
  },
  {
    "path": "clippy_lints/src/cognitive_complexity.rs",
    "chars": 5834,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_help;\nuse clippy_utils::res::MaybeDef;\nuse clippy_"
  },
  {
    "path": "clippy_lints/src/collapsible_if.rs",
    "chars": 14552,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_hir_and_then;\nuse clippy_utils::msrvs::Msrv;\nuse clipp"
  },
  {
    "path": "clippy_lints/src/collection_is_never_read.rs",
    "chars": 6183,
    "preview": "use clippy_utils::diagnostics::span_lint;\nuse clippy_utils::res::{MaybeDef, MaybeResPath};\nuse clippy_utils::visitors::{"
  },
  {
    "path": "clippy_lints/src/comparison_chain.rs",
    "chars": 4543,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::sugg::Sugg;\nuse clippy_utils::ty::implements_trait;"
  },
  {
    "path": "clippy_lints/src/copy_iterator.rs",
    "chars": 1752,
    "preview": "use clippy_utils::diagnostics::span_lint_and_note;\nuse clippy_utils::ty::is_copy;\nuse rustc_hir::{Impl, Item, ItemKind};"
  },
  {
    "path": "clippy_lints/src/crate_in_macro_def.rs",
    "chars": 3803,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse rustc_ast::ast::{AttrKind, Attribute, Item, ItemKind};\nuse rustc_"
  },
  {
    "path": "clippy_lints/src/create_dir.rs",
    "chars": 2384,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::sym;\nuse rustc_errors::Applicability;\nuse rustc_hir"
  },
  {
    "path": "clippy_lints/src/dbg_macro.rs",
    "chars": 7412,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::macros::{MacroCall, macro_"
  },
  {
    "path": "clippy_lints/src/declared_lints.rs",
    "chars": 41555,
    "preview": "// This file was generated by `cargo dev update_lints`.\n// Use that command to update this file and do not edit by hand."
  },
  {
    "path": "clippy_lints/src/default.rs",
    "chars": 12297,
    "preview": "use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};\nuse clippy_utils::source::snippet_with_context;"
  },
  {
    "path": "clippy_lints/src/default_constructed_unit_structs.rs",
    "chars": 3580,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::is_ty_alias;\nuse clippy_utils::source::SpanRangeExt"
  },
  {
    "path": "clippy_lints/src/default_instead_of_iter_empty.rs",
    "chars": 2913,
    "preview": "use clippy_utils::diagnostics::span_lint_and_sugg;\nuse clippy_utils::source::snippet_with_context;\nuse clippy_utils::{la"
  },
  {
    "path": "clippy_lints/src/default_numeric_fallback.rs",
    "chars": 10577,
    "preview": "use clippy_utils::diagnostics::span_lint_hir_and_then;\nuse clippy_utils::numeric_literal;\nuse clippy_utils::source::snip"
  },
  {
    "path": "clippy_lints/src/default_union_representation.rs",
    "chars": 3701,
    "preview": "use clippy_utils::diagnostics::span_lint_and_then;\nuse rustc_hir::attrs::ReprAttr;\nuse rustc_hir::{HirId, Item, ItemKind"
  },
  {
    "path": "clippy_lints/src/deprecated_lints.rs",
    "chars": 9997,
    "preview": "// This file is managed by `cargo dev rename_lint` and `cargo dev deprecate_lint`.\n// Prefer to use those when possible."
  },
  {
    "path": "clippy_lints/src/dereference.rs",
    "chars": 50468,
    "preview": "use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};\nuse clippy_utils::res::MaybeResPath;\nuse cl"
  },
  {
    "path": "clippy_lints/src/derivable_impls.rs",
    "chars": 10011,
    "preview": "use clippy_config::Conf;\nuse clippy_utils::diagnostics::span_lint_and_then;\nuse clippy_utils::msrvs::{self, Msrv};\nuse c"
  },
  {
    "path": "clippy_lints/src/derive/derive_ord_xor_partial_ord.rs",
    "chars": 2277,
    "preview": "use clippy_utils::diagnostics::span_lint_hir_and_then;\nuse clippy_utils::fulfill_or_allowed;\nuse rustc_hir::{self as hir"
  },
  {
    "path": "clippy_lints/src/derive/derive_partial_eq_without_eq.rs",
    "chars": 3554,
    "preview": "use clippy_utils::diagnostics::span_lint_hir_and_then;\nuse clippy_utils::has_non_exhaustive_attr;\nuse clippy_utils::ty::"
  },
  {
    "path": "clippy_lints/src/derive/derived_hash_with_manual_eq.rs",
    "chars": 1902,
    "preview": "use clippy_utils::diagnostics::span_lint_hir_and_then;\nuse rustc_hir::{HirId, TraitRef};\nuse rustc_lint::LateContext;\nus"
  },
  {
    "path": "clippy_lints/src/derive/expl_impl_clone_on_copy.rs",
    "chars": 2607,
    "preview": "use clippy_utils::diagnostics::span_lint_and_help;\nuse clippy_utils::fulfill_or_allowed;\nuse clippy_utils::ty::{implemen"
  }
]

// ... and 4201 more files (download for full content)