From 8e73e2a83486fc83afa574da868aaf389ea9459f Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Thu, 23 Jun 2022 23:09:50 +0900 Subject: [PATCH 01/21] add `[unnecessary_reserve]` lint --- CHANGELOG.md | 1 + clippy_lints/src/lib.register_lints.rs | 600 ++++++++++++++++++++++ clippy_lints/src/lib.register_pedantic.rs | 102 ++++ clippy_lints/src/lib.rs | 2 + clippy_lints/src/unnecessary_reserve.rs | 141 +++++ clippy_utils/src/msrvs.rs | 2 +- clippy_utils/src/paths.rs | 5 + tests/ui/unnecessary_reserve.rs | 95 ++++ tests/ui/unnecessary_reserve.stderr | 40 ++ 9 files changed, 987 insertions(+), 1 deletion(-) create mode 100644 clippy_lints/src/lib.register_lints.rs create mode 100644 clippy_lints/src/lib.register_pedantic.rs create mode 100644 clippy_lints/src/unnecessary_reserve.rs create mode 100644 tests/ui/unnecessary_reserve.rs create mode 100644 tests/ui/unnecessary_reserve.stderr diff --git a/CHANGELOG.md b/CHANGELOG.md index 559b560dde4b..101c2292145a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4992,6 +4992,7 @@ Released 2018-09-13 [`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings [`unnecessary_safety_comment`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_comment [`unnecessary_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_doc +[`unnecessary_reserve`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_reserve [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by [`unnecessary_struct_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_struct_initialization diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs new file mode 100644 index 000000000000..0bc56d55fc19 --- /dev/null +++ b/clippy_lints/src/lib.register_lints.rs @@ -0,0 +1,600 @@ +// This file was generated by `cargo dev update_lints`. +// Use that command to update this file and do not edit by hand. +// Manual edits will be overwritten. + +store.register_lints(&[ + #[cfg(feature = "internal")] + utils::internal_lints::CLIPPY_LINTS_INTERNAL, + #[cfg(feature = "internal")] + utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS, + #[cfg(feature = "internal")] + utils::internal_lints::COMPILER_LINT_FUNCTIONS, + #[cfg(feature = "internal")] + utils::internal_lints::DEFAULT_DEPRECATION_REASON, + #[cfg(feature = "internal")] + utils::internal_lints::DEFAULT_LINT, + #[cfg(feature = "internal")] + utils::internal_lints::IF_CHAIN_STYLE, + #[cfg(feature = "internal")] + utils::internal_lints::INTERNING_DEFINED_SYMBOL, + #[cfg(feature = "internal")] + utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE, + #[cfg(feature = "internal")] + utils::internal_lints::INVALID_PATHS, + #[cfg(feature = "internal")] + utils::internal_lints::LINT_WITHOUT_LINT_PASS, + #[cfg(feature = "internal")] + utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM, + #[cfg(feature = "internal")] + utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE, + #[cfg(feature = "internal")] + utils::internal_lints::MISSING_MSRV_ATTR_IMPL, + #[cfg(feature = "internal")] + utils::internal_lints::OUTER_EXPN_EXPN_DATA, + #[cfg(feature = "internal")] + utils::internal_lints::PRODUCE_ICE, + #[cfg(feature = "internal")] + utils::internal_lints::UNNECESSARY_SYMBOL_STR, + almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE, + approx_const::APPROX_CONSTANT, + as_conversions::AS_CONVERSIONS, + as_underscore::AS_UNDERSCORE, + asm_syntax::INLINE_ASM_X86_ATT_SYNTAX, + asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX, + assertions_on_constants::ASSERTIONS_ON_CONSTANTS, + assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES, + async_yields_async::ASYNC_YIELDS_ASYNC, + attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON, + attrs::BLANKET_CLIPPY_RESTRICTION_LINTS, + attrs::DEPRECATED_CFG_ATTR, + attrs::DEPRECATED_SEMVER, + attrs::EMPTY_LINE_AFTER_OUTER_ATTR, + attrs::INLINE_ALWAYS, + attrs::MISMATCHED_TARGET_OS, + attrs::USELESS_ATTRIBUTE, + await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE, + await_holding_invalid::AWAIT_HOLDING_LOCK, + await_holding_invalid::AWAIT_HOLDING_REFCELL_REF, + blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS, + bool_assert_comparison::BOOL_ASSERT_COMPARISON, + booleans::NONMINIMAL_BOOL, + booleans::OVERLY_COMPLEX_BOOL_EXPR, + borrow_as_ptr::BORROW_AS_PTR, + borrow_deref_ref::BORROW_DEREF_REF, + bytecount::NAIVE_BYTECOUNT, + bytes_count_to_len::BYTES_COUNT_TO_LEN, + cargo::CARGO_COMMON_METADATA, + cargo::MULTIPLE_CRATE_VERSIONS, + cargo::NEGATIVE_FEATURE_NAMES, + cargo::REDUNDANT_FEATURE_NAMES, + cargo::WILDCARD_DEPENDENCIES, + case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS, + casts::CAST_ABS_TO_UNSIGNED, + casts::CAST_ENUM_CONSTRUCTOR, + casts::CAST_ENUM_TRUNCATION, + casts::CAST_LOSSLESS, + casts::CAST_POSSIBLE_TRUNCATION, + casts::CAST_POSSIBLE_WRAP, + casts::CAST_PRECISION_LOSS, + casts::CAST_PTR_ALIGNMENT, + casts::CAST_REF_TO_MUT, + casts::CAST_SIGN_LOSS, + casts::CAST_SLICE_DIFFERENT_SIZES, + casts::CHAR_LIT_AS_U8, + casts::FN_TO_NUMERIC_CAST, + casts::FN_TO_NUMERIC_CAST_ANY, + casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION, + casts::PTR_AS_PTR, + casts::UNNECESSARY_CAST, + checked_conversions::CHECKED_CONVERSIONS, + cognitive_complexity::COGNITIVE_COMPLEXITY, + collapsible_if::COLLAPSIBLE_ELSE_IF, + collapsible_if::COLLAPSIBLE_IF, + comparison_chain::COMPARISON_CHAIN, + copies::BRANCHES_SHARING_CODE, + copies::IFS_SAME_COND, + copies::IF_SAME_THEN_ELSE, + copies::SAME_FUNCTIONS_IN_IF_CONDITION, + copy_iterator::COPY_ITERATOR, + crate_in_macro_def::CRATE_IN_MACRO_DEF, + create_dir::CREATE_DIR, + dbg_macro::DBG_MACRO, + default::DEFAULT_TRAIT_ACCESS, + default::FIELD_REASSIGN_WITH_DEFAULT, + default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY, + default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK, + default_union_representation::DEFAULT_UNION_REPRESENTATION, + dereference::EXPLICIT_AUTO_DEREF, + dereference::EXPLICIT_DEREF_METHODS, + dereference::NEEDLESS_BORROW, + dereference::REF_BINDING_TO_REFERENCE, + derivable_impls::DERIVABLE_IMPLS, + derive::DERIVE_HASH_XOR_EQ, + derive::DERIVE_ORD_XOR_PARTIAL_ORD, + derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ, + derive::EXPL_IMPL_CLONE_ON_COPY, + derive::UNSAFE_DERIVE_DESERIALIZE, + disallowed_methods::DISALLOWED_METHODS, + disallowed_names::DISALLOWED_NAMES, + disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS, + disallowed_types::DISALLOWED_TYPES, + doc::DOC_MARKDOWN, + doc::MISSING_ERRORS_DOC, + doc::MISSING_PANICS_DOC, + doc::MISSING_SAFETY_DOC, + doc::NEEDLESS_DOCTEST_MAIN, + doc_link_with_quotes::DOC_LINK_WITH_QUOTES, + double_parens::DOUBLE_PARENS, + drop_forget_ref::DROP_COPY, + drop_forget_ref::DROP_NON_DROP, + drop_forget_ref::DROP_REF, + drop_forget_ref::FORGET_COPY, + drop_forget_ref::FORGET_NON_DROP, + drop_forget_ref::FORGET_REF, + drop_forget_ref::UNDROPPED_MANUALLY_DROPS, + duplicate_mod::DUPLICATE_MOD, + else_if_without_else::ELSE_IF_WITHOUT_ELSE, + empty_drop::EMPTY_DROP, + empty_enum::EMPTY_ENUM, + empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS, + entry::MAP_ENTRY, + enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT, + enum_variants::ENUM_VARIANT_NAMES, + enum_variants::MODULE_INCEPTION, + enum_variants::MODULE_NAME_REPETITIONS, + equatable_if_let::EQUATABLE_IF_LET, + escape::BOXED_LOCAL, + eta_reduction::REDUNDANT_CLOSURE, + eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS, + excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS, + excessive_bools::STRUCT_EXCESSIVE_BOOLS, + exhaustive_items::EXHAUSTIVE_ENUMS, + exhaustive_items::EXHAUSTIVE_STRUCTS, + exit::EXIT, + explicit_write::EXPLICIT_WRITE, + fallible_impl_from::FALLIBLE_IMPL_FROM, + float_literal::EXCESSIVE_PRECISION, + float_literal::LOSSY_FLOAT_LITERAL, + floating_point_arithmetic::IMPRECISE_FLOPS, + floating_point_arithmetic::SUBOPTIMAL_FLOPS, + format::USELESS_FORMAT, + format_args::FORMAT_IN_FORMAT_ARGS, + format_args::TO_STRING_IN_FORMAT_ARGS, + format_impl::PRINT_IN_FORMAT_IMPL, + format_impl::RECURSIVE_FORMAT_IMPL, + format_push_string::FORMAT_PUSH_STRING, + formatting::POSSIBLE_MISSING_COMMA, + formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING, + formatting::SUSPICIOUS_ELSE_FORMATTING, + formatting::SUSPICIOUS_UNARY_OP_FORMATTING, + from_over_into::FROM_OVER_INTO, + from_str_radix_10::FROM_STR_RADIX_10, + functions::DOUBLE_MUST_USE, + functions::MUST_USE_CANDIDATE, + functions::MUST_USE_UNIT, + functions::NOT_UNSAFE_PTR_ARG_DEREF, + functions::RESULT_UNIT_ERR, + functions::TOO_MANY_ARGUMENTS, + functions::TOO_MANY_LINES, + future_not_send::FUTURE_NOT_SEND, + get_first::GET_FIRST, + if_let_mutex::IF_LET_MUTEX, + if_not_else::IF_NOT_ELSE, + if_then_some_else_none::IF_THEN_SOME_ELSE_NONE, + implicit_hasher::IMPLICIT_HASHER, + implicit_return::IMPLICIT_RETURN, + implicit_saturating_sub::IMPLICIT_SATURATING_SUB, + inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR, + index_refutable_slice::INDEX_REFUTABLE_SLICE, + indexing_slicing::INDEXING_SLICING, + indexing_slicing::OUT_OF_BOUNDS_INDEXING, + infinite_iter::INFINITE_ITER, + infinite_iter::MAYBE_INFINITE_ITER, + inherent_impl::MULTIPLE_INHERENT_IMPL, + inherent_to_string::INHERENT_TO_STRING, + inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY, + init_numbered_fields::INIT_NUMBERED_FIELDS, + inline_fn_without_body::INLINE_FN_WITHOUT_BODY, + int_plus_one::INT_PLUS_ONE, + invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS, + invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED, + items_after_statements::ITEMS_AFTER_STATEMENTS, + iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR, + large_const_arrays::LARGE_CONST_ARRAYS, + large_enum_variant::LARGE_ENUM_VARIANT, + large_include_file::LARGE_INCLUDE_FILE, + large_stack_arrays::LARGE_STACK_ARRAYS, + len_zero::COMPARISON_TO_EMPTY, + len_zero::LEN_WITHOUT_IS_EMPTY, + len_zero::LEN_ZERO, + let_if_seq::USELESS_LET_IF_SEQ, + let_underscore::LET_UNDERSCORE_DROP, + let_underscore::LET_UNDERSCORE_LOCK, + let_underscore::LET_UNDERSCORE_MUST_USE, + lifetimes::EXTRA_UNUSED_LIFETIMES, + lifetimes::NEEDLESS_LIFETIMES, + literal_representation::DECIMAL_LITERAL_REPRESENTATION, + literal_representation::INCONSISTENT_DIGIT_GROUPING, + literal_representation::LARGE_DIGIT_GROUPS, + literal_representation::MISTYPED_LITERAL_SUFFIXES, + literal_representation::UNREADABLE_LITERAL, + literal_representation::UNUSUAL_BYTE_GROUPINGS, + loops::EMPTY_LOOP, + loops::EXPLICIT_COUNTER_LOOP, + loops::EXPLICIT_INTO_ITER_LOOP, + loops::EXPLICIT_ITER_LOOP, + loops::FOR_KV_MAP, + loops::FOR_LOOPS_OVER_FALLIBLES, + loops::ITER_NEXT_LOOP, + loops::MANUAL_FIND, + loops::MANUAL_FLATTEN, + loops::MANUAL_MEMCPY, + loops::MISSING_SPIN_LOOP, + loops::MUT_RANGE_BOUND, + loops::NEEDLESS_COLLECT, + loops::NEEDLESS_RANGE_LOOP, + loops::NEVER_LOOP, + loops::SAME_ITEM_PUSH, + loops::SINGLE_ELEMENT_LOOP, + loops::WHILE_IMMUTABLE_CONDITION, + loops::WHILE_LET_LOOP, + loops::WHILE_LET_ON_ITERATOR, + macro_use::MACRO_USE_IMPORTS, + main_recursion::MAIN_RECURSION, + manual_assert::MANUAL_ASSERT, + manual_async_fn::MANUAL_ASYNC_FN, + manual_bits::MANUAL_BITS, + manual_instant_elapsed::MANUAL_INSTANT_ELAPSED, + manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE, + manual_ok_or::MANUAL_OK_OR, + manual_rem_euclid::MANUAL_REM_EUCLID, + manual_retain::MANUAL_RETAIN, + manual_strip::MANUAL_STRIP, + map_clone::MAP_CLONE, + map_err_ignore::MAP_ERR_IGNORE, + map_unit_fn::OPTION_MAP_UNIT_FN, + map_unit_fn::RESULT_MAP_UNIT_FN, + match_result_ok::MATCH_RESULT_OK, + matches::COLLAPSIBLE_MATCH, + matches::INFALLIBLE_DESTRUCTURING_MATCH, + matches::MANUAL_MAP, + matches::MANUAL_UNWRAP_OR, + matches::MATCH_AS_REF, + matches::MATCH_BOOL, + matches::MATCH_LIKE_MATCHES_MACRO, + matches::MATCH_ON_VEC_ITEMS, + matches::MATCH_OVERLAPPING_ARM, + matches::MATCH_REF_PATS, + matches::MATCH_SAME_ARMS, + matches::MATCH_SINGLE_BINDING, + matches::MATCH_STR_CASE_MISMATCH, + matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS, + matches::MATCH_WILD_ERR_ARM, + matches::NEEDLESS_MATCH, + matches::REDUNDANT_PATTERN_MATCHING, + matches::REST_PAT_IN_FULLY_BOUND_STRUCTS, + matches::SIGNIFICANT_DROP_IN_SCRUTINEE, + matches::SINGLE_MATCH, + matches::SINGLE_MATCH_ELSE, + matches::TRY_ERR, + matches::WILDCARD_ENUM_MATCH_ARM, + matches::WILDCARD_IN_OR_PATTERNS, + mem_forget::MEM_FORGET, + mem_replace::MEM_REPLACE_OPTION_WITH_NONE, + mem_replace::MEM_REPLACE_WITH_DEFAULT, + mem_replace::MEM_REPLACE_WITH_UNINIT, + methods::BIND_INSTEAD_OF_MAP, + methods::BYTES_NTH, + methods::CHARS_LAST_CMP, + methods::CHARS_NEXT_CMP, + methods::CLONED_INSTEAD_OF_COPIED, + methods::CLONE_DOUBLE_REF, + methods::CLONE_ON_COPY, + methods::CLONE_ON_REF_PTR, + methods::ERR_EXPECT, + methods::EXPECT_FUN_CALL, + methods::EXPECT_USED, + methods::EXTEND_WITH_DRAIN, + methods::FILETYPE_IS_FILE, + methods::FILTER_MAP_IDENTITY, + methods::FILTER_MAP_NEXT, + methods::FILTER_NEXT, + methods::FLAT_MAP_IDENTITY, + methods::FLAT_MAP_OPTION, + methods::FROM_ITER_INSTEAD_OF_COLLECT, + methods::GET_LAST_WITH_LEN, + methods::GET_UNWRAP, + methods::IMPLICIT_CLONE, + methods::INEFFICIENT_TO_STRING, + methods::INSPECT_FOR_EACH, + methods::INTO_ITER_ON_REF, + methods::IS_DIGIT_ASCII_RADIX, + methods::ITERATOR_STEP_BY_ZERO, + methods::ITER_CLONED_COLLECT, + methods::ITER_COUNT, + methods::ITER_NEXT_SLICE, + methods::ITER_NTH, + methods::ITER_NTH_ZERO, + methods::ITER_OVEREAGER_CLONED, + methods::ITER_SKIP_NEXT, + methods::ITER_WITH_DRAIN, + methods::MANUAL_FILTER_MAP, + methods::MANUAL_FIND_MAP, + methods::MANUAL_SATURATING_ARITHMETIC, + methods::MANUAL_SPLIT_ONCE, + methods::MANUAL_STR_REPEAT, + methods::MAP_COLLECT_RESULT_UNIT, + methods::MAP_FLATTEN, + methods::MAP_IDENTITY, + methods::MAP_UNWRAP_OR, + methods::NEEDLESS_OPTION_AS_DEREF, + methods::NEEDLESS_OPTION_TAKE, + methods::NEEDLESS_SPLITN, + methods::NEW_RET_NO_SELF, + methods::NO_EFFECT_REPLACE, + methods::OBFUSCATED_IF_ELSE, + methods::OK_EXPECT, + methods::OPTION_AS_REF_DEREF, + methods::OPTION_FILTER_MAP, + methods::OPTION_MAP_OR_NONE, + methods::OR_FUN_CALL, + methods::OR_THEN_UNWRAP, + methods::RESULT_MAP_OR_INTO_OPTION, + methods::SEARCH_IS_SOME, + methods::SHOULD_IMPLEMENT_TRAIT, + methods::SINGLE_CHAR_ADD_STR, + methods::SINGLE_CHAR_PATTERN, + methods::SKIP_WHILE_NEXT, + methods::STRING_EXTEND_CHARS, + methods::SUSPICIOUS_MAP, + methods::SUSPICIOUS_SPLITN, + methods::UNINIT_ASSUMED_INIT, + methods::UNNECESSARY_FILTER_MAP, + methods::UNNECESSARY_FIND_MAP, + methods::UNNECESSARY_FOLD, + methods::UNNECESSARY_JOIN, + methods::UNNECESSARY_LAZY_EVALUATIONS, + methods::UNNECESSARY_TO_OWNED, + methods::UNWRAP_OR_ELSE_DEFAULT, + methods::UNWRAP_USED, + methods::USELESS_ASREF, + methods::WRONG_SELF_CONVENTION, + methods::ZST_OFFSET, + minmax::MIN_MAX, + misc::SHORT_CIRCUIT_STATEMENT, + misc::TOPLEVEL_REF_ARG, + misc::USED_UNDERSCORE_BINDING, + misc::ZERO_PTR, + misc_early::BUILTIN_TYPE_SHADOW, + misc_early::DOUBLE_NEG, + misc_early::DUPLICATE_UNDERSCORE_ARGUMENT, + misc_early::MIXED_CASE_HEX_LITERALS, + misc_early::REDUNDANT_PATTERN, + misc_early::SEPARATED_LITERAL_SUFFIX, + misc_early::UNNEEDED_FIELD_PATTERN, + misc_early::UNNEEDED_WILDCARD_PATTERN, + misc_early::UNSEPARATED_LITERAL_SUFFIX, + misc_early::ZERO_PREFIXED_LITERAL, + mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER, + missing_const_for_fn::MISSING_CONST_FOR_FN, + missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS, + missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES, + missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS, + mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION, + mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION, + module_style::MOD_MODULE_FILES, + module_style::SELF_NAMED_MODULE_FILES, + mut_key::MUTABLE_KEY_TYPE, + mut_mut::MUT_MUT, + mut_mutex_lock::MUT_MUTEX_LOCK, + mut_reference::UNNECESSARY_MUT_PASSED, + mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL, + mutex_atomic::MUTEX_ATOMIC, + mutex_atomic::MUTEX_INTEGER, + needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE, + needless_bool::BOOL_COMPARISON, + needless_bool::NEEDLESS_BOOL, + needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE, + needless_continue::NEEDLESS_CONTINUE, + needless_for_each::NEEDLESS_FOR_EACH, + needless_late_init::NEEDLESS_LATE_INIT, + needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS, + needless_pass_by_value::NEEDLESS_PASS_BY_VALUE, + needless_question_mark::NEEDLESS_QUESTION_MARK, + needless_update::NEEDLESS_UPDATE, + neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD, + neg_multiply::NEG_MULTIPLY, + new_without_default::NEW_WITHOUT_DEFAULT, + no_effect::NO_EFFECT, + no_effect::NO_EFFECT_UNDERSCORE_BINDING, + no_effect::UNNECESSARY_OPERATION, + non_copy_const::BORROW_INTERIOR_MUTABLE_CONST, + non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST, + non_expressive_names::JUST_UNDERSCORES_AND_DIGITS, + non_expressive_names::MANY_SINGLE_CHAR_NAMES, + non_expressive_names::SIMILAR_NAMES, + non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS, + non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY, + nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES, + octal_escapes::OCTAL_ESCAPES, + only_used_in_recursion::ONLY_USED_IN_RECURSION, + open_options::NONSENSICAL_OPEN_OPTIONS, + operators::ABSURD_EXTREME_COMPARISONS, + operators::ARITHMETIC, + operators::ASSIGN_OP_PATTERN, + operators::BAD_BIT_MASK, + operators::CMP_NAN, + operators::CMP_OWNED, + operators::DOUBLE_COMPARISONS, + operators::DURATION_SUBSEC, + operators::EQ_OP, + operators::ERASING_OP, + operators::FLOAT_ARITHMETIC, + operators::FLOAT_CMP, + operators::FLOAT_CMP_CONST, + operators::FLOAT_EQUALITY_WITHOUT_ABS, + operators::IDENTITY_OP, + operators::INEFFECTIVE_BIT_MASK, + operators::INTEGER_ARITHMETIC, + operators::INTEGER_DIVISION, + operators::MISREFACTORED_ASSIGN_OP, + operators::MODULO_ARITHMETIC, + operators::MODULO_ONE, + operators::NEEDLESS_BITWISE_BOOL, + operators::OP_REF, + operators::PTR_EQ, + operators::SELF_ASSIGNMENT, + operators::VERBOSE_BIT_MASK, + option_env_unwrap::OPTION_ENV_UNWRAP, + option_if_let_else::OPTION_IF_LET_ELSE, + overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL, + panic_in_result_fn::PANIC_IN_RESULT_FN, + panic_unimplemented::PANIC, + panic_unimplemented::TODO, + panic_unimplemented::UNIMPLEMENTED, + panic_unimplemented::UNREACHABLE, + partialeq_ne_impl::PARTIALEQ_NE_IMPL, + partialeq_to_none::PARTIALEQ_TO_NONE, + pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE, + pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF, + path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE, + pattern_type_mismatch::PATTERN_TYPE_MISMATCH, + precedence::PRECEDENCE, + ptr::CMP_NULL, + ptr::INVALID_NULL_PTR_USAGE, + ptr::MUT_FROM_REF, + ptr::PTR_ARG, + ptr_offset_with_cast::PTR_OFFSET_WITH_CAST, + pub_use::PUB_USE, + question_mark::QUESTION_MARK, + ranges::MANUAL_RANGE_CONTAINS, + ranges::RANGE_MINUS_ONE, + ranges::RANGE_PLUS_ONE, + ranges::RANGE_ZIP_WITH_LEN, + ranges::REVERSED_EMPTY_RANGES, + rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT, + read_zero_byte_vec::READ_ZERO_BYTE_VEC, + redundant_clone::REDUNDANT_CLONE, + redundant_closure_call::REDUNDANT_CLOSURE_CALL, + redundant_else::REDUNDANT_ELSE, + redundant_field_names::REDUNDANT_FIELD_NAMES, + redundant_pub_crate::REDUNDANT_PUB_CRATE, + redundant_slicing::DEREF_BY_SLICING, + redundant_slicing::REDUNDANT_SLICING, + redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES, + ref_option_ref::REF_OPTION_REF, + reference::DEREF_ADDROF, + regex::INVALID_REGEX, + regex::TRIVIAL_REGEX, + repeat_once::REPEAT_ONCE, + return_self_not_must_use::RETURN_SELF_NOT_MUST_USE, + returns::LET_AND_RETURN, + returns::NEEDLESS_RETURN, + same_name_method::SAME_NAME_METHOD, + self_named_constructors::SELF_NAMED_CONSTRUCTORS, + semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED, + serde_api::SERDE_API_MISUSE, + shadow::SHADOW_REUSE, + shadow::SHADOW_SAME, + shadow::SHADOW_UNRELATED, + single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES, + single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS, + size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT, + slow_vector_initialization::SLOW_VECTOR_INITIALIZATION, + stable_sort_primitive::STABLE_SORT_PRIMITIVE, + std_instead_of_core::ALLOC_INSTEAD_OF_CORE, + std_instead_of_core::STD_INSTEAD_OF_ALLOC, + std_instead_of_core::STD_INSTEAD_OF_CORE, + strings::STRING_ADD, + strings::STRING_ADD_ASSIGN, + strings::STRING_FROM_UTF8_AS_BYTES, + strings::STRING_LIT_AS_BYTES, + strings::STRING_SLICE, + strings::STRING_TO_STRING, + strings::STR_TO_STRING, + strings::TRIM_SPLIT_WHITESPACE, + strlen_on_c_strings::STRLEN_ON_C_STRINGS, + suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS, + suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL, + suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL, + swap::ALMOST_SWAPPED, + swap::MANUAL_SWAP, + swap_ptr_to_ref::SWAP_PTR_TO_REF, + tabs_in_doc_comments::TABS_IN_DOC_COMMENTS, + temporary_assignment::TEMPORARY_ASSIGNMENT, + to_digit_is_some::TO_DIGIT_IS_SOME, + trailing_empty_array::TRAILING_EMPTY_ARRAY, + trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS, + trait_bounds::TYPE_REPETITION_IN_BOUNDS, + transmute::CROSSPOINTER_TRANSMUTE, + transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS, + transmute::TRANSMUTE_BYTES_TO_STR, + transmute::TRANSMUTE_FLOAT_TO_INT, + transmute::TRANSMUTE_INT_TO_BOOL, + transmute::TRANSMUTE_INT_TO_CHAR, + transmute::TRANSMUTE_INT_TO_FLOAT, + transmute::TRANSMUTE_NUM_TO_BYTES, + transmute::TRANSMUTE_PTR_TO_PTR, + transmute::TRANSMUTE_PTR_TO_REF, + transmute::TRANSMUTE_UNDEFINED_REPR, + transmute::UNSOUND_COLLECTION_TRANSMUTE, + transmute::USELESS_TRANSMUTE, + transmute::WRONG_TRANSMUTE, + transmuting_null::TRANSMUTING_NULL, + types::BORROWED_BOX, + types::BOX_COLLECTION, + types::LINKEDLIST, + types::OPTION_OPTION, + types::RC_BUFFER, + types::RC_MUTEX, + types::REDUNDANT_ALLOCATION, + types::TYPE_COMPLEXITY, + types::VEC_BOX, + undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS, + unicode::INVISIBLE_CHARACTERS, + unicode::NON_ASCII_LITERAL, + unicode::UNICODE_NOT_NFC, + uninit_vec::UNINIT_VEC, + unit_hash::UNIT_HASH, + unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD, + unit_types::LET_UNIT_VALUE, + unit_types::UNIT_ARG, + unit_types::UNIT_CMP, + unnamed_address::FN_ADDRESS_COMPARISONS, + unnamed_address::VTABLE_ADDRESS_COMPARISONS, + unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS, + unnecessary_reserve::UNNECESSARY_RESERVE, + unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS, + unnecessary_sort_by::UNNECESSARY_SORT_BY, + unnecessary_wraps::UNNECESSARY_WRAPS, + unnested_or_patterns::UNNESTED_OR_PATTERNS, + unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME, + unused_async::UNUSED_ASYNC, + unused_io_amount::UNUSED_IO_AMOUNT, + unused_rounding::UNUSED_ROUNDING, + unused_self::UNUSED_SELF, + unused_unit::UNUSED_UNIT, + unwrap::PANICKING_UNWRAP, + unwrap::UNNECESSARY_UNWRAP, + unwrap_in_result::UNWRAP_IN_RESULT, + upper_case_acronyms::UPPER_CASE_ACRONYMS, + use_self::USE_SELF, + useless_conversion::USELESS_CONVERSION, + vec::USELESS_VEC, + vec_init_then_push::VEC_INIT_THEN_PUSH, + vec_resize_to_zero::VEC_RESIZE_TO_ZERO, + verbose_file_reads::VERBOSE_FILE_READS, + wildcard_imports::ENUM_GLOB_USE, + wildcard_imports::WILDCARD_IMPORTS, + write::PRINTLN_EMPTY_STRING, + write::PRINT_LITERAL, + write::PRINT_STDERR, + write::PRINT_STDOUT, + write::PRINT_WITH_NEWLINE, + write::USE_DEBUG, + write::WRITELN_EMPTY_STRING, + write::WRITE_LITERAL, + write::WRITE_WITH_NEWLINE, + zero_div_zero::ZERO_DIVIDED_BY_ZERO, + zero_sized_map_values::ZERO_SIZED_MAP_VALUES, +]) diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs new file mode 100644 index 000000000000..69fbc625983b --- /dev/null +++ b/clippy_lints/src/lib.register_pedantic.rs @@ -0,0 +1,102 @@ +// This file was generated by `cargo dev update_lints`. +// Use that command to update this file and do not edit by hand. +// Manual edits will be overwritten. + +store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![ + LintId::of(attrs::INLINE_ALWAYS), + LintId::of(borrow_as_ptr::BORROW_AS_PTR), + LintId::of(bytecount::NAIVE_BYTECOUNT), + LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS), + LintId::of(casts::CAST_LOSSLESS), + LintId::of(casts::CAST_POSSIBLE_TRUNCATION), + LintId::of(casts::CAST_POSSIBLE_WRAP), + LintId::of(casts::CAST_PRECISION_LOSS), + LintId::of(casts::CAST_PTR_ALIGNMENT), + LintId::of(casts::CAST_SIGN_LOSS), + LintId::of(casts::PTR_AS_PTR), + LintId::of(checked_conversions::CHECKED_CONVERSIONS), + LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION), + LintId::of(copy_iterator::COPY_ITERATOR), + LintId::of(default::DEFAULT_TRAIT_ACCESS), + LintId::of(dereference::EXPLICIT_DEREF_METHODS), + LintId::of(dereference::REF_BINDING_TO_REFERENCE), + LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY), + LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE), + LintId::of(doc::DOC_MARKDOWN), + LintId::of(doc::MISSING_ERRORS_DOC), + LintId::of(doc::MISSING_PANICS_DOC), + LintId::of(doc_link_with_quotes::DOC_LINK_WITH_QUOTES), + LintId::of(empty_enum::EMPTY_ENUM), + LintId::of(enum_variants::MODULE_NAME_REPETITIONS), + LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS), + LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS), + LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS), + LintId::of(functions::MUST_USE_CANDIDATE), + LintId::of(functions::TOO_MANY_LINES), + LintId::of(if_not_else::IF_NOT_ELSE), + LintId::of(implicit_hasher::IMPLICIT_HASHER), + LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB), + LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR), + LintId::of(infinite_iter::MAYBE_INFINITE_ITER), + LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS), + LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS), + LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR), + LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS), + LintId::of(let_underscore::LET_UNDERSCORE_DROP), + LintId::of(literal_representation::LARGE_DIGIT_GROUPS), + LintId::of(literal_representation::UNREADABLE_LITERAL), + LintId::of(loops::EXPLICIT_INTO_ITER_LOOP), + LintId::of(loops::EXPLICIT_ITER_LOOP), + LintId::of(macro_use::MACRO_USE_IMPORTS), + LintId::of(manual_assert::MANUAL_ASSERT), + LintId::of(manual_instant_elapsed::MANUAL_INSTANT_ELAPSED), + LintId::of(manual_ok_or::MANUAL_OK_OR), + LintId::of(matches::MATCH_BOOL), + LintId::of(matches::MATCH_ON_VEC_ITEMS), + LintId::of(matches::MATCH_SAME_ARMS), + LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS), + LintId::of(matches::MATCH_WILD_ERR_ARM), + LintId::of(matches::SINGLE_MATCH_ELSE), + LintId::of(methods::CLONED_INSTEAD_OF_COPIED), + LintId::of(methods::FILTER_MAP_NEXT), + LintId::of(methods::FLAT_MAP_OPTION), + LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT), + LintId::of(methods::IMPLICIT_CLONE), + LintId::of(methods::INEFFICIENT_TO_STRING), + LintId::of(methods::MAP_UNWRAP_OR), + LintId::of(methods::UNNECESSARY_JOIN), + LintId::of(misc::USED_UNDERSCORE_BINDING), + LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER), + LintId::of(mut_mut::MUT_MUT), + LintId::of(needless_continue::NEEDLESS_CONTINUE), + LintId::of(needless_for_each::NEEDLESS_FOR_EACH), + LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE), + LintId::of(no_effect::NO_EFFECT_UNDERSCORE_BINDING), + LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES), + LintId::of(non_expressive_names::SIMILAR_NAMES), + LintId::of(operators::FLOAT_CMP), + LintId::of(operators::NEEDLESS_BITWISE_BOOL), + LintId::of(operators::VERBOSE_BIT_MASK), + LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE), + LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF), + LintId::of(ranges::RANGE_MINUS_ONE), + LintId::of(ranges::RANGE_PLUS_ONE), + LintId::of(redundant_else::REDUNDANT_ELSE), + LintId::of(ref_option_ref::REF_OPTION_REF), + LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE), + LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED), + LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE), + LintId::of(strings::STRING_ADD_ASSIGN), + LintId::of(transmute::TRANSMUTE_PTR_TO_PTR), + LintId::of(types::LINKEDLIST), + LintId::of(types::OPTION_OPTION), + LintId::of(unicode::UNICODE_NOT_NFC), + LintId::of(unnecessary_reserve::UNNECESSARY_RESERVE), + LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS), + LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS), + LintId::of(unused_async::UNUSED_ASYNC), + LintId::of(unused_self::UNUSED_SELF), + LintId::of(wildcard_imports::ENUM_GLOB_USE), + LintId::of(wildcard_imports::WILDCARD_IMPORTS), + LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES), +]) diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index b0ec14855e71..a429d4bc4034 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -305,6 +305,7 @@ mod unit_types; mod unnamed_address; mod unnecessary_box_returns; mod unnecessary_owned_empty_strings; +mod unnecessary_reserve; mod unnecessary_self_imports; mod unnecessary_struct_initialization; mod unnecessary_wraps; @@ -959,6 +960,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule)); store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation)); store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments)); + store.register_late_pass(move || Box::new(unnecessary_reserve::UnnecessaryReserve::new(msrv))); // add lints here, do not remove this comment, it's used in `new_lint` } diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs new file mode 100644 index 000000000000..b1995e9e2814 --- /dev/null +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -0,0 +1,141 @@ +use clippy_utils::diagnostics::span_lint; +use clippy_utils::{match_def_path, meets_msrv, msrvs, paths, visitors::expr_visitor_no_bodies}; +use rustc_hir::{intravisit::Visitor, Block, ExprKind, QPath, StmtKind}; +use rustc_lint::{LateContext, LateLintPass}; +use rustc_middle::ty; +use rustc_semver::RustcVersion; +use rustc_session::{declare_tool_lint, impl_lint_pass}; +use rustc_span::sym; + +declare_clippy_lint! { + /// ### What it does + /// This lint checks for `reserve` before calling the `extend` method. + /// ### Why is this bad? + /// vec::reserve method before vec::extend is no longer makes sense in rustc version >= 1.62 + /// ### Example + /// ```rust + /// let mut vec: Vec = vec![]; + /// let array: &[usize] = &[1, 2]; + /// vec.reserve(array.len()); + /// vec.extend(array); + /// ``` + /// Use instead: + /// ```rust + /// let mut vec: Vec = vec![]; + /// let array: &[usize] = &[1, 2]; + /// vec.extend(array); + /// ``` + #[clippy::version = "1.64.0"] + pub UNNECESSARY_RESERVE, + pedantic, + "`reserve` method before `extend` is no longer makes sense in rustc version >= 1.62" +} + +pub struct UnnecessaryReserve { + msrv: Option, +} + +impl UnnecessaryReserve { + #[must_use] + pub fn new(msrv: Option) -> Self { + Self { msrv } + } +} + +impl_lint_pass!(UnnecessaryReserve => [UNNECESSARY_RESERVE]); + +impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { + fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) { + if !meets_msrv(self.msrv, msrvs::UNNECESSARY_RESERVE) { + return; + } + + for (idx, stmt) in block.stmts.iter().enumerate() { + if let StmtKind::Semi(semi_expr) = stmt.kind + && let ExprKind::MethodCall(_, [struct_calling_on, _], _) = semi_expr.kind + && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(semi_expr.hir_id) + && (match_def_path(cx, expr_def_id, &paths::VEC_RESERVE) || + match_def_path(cx, expr_def_id, &paths::VEC_DEQUE_RESERVE)) + && acceptable_type(cx, struct_calling_on) + && let Some(next_stmt_span) = check_extend_method(cx, block, idx, struct_calling_on) + && !next_stmt_span.from_expansion() + { + span_lint( + cx, + UNNECESSARY_RESERVE, + next_stmt_span, + "this `reserve` no longer makes sense in rustc version >= 1.62", + ); + } + } + } + + extract_msrv_attr!(LateContext); +} + +#[must_use] +fn acceptable_type(cx: &LateContext<'_>, struct_calling_on: &rustc_hir::Expr<'_>) -> bool { + let acceptable_types = [sym::Vec, sym::VecDeque]; + acceptable_types.iter().any(|&acceptable_ty| { + match cx.typeck_results().expr_ty(struct_calling_on).peel_refs().kind() { + ty::Adt(def, _) => cx.tcx.is_diagnostic_item(acceptable_ty, def.did()), + _ => false, + } + }) +} + +#[must_use] +fn check_extend_method( + cx: &LateContext<'_>, + block: &Block<'_>, + idx: usize, + struct_expr: &rustc_hir::Expr<'_>, +) -> Option { + let mut read_found = false; + let next_stmt_span; + + let mut visitor = expr_visitor_no_bodies(|expr| { + if let ExprKind::MethodCall(_, [struct_calling_on, _], _) = expr.kind + && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && match_def_path(cx, expr_def_id, &paths::ITER_EXTEND) + && acceptable_type(cx, struct_calling_on) + && equal_ident(struct_calling_on, struct_expr) + { + read_found = true; + } + !read_found + }); + + if idx == block.stmts.len() - 1 { + if let Some(e) = block.expr { + visitor.visit_expr(e); + next_stmt_span = e.span; + } else { + return None; + } + } else { + let next_stmt = &block.stmts[idx + 1]; + visitor.visit_stmt(next_stmt); + next_stmt_span = next_stmt.span; + } + drop(visitor); + + if read_found { + return Some(next_stmt_span); + } + + None +} + +#[must_use] +fn equal_ident(left: &rustc_hir::Expr<'_>, right: &rustc_hir::Expr<'_>) -> bool { + fn ident_name(expr: &rustc_hir::Expr<'_>) -> Option { + if let ExprKind::Path(QPath::Resolved(None, inner_path)) = expr.kind + && let [inner_seg] = inner_path.segments { + return Some(inner_seg.ident.name); + } + None + } + + ident_name(left) == ident_name(right) +} diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs index e05de2dc99c0..e94c0b00a653 100644 --- a/clippy_utils/src/msrvs.rs +++ b/clippy_utils/src/msrvs.rs @@ -21,7 +21,7 @@ macro_rules! msrv_aliases { msrv_aliases! { 1,68,0 { PATH_MAIN_SEPARATOR_STR } 1,65,0 { LET_ELSE } - 1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE } + 1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, UNNECESSARY_RESERVE } 1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY } 1,55,0 { SEEK_REWIND } 1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR } diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs index 9be2d0eae80a..664b7e772cfd 100644 --- a/clippy_utils/src/paths.rs +++ b/clippy_utils/src/paths.rs @@ -49,6 +49,9 @@ pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"]; pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"]; pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"]; pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"]; +pub const ITER_EXTEND: [&str; 6] = ["core", "iter", "traits", "collect", "Extend", "extend"]; +pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"]; +#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"]; #[cfg(feature = "internal")] pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"]; @@ -154,6 +157,8 @@ pub const VEC_DEQUE_ITER: [&str; 5] = ["alloc", "collections", "vec_deque", "Vec pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"]; pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"]; pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"]; +pub const VEC_RESERVE: [&str; 4] = ["alloc", "vec", "Vec", "reserve"]; +pub const VEC_DEQUE_RESERVE: [&str; 5] = ["alloc", "collections", "vec_deque", "VecDeque", "reserve"]; pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"]; pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"]; pub const PTR_NON_NULL: [&str; 4] = ["core", "ptr", "non_null", "NonNull"]; diff --git a/tests/ui/unnecessary_reserve.rs b/tests/ui/unnecessary_reserve.rs new file mode 100644 index 000000000000..372c7f434ea5 --- /dev/null +++ b/tests/ui/unnecessary_reserve.rs @@ -0,0 +1,95 @@ +#![warn(clippy::unnecessary_reserve)] +#![feature(custom_inner_attributes)] + +use std::collections::HashMap; +use std::collections::VecDeque; + +fn main() { + vec_reserve(); + vec_deque_reserve(); + hash_map_reserve(); + msrv_1_62(); +} + +fn vec_reserve() { + let mut vec: Vec = vec![]; + let array: &[usize] = &[1, 2]; + + // do lint + vec.reserve(1); + vec.extend([1]); + + // do lint + vec.reserve(array.len()); + vec.extend(array); + + // do lint + { + vec.reserve(1); + vec.extend([1]) + }; + + // do not lint + vec.reserve(array.len()); + vec.push(1); + vec.extend(array); + + // do not lint + let mut other_vec: Vec = vec![]; + other_vec.reserve(1); + vec.extend([1]) +} + +fn vec_deque_reserve() { + let mut vec_deque: VecDeque = [1].into(); + let array: &[usize] = &[1, 2]; + + // do lint + vec_deque.reserve(1); + vec_deque.extend([1]); + + // do lint + vec_deque.reserve(array.len()); + vec_deque.extend(array); + + // do lint + { + vec_deque.reserve(1); + vec_deque.extend([1]) + }; + + // do not lint + vec_deque.reserve(array.len() + 1); + vec_deque.push_back(1); + vec_deque.extend(array); + + // do not lint + let mut other_vec_deque: VecDeque = [1].into(); + other_vec_deque.reserve(1); + vec_deque.extend([1]) +} + +fn hash_map_reserve() { + let mut map: HashMap = HashMap::new(); + let mut other_map: HashMap = HashMap::new(); + // do not lint + map.reserve(other_map.len()); + map.extend(other_map); +} + +fn msrv_1_62() { + #![clippy::msrv = "1.61"] + let mut vec: Vec = vec![]; + let array: &[usize] = &[1, 2]; + + // do not lint + vec.reserve(1); + vec.extend([1]); + + let mut vec_deque: VecDeque = [1].into(); + let array: &[usize] = &[1, 2]; + + // do not lint + vec_deque.reserve(1); + vec_deque.extend([1]); +} diff --git a/tests/ui/unnecessary_reserve.stderr b/tests/ui/unnecessary_reserve.stderr new file mode 100644 index 000000000000..b7a76bf5f782 --- /dev/null +++ b/tests/ui/unnecessary_reserve.stderr @@ -0,0 +1,40 @@ +error: this `reserve` no longer makes sense in rustc version >= 1.62 + --> $DIR/unnecessary_reserve.rs:20:5 + | +LL | vec.extend([1]); + | ^^^^^^^^^^^^^^^^ + | + = note: `-D clippy::unnecessary-reserve` implied by `-D warnings` + +error: this `reserve` no longer makes sense in rustc version >= 1.62 + --> $DIR/unnecessary_reserve.rs:24:5 + | +LL | vec.extend(array); + | ^^^^^^^^^^^^^^^^^^ + +error: this `reserve` no longer makes sense in rustc version >= 1.62 + --> $DIR/unnecessary_reserve.rs:29:9 + | +LL | vec.extend([1]) + | ^^^^^^^^^^^^^^^ + +error: this `reserve` no longer makes sense in rustc version >= 1.62 + --> $DIR/unnecessary_reserve.rs:49:5 + | +LL | vec_deque.extend([1]); + | ^^^^^^^^^^^^^^^^^^^^^^ + +error: this `reserve` no longer makes sense in rustc version >= 1.62 + --> $DIR/unnecessary_reserve.rs:53:5 + | +LL | vec_deque.extend(array); + | ^^^^^^^^^^^^^^^^^^^^^^^^ + +error: this `reserve` no longer makes sense in rustc version >= 1.62 + --> $DIR/unnecessary_reserve.rs:58:9 + | +LL | vec_deque.extend([1]) + | ^^^^^^^^^^^^^^^^^^^^^ + +error: aborting due to 6 previous errors + From ab1a1b3a67e4504144b2ee88c10f4c877c9d128e Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Fri, 1 Jul 2022 22:14:35 +0900 Subject: [PATCH 02/21] Update What it dose Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com> --- clippy_lints/src/unnecessary_reserve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index b1995e9e2814..9519f7b0de85 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -9,7 +9,7 @@ use rustc_span::sym; declare_clippy_lint! { /// ### What it does - /// This lint checks for `reserve` before calling the `extend` method. + /// This lint checks for a call to `reserve` before `extend` on a `Vec` or `VecDeque`. /// ### Why is this bad? /// vec::reserve method before vec::extend is no longer makes sense in rustc version >= 1.62 /// ### Example From a980ee8e3d86ba13eaf0f5075ebd89bd73bfacfa Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Fri, 1 Jul 2022 22:14:45 +0900 Subject: [PATCH 03/21] Update description Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com> --- clippy_lints/src/unnecessary_reserve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 9519f7b0de85..c5386c2142ce 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -28,7 +28,7 @@ declare_clippy_lint! { #[clippy::version = "1.64.0"] pub UNNECESSARY_RESERVE, pedantic, - "`reserve` method before `extend` is no longer makes sense in rustc version >= 1.62" + "`reserve` before `extend` no longer makes sense in rustc version >= 1.62" } pub struct UnnecessaryReserve { From df42bbdeb6acc520b1a2a4bb139f34a720481dab Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Fri, 1 Jul 2022 22:14:57 +0900 Subject: [PATCH 04/21] Update Why is this bad Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com> --- clippy_lints/src/unnecessary_reserve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index c5386c2142ce..4f8640bd31d9 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -11,7 +11,7 @@ declare_clippy_lint! { /// ### What it does /// This lint checks for a call to `reserve` before `extend` on a `Vec` or `VecDeque`. /// ### Why is this bad? - /// vec::reserve method before vec::extend is no longer makes sense in rustc version >= 1.62 + /// Since Rust 1.62, `extend` implicitly calls `reserve` /// ### Example /// ```rust /// let mut vec: Vec = vec![]; From c772ac34197e4e181e8b8e44e70dd43dc44d864c Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Mon, 4 Jul 2022 22:06:19 +0900 Subject: [PATCH 05/21] use span_lint_and_then --- clippy_lints/src/unnecessary_reserve.rs | 13 +++++++++++-- tests/ui/unnecessary_reserve.stderr | 12 ++++++++++++ 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 4f8640bd31d9..cd396465587a 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -1,5 +1,6 @@ -use clippy_utils::diagnostics::span_lint; +use clippy_utils::diagnostics::span_lint_and_then; use clippy_utils::{match_def_path, meets_msrv, msrvs, paths, visitors::expr_visitor_no_bodies}; +use rustc_errors::Applicability; use rustc_hir::{intravisit::Visitor, Block, ExprKind, QPath, StmtKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; @@ -60,11 +61,19 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { && let Some(next_stmt_span) = check_extend_method(cx, block, idx, struct_calling_on) && !next_stmt_span.from_expansion() { - span_lint( + span_lint_and_then( cx, UNNECESSARY_RESERVE, next_stmt_span, "this `reserve` no longer makes sense in rustc version >= 1.62", + |diag| { + diag.span_suggestion( + semi_expr.span, + "remove this line", + String::new(), + Applicability::MaybeIncorrect, + ); + } ); } } diff --git a/tests/ui/unnecessary_reserve.stderr b/tests/ui/unnecessary_reserve.stderr index b7a76bf5f782..7d87a2cd37d6 100644 --- a/tests/ui/unnecessary_reserve.stderr +++ b/tests/ui/unnecessary_reserve.stderr @@ -1,6 +1,8 @@ error: this `reserve` no longer makes sense in rustc version >= 1.62 --> $DIR/unnecessary_reserve.rs:20:5 | +LL | vec.reserve(1); + | -------------- help: remove this line LL | vec.extend([1]); | ^^^^^^^^^^^^^^^^ | @@ -9,30 +11,40 @@ LL | vec.extend([1]); error: this `reserve` no longer makes sense in rustc version >= 1.62 --> $DIR/unnecessary_reserve.rs:24:5 | +LL | vec.reserve(array.len()); + | ------------------------ help: remove this line LL | vec.extend(array); | ^^^^^^^^^^^^^^^^^^ error: this `reserve` no longer makes sense in rustc version >= 1.62 --> $DIR/unnecessary_reserve.rs:29:9 | +LL | vec.reserve(1); + | -------------- help: remove this line LL | vec.extend([1]) | ^^^^^^^^^^^^^^^ error: this `reserve` no longer makes sense in rustc version >= 1.62 --> $DIR/unnecessary_reserve.rs:49:5 | +LL | vec_deque.reserve(1); + | -------------------- help: remove this line LL | vec_deque.extend([1]); | ^^^^^^^^^^^^^^^^^^^^^^ error: this `reserve` no longer makes sense in rustc version >= 1.62 --> $DIR/unnecessary_reserve.rs:53:5 | +LL | vec_deque.reserve(array.len()); + | ------------------------------ help: remove this line LL | vec_deque.extend(array); | ^^^^^^^^^^^^^^^^^^^^^^^^ error: this `reserve` no longer makes sense in rustc version >= 1.62 --> $DIR/unnecessary_reserve.rs:58:9 | +LL | vec_deque.reserve(1); + | -------------------- help: remove this line LL | vec_deque.extend([1]) | ^^^^^^^^^^^^^^^^^^^^^ From 6100e83e77f1e71a367bbbd2e5c5be82dd94911f Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Sun, 14 Aug 2022 14:05:21 +0900 Subject: [PATCH 06/21] Update warn message Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com> --- clippy_lints/src/unnecessary_reserve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index cd396465587a..69dc2bc564cc 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -29,7 +29,7 @@ declare_clippy_lint! { #[clippy::version = "1.64.0"] pub UNNECESSARY_RESERVE, pedantic, - "`reserve` before `extend` no longer makes sense in rustc version >= 1.62" + "calling `reserve` before `extend` on a `Vec` or `VecDeque`, when it will be called implicitly" } pub struct UnnecessaryReserve { From 9a961d5eaf354d9939c40dfa120e365663f0c06f Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Sun, 14 Aug 2022 14:05:41 +0900 Subject: [PATCH 07/21] Update clippy_lints/src/unnecessary_reserve.rs Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com> --- clippy_lints/src/unnecessary_reserve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 69dc2bc564cc..76eff77fd392 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -65,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { cx, UNNECESSARY_RESERVE, next_stmt_span, - "this `reserve` no longer makes sense in rustc version >= 1.62", + "unnecessary call to `reserve`", |diag| { diag.span_suggestion( semi_expr.span, From a02df992796473ddc7509f55be237b028f868037 Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Sun, 14 Aug 2022 14:05:50 +0900 Subject: [PATCH 08/21] Update clippy_lints/src/unnecessary_reserve.rs Co-authored-by: Alex <69764315+Serial-ATA@users.noreply.github.com> --- clippy_lints/src/unnecessary_reserve.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 76eff77fd392..261945d39afb 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -140,7 +140,8 @@ fn check_extend_method( fn equal_ident(left: &rustc_hir::Expr<'_>, right: &rustc_hir::Expr<'_>) -> bool { fn ident_name(expr: &rustc_hir::Expr<'_>) -> Option { if let ExprKind::Path(QPath::Resolved(None, inner_path)) = expr.kind - && let [inner_seg] = inner_path.segments { + && let [inner_seg] = inner_path.segments + { return Some(inner_seg.ident.name); } None From 47e916fab2e6f8931fc218c5d4edf9a0f9452d9e Mon Sep 17 00:00:00 2001 From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com> Date: Sun, 14 Aug 2022 14:18:30 +0900 Subject: [PATCH 09/21] fix test --- tests/ui/unnecessary_reserve.stderr | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/ui/unnecessary_reserve.stderr b/tests/ui/unnecessary_reserve.stderr index 7d87a2cd37d6..75c7d58e7301 100644 --- a/tests/ui/unnecessary_reserve.stderr +++ b/tests/ui/unnecessary_reserve.stderr @@ -1,4 +1,4 @@ -error: this `reserve` no longer makes sense in rustc version >= 1.62 +error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:20:5 | LL | vec.reserve(1); @@ -8,7 +8,7 @@ LL | vec.extend([1]); | = note: `-D clippy::unnecessary-reserve` implied by `-D warnings` -error: this `reserve` no longer makes sense in rustc version >= 1.62 +error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:24:5 | LL | vec.reserve(array.len()); @@ -16,7 +16,7 @@ LL | vec.reserve(array.len()); LL | vec.extend(array); | ^^^^^^^^^^^^^^^^^^ -error: this `reserve` no longer makes sense in rustc version >= 1.62 +error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:29:9 | LL | vec.reserve(1); @@ -24,7 +24,7 @@ LL | vec.reserve(1); LL | vec.extend([1]) | ^^^^^^^^^^^^^^^ -error: this `reserve` no longer makes sense in rustc version >= 1.62 +error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:49:5 | LL | vec_deque.reserve(1); @@ -32,7 +32,7 @@ LL | vec_deque.reserve(1); LL | vec_deque.extend([1]); | ^^^^^^^^^^^^^^^^^^^^^^ -error: this `reserve` no longer makes sense in rustc version >= 1.62 +error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:53:5 | LL | vec_deque.reserve(array.len()); @@ -40,7 +40,7 @@ LL | vec_deque.reserve(array.len()); LL | vec_deque.extend(array); | ^^^^^^^^^^^^^^^^^^^^^^^^ -error: this `reserve` no longer makes sense in rustc version >= 1.62 +error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:58:9 | LL | vec_deque.reserve(1); From c332c4897abcafc85f00138ee1fe937142727243 Mon Sep 17 00:00:00 2001 From: chansuke Date: Mon, 2 Jan 2023 23:25:08 +0900 Subject: [PATCH 10/21] refactor: delete unnecessary comparison --- clippy_lints/src/declared_lints.rs | 1 + clippy_lints/src/lib.rs | 1 + clippy_lints/src/unnecessary_reserve.rs | 55 +++++++++---------------- clippy_utils/src/msrvs.rs | 2 +- tests/ui/unnecessary_reserve.rs | 18 ++++---- tests/ui/unnecessary_reserve.stderr | 26 +++++++++--- 6 files changed, 53 insertions(+), 50 deletions(-) diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs index f24dab627809..9836b752a645 100644 --- a/clippy_lints/src/declared_lints.rs +++ b/clippy_lints/src/declared_lints.rs @@ -624,6 +624,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[ crate::unnamed_address::VTABLE_ADDRESS_COMPARISONS_INFO, crate::unnecessary_box_returns::UNNECESSARY_BOX_RETURNS_INFO, crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO, + crate::unnecessary_reserve::UNNECESSARY_RESERVE_INFO, crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO, crate::unnecessary_struct_initialization::UNNECESSARY_STRUCT_INITIALIZATION_INFO, crate::unnecessary_wraps::UNNECESSARY_WRAPS_INFO, diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index a429d4bc4034..baf366a03263 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -961,6 +961,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation)); store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments)); store.register_late_pass(move || Box::new(unnecessary_reserve::UnnecessaryReserve::new(msrv))); + store.register_late_pass(move |_| Box::new(unnecessary_reserve::UnnecessaryReserve::new(msrv()))); // add lints here, do not remove this comment, it's used in `new_lint` } diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 261945d39afb..fa222a4421b7 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -1,18 +1,21 @@ use clippy_utils::diagnostics::span_lint_and_then; -use clippy_utils::{match_def_path, meets_msrv, msrvs, paths, visitors::expr_visitor_no_bodies}; +use clippy_utils::msrvs::{self, Msrv}; +use clippy_utils::{match_def_path, paths, visitors::for_each_expr, SpanlessEq}; +use core::ops::ControlFlow; use rustc_errors::Applicability; -use rustc_hir::{intravisit::Visitor, Block, ExprKind, QPath, StmtKind}; +use rustc_hir::{Block, ExprKind, PathSegment, StmtKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; -use rustc_semver::RustcVersion; use rustc_session::{declare_tool_lint, impl_lint_pass}; use rustc_span::sym; declare_clippy_lint! { /// ### What it does + /// /// This lint checks for a call to `reserve` before `extend` on a `Vec` or `VecDeque`. /// ### Why is this bad? /// Since Rust 1.62, `extend` implicitly calls `reserve` + /// /// ### Example /// ```rust /// let mut vec: Vec = vec![]; @@ -32,31 +35,27 @@ declare_clippy_lint! { "calling `reserve` before `extend` on a `Vec` or `VecDeque`, when it will be called implicitly" } +impl_lint_pass!(UnnecessaryReserve => [UNNECESSARY_RESERVE]); + pub struct UnnecessaryReserve { - msrv: Option, + msrv: Msrv, } - impl UnnecessaryReserve { - #[must_use] - pub fn new(msrv: Option) -> Self { + pub fn new(msrv: Msrv) -> Self { Self { msrv } } } -impl_lint_pass!(UnnecessaryReserve => [UNNECESSARY_RESERVE]); - impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) { - if !meets_msrv(self.msrv, msrvs::UNNECESSARY_RESERVE) { + if !self.msrv.meets(msrvs::CHECK_UNNECESSARY_RESERVE) { return; } for (idx, stmt) in block.stmts.iter().enumerate() { if let StmtKind::Semi(semi_expr) = stmt.kind - && let ExprKind::MethodCall(_, [struct_calling_on, _], _) = semi_expr.kind - && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(semi_expr.hir_id) - && (match_def_path(cx, expr_def_id, &paths::VEC_RESERVE) || - match_def_path(cx, expr_def_id, &paths::VEC_DEQUE_RESERVE)) + && let ExprKind::MethodCall(PathSegment { ident: method, .. }, struct_calling_on, _, _) = semi_expr.kind + && method.name.as_str() == "reserve" && acceptable_type(cx, struct_calling_on) && let Some(next_stmt_span) = check_extend_method(cx, block, idx, struct_calling_on) && !next_stmt_span.from_expansion() @@ -102,32 +101,32 @@ fn check_extend_method( ) -> Option { let mut read_found = false; let next_stmt_span; + let mut spanless_eq = SpanlessEq::new(cx); - let mut visitor = expr_visitor_no_bodies(|expr| { - if let ExprKind::MethodCall(_, [struct_calling_on, _], _) = expr.kind + let _: Option = for_each_expr(block, |expr| { + if let ExprKind::MethodCall(_, struct_calling_on, _,_) = expr.kind && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) && match_def_path(cx, expr_def_id, &paths::ITER_EXTEND) && acceptable_type(cx, struct_calling_on) - && equal_ident(struct_calling_on, struct_expr) + // Check that both expr are equal + && spanless_eq.eq_expr(struct_calling_on, struct_expr) { read_found = true; } - !read_found + let _ = !read_found; + ControlFlow::Continue(()) }); if idx == block.stmts.len() - 1 { if let Some(e) = block.expr { - visitor.visit_expr(e); next_stmt_span = e.span; } else { return None; } } else { let next_stmt = &block.stmts[idx + 1]; - visitor.visit_stmt(next_stmt); next_stmt_span = next_stmt.span; } - drop(visitor); if read_found { return Some(next_stmt_span); @@ -135,17 +134,3 @@ fn check_extend_method( None } - -#[must_use] -fn equal_ident(left: &rustc_hir::Expr<'_>, right: &rustc_hir::Expr<'_>) -> bool { - fn ident_name(expr: &rustc_hir::Expr<'_>) -> Option { - if let ExprKind::Path(QPath::Resolved(None, inner_path)) = expr.kind - && let [inner_seg] = inner_path.segments - { - return Some(inner_seg.ident.name); - } - None - } - - ident_name(left) == ident_name(right) -} diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs index e94c0b00a653..d82e4eba4add 100644 --- a/clippy_utils/src/msrvs.rs +++ b/clippy_utils/src/msrvs.rs @@ -21,7 +21,7 @@ macro_rules! msrv_aliases { msrv_aliases! { 1,68,0 { PATH_MAIN_SEPARATOR_STR } 1,65,0 { LET_ELSE } - 1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, UNNECESSARY_RESERVE } + 1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, CHECK_UNNECESSARY_RESERVE } 1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY } 1,55,0 { SEEK_REWIND } 1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR } diff --git a/tests/ui/unnecessary_reserve.rs b/tests/ui/unnecessary_reserve.rs index 372c7f434ea5..f67d16e17bd3 100644 --- a/tests/ui/unnecessary_reserve.rs +++ b/tests/ui/unnecessary_reserve.rs @@ -6,27 +6,27 @@ use std::collections::VecDeque; fn main() { vec_reserve(); - vec_deque_reserve(); - hash_map_reserve(); - msrv_1_62(); + //vec_deque_reserve(); + //hash_map_reserve(); + //msrv_1_62(); } fn vec_reserve() { let mut vec: Vec = vec![]; let array: &[usize] = &[1, 2]; - // do lint + // do not lint vec.reserve(1); vec.extend([1]); - // do lint + //// do lint vec.reserve(array.len()); vec.extend(array); // do lint { - vec.reserve(1); - vec.extend([1]) + vec.reserve(array.len()); + vec.extend(array) }; // do not lint @@ -44,7 +44,7 @@ fn vec_deque_reserve() { let mut vec_deque: VecDeque = [1].into(); let array: &[usize] = &[1, 2]; - // do lint + // do not lint vec_deque.reserve(1); vec_deque.extend([1]); @@ -52,7 +52,7 @@ fn vec_deque_reserve() { vec_deque.reserve(array.len()); vec_deque.extend(array); - // do lint + // do not lint { vec_deque.reserve(1); vec_deque.extend([1]) diff --git a/tests/ui/unnecessary_reserve.stderr b/tests/ui/unnecessary_reserve.stderr index 75c7d58e7301..65f62d5d6d6f 100644 --- a/tests/ui/unnecessary_reserve.stderr +++ b/tests/ui/unnecessary_reserve.stderr @@ -16,13 +16,21 @@ LL | vec.reserve(array.len()); LL | vec.extend(array); | ^^^^^^^^^^^^^^^^^^ +error: unnecessary call to `reserve` + --> $DIR/unnecessary_reserve.rs:34:5 + | +LL | vec.reserve(array.len()); + | ------------------------ help: remove this line +LL | vec.push(1); + | ^^^^^^^^^^^^ + error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:29:9 | -LL | vec.reserve(1); - | -------------- help: remove this line -LL | vec.extend([1]) - | ^^^^^^^^^^^^^^^ +LL | vec.reserve(array.len()); + | ------------------------ help: remove this line +LL | vec.extend(array) + | ^^^^^^^^^^^^^^^^^ error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:49:5 @@ -40,6 +48,14 @@ LL | vec_deque.reserve(array.len()); LL | vec_deque.extend(array); | ^^^^^^^^^^^^^^^^^^^^^^^^ +error: unnecessary call to `reserve` + --> $DIR/unnecessary_reserve.rs:63:5 + | +LL | vec_deque.reserve(array.len() + 1); + | ---------------------------------- help: remove this line +LL | vec_deque.push_back(1); + | ^^^^^^^^^^^^^^^^^^^^^^^ + error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:58:9 | @@ -48,5 +64,5 @@ LL | vec_deque.reserve(1); LL | vec_deque.extend([1]) | ^^^^^^^^^^^^^^^^^^^^^ -error: aborting due to 6 previous errors +error: aborting due to 8 previous errors From 390d702aedb04b4f67f78db161b5289451948715 Mon Sep 17 00:00:00 2001 From: chansuke Date: Wed, 4 Jan 2023 22:37:19 +0900 Subject: [PATCH 11/21] refactor: fix re-daclare logic --- clippy_lints/src/unnecessary_reserve.rs | 9 ++++----- tests/ui/unnecessary_reserve.rs | 6 +++--- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index fa222a4421b7..0bf3c01979fc 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -100,7 +100,6 @@ fn check_extend_method( struct_expr: &rustc_hir::Expr<'_>, ) -> Option { let mut read_found = false; - let next_stmt_span; let mut spanless_eq = SpanlessEq::new(cx); let _: Option = for_each_expr(block, |expr| { @@ -117,16 +116,16 @@ fn check_extend_method( ControlFlow::Continue(()) }); - if idx == block.stmts.len() - 1 { + let next_stmt_span: rustc_span::Span = if idx == block.stmts.len() - 1 { if let Some(e) = block.expr { - next_stmt_span = e.span; + e.span } else { return None; } } else { let next_stmt = &block.stmts[idx + 1]; - next_stmt_span = next_stmt.span; - } + return Some(next_stmt.span); + }; if read_found { return Some(next_stmt_span); diff --git a/tests/ui/unnecessary_reserve.rs b/tests/ui/unnecessary_reserve.rs index f67d16e17bd3..0bf826e181e9 100644 --- a/tests/ui/unnecessary_reserve.rs +++ b/tests/ui/unnecessary_reserve.rs @@ -6,9 +6,9 @@ use std::collections::VecDeque; fn main() { vec_reserve(); - //vec_deque_reserve(); - //hash_map_reserve(); - //msrv_1_62(); + vec_deque_reserve(); + hash_map_reserve(); + msrv_1_62(); } fn vec_reserve() { From 6cd1b648ca2fbc4df975daf62cc6acdaf99dab70 Mon Sep 17 00:00:00 2001 From: chansuke Date: Wed, 4 Jan 2023 22:58:58 +0900 Subject: [PATCH 12/21] chore: run `cargo dev update_lints` --- CHANGELOG.md | 2 +- clippy_lints/src/lib.register_lints.rs | 600 ---------------------- clippy_lints/src/lib.register_pedantic.rs | 102 ---- 3 files changed, 1 insertion(+), 703 deletions(-) delete mode 100644 clippy_lints/src/lib.register_lints.rs delete mode 100644 clippy_lints/src/lib.register_pedantic.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 101c2292145a..abb5376f1783 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4990,9 +4990,9 @@ Released 2018-09-13 [`unnecessary_mut_passed`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_mut_passed [`unnecessary_operation`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_operation [`unnecessary_owned_empty_strings`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_owned_empty_strings +[`unnecessary_reserve`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_reserve [`unnecessary_safety_comment`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_comment [`unnecessary_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_safety_doc -[`unnecessary_reserve`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_reserve [`unnecessary_self_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_self_imports [`unnecessary_sort_by`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_sort_by [`unnecessary_struct_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_struct_initialization diff --git a/clippy_lints/src/lib.register_lints.rs b/clippy_lints/src/lib.register_lints.rs deleted file mode 100644 index 0bc56d55fc19..000000000000 --- a/clippy_lints/src/lib.register_lints.rs +++ /dev/null @@ -1,600 +0,0 @@ -// This file was generated by `cargo dev update_lints`. -// Use that command to update this file and do not edit by hand. -// Manual edits will be overwritten. - -store.register_lints(&[ - #[cfg(feature = "internal")] - utils::internal_lints::CLIPPY_LINTS_INTERNAL, - #[cfg(feature = "internal")] - utils::internal_lints::COLLAPSIBLE_SPAN_LINT_CALLS, - #[cfg(feature = "internal")] - utils::internal_lints::COMPILER_LINT_FUNCTIONS, - #[cfg(feature = "internal")] - utils::internal_lints::DEFAULT_DEPRECATION_REASON, - #[cfg(feature = "internal")] - utils::internal_lints::DEFAULT_LINT, - #[cfg(feature = "internal")] - utils::internal_lints::IF_CHAIN_STYLE, - #[cfg(feature = "internal")] - utils::internal_lints::INTERNING_DEFINED_SYMBOL, - #[cfg(feature = "internal")] - utils::internal_lints::INVALID_CLIPPY_VERSION_ATTRIBUTE, - #[cfg(feature = "internal")] - utils::internal_lints::INVALID_PATHS, - #[cfg(feature = "internal")] - utils::internal_lints::LINT_WITHOUT_LINT_PASS, - #[cfg(feature = "internal")] - utils::internal_lints::MATCH_TYPE_ON_DIAGNOSTIC_ITEM, - #[cfg(feature = "internal")] - utils::internal_lints::MISSING_CLIPPY_VERSION_ATTRIBUTE, - #[cfg(feature = "internal")] - utils::internal_lints::MISSING_MSRV_ATTR_IMPL, - #[cfg(feature = "internal")] - utils::internal_lints::OUTER_EXPN_EXPN_DATA, - #[cfg(feature = "internal")] - utils::internal_lints::PRODUCE_ICE, - #[cfg(feature = "internal")] - utils::internal_lints::UNNECESSARY_SYMBOL_STR, - almost_complete_letter_range::ALMOST_COMPLETE_LETTER_RANGE, - approx_const::APPROX_CONSTANT, - as_conversions::AS_CONVERSIONS, - as_underscore::AS_UNDERSCORE, - asm_syntax::INLINE_ASM_X86_ATT_SYNTAX, - asm_syntax::INLINE_ASM_X86_INTEL_SYNTAX, - assertions_on_constants::ASSERTIONS_ON_CONSTANTS, - assertions_on_result_states::ASSERTIONS_ON_RESULT_STATES, - async_yields_async::ASYNC_YIELDS_ASYNC, - attrs::ALLOW_ATTRIBUTES_WITHOUT_REASON, - attrs::BLANKET_CLIPPY_RESTRICTION_LINTS, - attrs::DEPRECATED_CFG_ATTR, - attrs::DEPRECATED_SEMVER, - attrs::EMPTY_LINE_AFTER_OUTER_ATTR, - attrs::INLINE_ALWAYS, - attrs::MISMATCHED_TARGET_OS, - attrs::USELESS_ATTRIBUTE, - await_holding_invalid::AWAIT_HOLDING_INVALID_TYPE, - await_holding_invalid::AWAIT_HOLDING_LOCK, - await_holding_invalid::AWAIT_HOLDING_REFCELL_REF, - blocks_in_if_conditions::BLOCKS_IN_IF_CONDITIONS, - bool_assert_comparison::BOOL_ASSERT_COMPARISON, - booleans::NONMINIMAL_BOOL, - booleans::OVERLY_COMPLEX_BOOL_EXPR, - borrow_as_ptr::BORROW_AS_PTR, - borrow_deref_ref::BORROW_DEREF_REF, - bytecount::NAIVE_BYTECOUNT, - bytes_count_to_len::BYTES_COUNT_TO_LEN, - cargo::CARGO_COMMON_METADATA, - cargo::MULTIPLE_CRATE_VERSIONS, - cargo::NEGATIVE_FEATURE_NAMES, - cargo::REDUNDANT_FEATURE_NAMES, - cargo::WILDCARD_DEPENDENCIES, - case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS, - casts::CAST_ABS_TO_UNSIGNED, - casts::CAST_ENUM_CONSTRUCTOR, - casts::CAST_ENUM_TRUNCATION, - casts::CAST_LOSSLESS, - casts::CAST_POSSIBLE_TRUNCATION, - casts::CAST_POSSIBLE_WRAP, - casts::CAST_PRECISION_LOSS, - casts::CAST_PTR_ALIGNMENT, - casts::CAST_REF_TO_MUT, - casts::CAST_SIGN_LOSS, - casts::CAST_SLICE_DIFFERENT_SIZES, - casts::CHAR_LIT_AS_U8, - casts::FN_TO_NUMERIC_CAST, - casts::FN_TO_NUMERIC_CAST_ANY, - casts::FN_TO_NUMERIC_CAST_WITH_TRUNCATION, - casts::PTR_AS_PTR, - casts::UNNECESSARY_CAST, - checked_conversions::CHECKED_CONVERSIONS, - cognitive_complexity::COGNITIVE_COMPLEXITY, - collapsible_if::COLLAPSIBLE_ELSE_IF, - collapsible_if::COLLAPSIBLE_IF, - comparison_chain::COMPARISON_CHAIN, - copies::BRANCHES_SHARING_CODE, - copies::IFS_SAME_COND, - copies::IF_SAME_THEN_ELSE, - copies::SAME_FUNCTIONS_IN_IF_CONDITION, - copy_iterator::COPY_ITERATOR, - crate_in_macro_def::CRATE_IN_MACRO_DEF, - create_dir::CREATE_DIR, - dbg_macro::DBG_MACRO, - default::DEFAULT_TRAIT_ACCESS, - default::FIELD_REASSIGN_WITH_DEFAULT, - default_instead_of_iter_empty::DEFAULT_INSTEAD_OF_ITER_EMPTY, - default_numeric_fallback::DEFAULT_NUMERIC_FALLBACK, - default_union_representation::DEFAULT_UNION_REPRESENTATION, - dereference::EXPLICIT_AUTO_DEREF, - dereference::EXPLICIT_DEREF_METHODS, - dereference::NEEDLESS_BORROW, - dereference::REF_BINDING_TO_REFERENCE, - derivable_impls::DERIVABLE_IMPLS, - derive::DERIVE_HASH_XOR_EQ, - derive::DERIVE_ORD_XOR_PARTIAL_ORD, - derive::DERIVE_PARTIAL_EQ_WITHOUT_EQ, - derive::EXPL_IMPL_CLONE_ON_COPY, - derive::UNSAFE_DERIVE_DESERIALIZE, - disallowed_methods::DISALLOWED_METHODS, - disallowed_names::DISALLOWED_NAMES, - disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS, - disallowed_types::DISALLOWED_TYPES, - doc::DOC_MARKDOWN, - doc::MISSING_ERRORS_DOC, - doc::MISSING_PANICS_DOC, - doc::MISSING_SAFETY_DOC, - doc::NEEDLESS_DOCTEST_MAIN, - doc_link_with_quotes::DOC_LINK_WITH_QUOTES, - double_parens::DOUBLE_PARENS, - drop_forget_ref::DROP_COPY, - drop_forget_ref::DROP_NON_DROP, - drop_forget_ref::DROP_REF, - drop_forget_ref::FORGET_COPY, - drop_forget_ref::FORGET_NON_DROP, - drop_forget_ref::FORGET_REF, - drop_forget_ref::UNDROPPED_MANUALLY_DROPS, - duplicate_mod::DUPLICATE_MOD, - else_if_without_else::ELSE_IF_WITHOUT_ELSE, - empty_drop::EMPTY_DROP, - empty_enum::EMPTY_ENUM, - empty_structs_with_brackets::EMPTY_STRUCTS_WITH_BRACKETS, - entry::MAP_ENTRY, - enum_clike::ENUM_CLIKE_UNPORTABLE_VARIANT, - enum_variants::ENUM_VARIANT_NAMES, - enum_variants::MODULE_INCEPTION, - enum_variants::MODULE_NAME_REPETITIONS, - equatable_if_let::EQUATABLE_IF_LET, - escape::BOXED_LOCAL, - eta_reduction::REDUNDANT_CLOSURE, - eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS, - excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS, - excessive_bools::STRUCT_EXCESSIVE_BOOLS, - exhaustive_items::EXHAUSTIVE_ENUMS, - exhaustive_items::EXHAUSTIVE_STRUCTS, - exit::EXIT, - explicit_write::EXPLICIT_WRITE, - fallible_impl_from::FALLIBLE_IMPL_FROM, - float_literal::EXCESSIVE_PRECISION, - float_literal::LOSSY_FLOAT_LITERAL, - floating_point_arithmetic::IMPRECISE_FLOPS, - floating_point_arithmetic::SUBOPTIMAL_FLOPS, - format::USELESS_FORMAT, - format_args::FORMAT_IN_FORMAT_ARGS, - format_args::TO_STRING_IN_FORMAT_ARGS, - format_impl::PRINT_IN_FORMAT_IMPL, - format_impl::RECURSIVE_FORMAT_IMPL, - format_push_string::FORMAT_PUSH_STRING, - formatting::POSSIBLE_MISSING_COMMA, - formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING, - formatting::SUSPICIOUS_ELSE_FORMATTING, - formatting::SUSPICIOUS_UNARY_OP_FORMATTING, - from_over_into::FROM_OVER_INTO, - from_str_radix_10::FROM_STR_RADIX_10, - functions::DOUBLE_MUST_USE, - functions::MUST_USE_CANDIDATE, - functions::MUST_USE_UNIT, - functions::NOT_UNSAFE_PTR_ARG_DEREF, - functions::RESULT_UNIT_ERR, - functions::TOO_MANY_ARGUMENTS, - functions::TOO_MANY_LINES, - future_not_send::FUTURE_NOT_SEND, - get_first::GET_FIRST, - if_let_mutex::IF_LET_MUTEX, - if_not_else::IF_NOT_ELSE, - if_then_some_else_none::IF_THEN_SOME_ELSE_NONE, - implicit_hasher::IMPLICIT_HASHER, - implicit_return::IMPLICIT_RETURN, - implicit_saturating_sub::IMPLICIT_SATURATING_SUB, - inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR, - index_refutable_slice::INDEX_REFUTABLE_SLICE, - indexing_slicing::INDEXING_SLICING, - indexing_slicing::OUT_OF_BOUNDS_INDEXING, - infinite_iter::INFINITE_ITER, - infinite_iter::MAYBE_INFINITE_ITER, - inherent_impl::MULTIPLE_INHERENT_IMPL, - inherent_to_string::INHERENT_TO_STRING, - inherent_to_string::INHERENT_TO_STRING_SHADOW_DISPLAY, - init_numbered_fields::INIT_NUMBERED_FIELDS, - inline_fn_without_body::INLINE_FN_WITHOUT_BODY, - int_plus_one::INT_PLUS_ONE, - invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS, - invalid_utf8_in_unchecked::INVALID_UTF8_IN_UNCHECKED, - items_after_statements::ITEMS_AFTER_STATEMENTS, - iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR, - large_const_arrays::LARGE_CONST_ARRAYS, - large_enum_variant::LARGE_ENUM_VARIANT, - large_include_file::LARGE_INCLUDE_FILE, - large_stack_arrays::LARGE_STACK_ARRAYS, - len_zero::COMPARISON_TO_EMPTY, - len_zero::LEN_WITHOUT_IS_EMPTY, - len_zero::LEN_ZERO, - let_if_seq::USELESS_LET_IF_SEQ, - let_underscore::LET_UNDERSCORE_DROP, - let_underscore::LET_UNDERSCORE_LOCK, - let_underscore::LET_UNDERSCORE_MUST_USE, - lifetimes::EXTRA_UNUSED_LIFETIMES, - lifetimes::NEEDLESS_LIFETIMES, - literal_representation::DECIMAL_LITERAL_REPRESENTATION, - literal_representation::INCONSISTENT_DIGIT_GROUPING, - literal_representation::LARGE_DIGIT_GROUPS, - literal_representation::MISTYPED_LITERAL_SUFFIXES, - literal_representation::UNREADABLE_LITERAL, - literal_representation::UNUSUAL_BYTE_GROUPINGS, - loops::EMPTY_LOOP, - loops::EXPLICIT_COUNTER_LOOP, - loops::EXPLICIT_INTO_ITER_LOOP, - loops::EXPLICIT_ITER_LOOP, - loops::FOR_KV_MAP, - loops::FOR_LOOPS_OVER_FALLIBLES, - loops::ITER_NEXT_LOOP, - loops::MANUAL_FIND, - loops::MANUAL_FLATTEN, - loops::MANUAL_MEMCPY, - loops::MISSING_SPIN_LOOP, - loops::MUT_RANGE_BOUND, - loops::NEEDLESS_COLLECT, - loops::NEEDLESS_RANGE_LOOP, - loops::NEVER_LOOP, - loops::SAME_ITEM_PUSH, - loops::SINGLE_ELEMENT_LOOP, - loops::WHILE_IMMUTABLE_CONDITION, - loops::WHILE_LET_LOOP, - loops::WHILE_LET_ON_ITERATOR, - macro_use::MACRO_USE_IMPORTS, - main_recursion::MAIN_RECURSION, - manual_assert::MANUAL_ASSERT, - manual_async_fn::MANUAL_ASYNC_FN, - manual_bits::MANUAL_BITS, - manual_instant_elapsed::MANUAL_INSTANT_ELAPSED, - manual_non_exhaustive::MANUAL_NON_EXHAUSTIVE, - manual_ok_or::MANUAL_OK_OR, - manual_rem_euclid::MANUAL_REM_EUCLID, - manual_retain::MANUAL_RETAIN, - manual_strip::MANUAL_STRIP, - map_clone::MAP_CLONE, - map_err_ignore::MAP_ERR_IGNORE, - map_unit_fn::OPTION_MAP_UNIT_FN, - map_unit_fn::RESULT_MAP_UNIT_FN, - match_result_ok::MATCH_RESULT_OK, - matches::COLLAPSIBLE_MATCH, - matches::INFALLIBLE_DESTRUCTURING_MATCH, - matches::MANUAL_MAP, - matches::MANUAL_UNWRAP_OR, - matches::MATCH_AS_REF, - matches::MATCH_BOOL, - matches::MATCH_LIKE_MATCHES_MACRO, - matches::MATCH_ON_VEC_ITEMS, - matches::MATCH_OVERLAPPING_ARM, - matches::MATCH_REF_PATS, - matches::MATCH_SAME_ARMS, - matches::MATCH_SINGLE_BINDING, - matches::MATCH_STR_CASE_MISMATCH, - matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS, - matches::MATCH_WILD_ERR_ARM, - matches::NEEDLESS_MATCH, - matches::REDUNDANT_PATTERN_MATCHING, - matches::REST_PAT_IN_FULLY_BOUND_STRUCTS, - matches::SIGNIFICANT_DROP_IN_SCRUTINEE, - matches::SINGLE_MATCH, - matches::SINGLE_MATCH_ELSE, - matches::TRY_ERR, - matches::WILDCARD_ENUM_MATCH_ARM, - matches::WILDCARD_IN_OR_PATTERNS, - mem_forget::MEM_FORGET, - mem_replace::MEM_REPLACE_OPTION_WITH_NONE, - mem_replace::MEM_REPLACE_WITH_DEFAULT, - mem_replace::MEM_REPLACE_WITH_UNINIT, - methods::BIND_INSTEAD_OF_MAP, - methods::BYTES_NTH, - methods::CHARS_LAST_CMP, - methods::CHARS_NEXT_CMP, - methods::CLONED_INSTEAD_OF_COPIED, - methods::CLONE_DOUBLE_REF, - methods::CLONE_ON_COPY, - methods::CLONE_ON_REF_PTR, - methods::ERR_EXPECT, - methods::EXPECT_FUN_CALL, - methods::EXPECT_USED, - methods::EXTEND_WITH_DRAIN, - methods::FILETYPE_IS_FILE, - methods::FILTER_MAP_IDENTITY, - methods::FILTER_MAP_NEXT, - methods::FILTER_NEXT, - methods::FLAT_MAP_IDENTITY, - methods::FLAT_MAP_OPTION, - methods::FROM_ITER_INSTEAD_OF_COLLECT, - methods::GET_LAST_WITH_LEN, - methods::GET_UNWRAP, - methods::IMPLICIT_CLONE, - methods::INEFFICIENT_TO_STRING, - methods::INSPECT_FOR_EACH, - methods::INTO_ITER_ON_REF, - methods::IS_DIGIT_ASCII_RADIX, - methods::ITERATOR_STEP_BY_ZERO, - methods::ITER_CLONED_COLLECT, - methods::ITER_COUNT, - methods::ITER_NEXT_SLICE, - methods::ITER_NTH, - methods::ITER_NTH_ZERO, - methods::ITER_OVEREAGER_CLONED, - methods::ITER_SKIP_NEXT, - methods::ITER_WITH_DRAIN, - methods::MANUAL_FILTER_MAP, - methods::MANUAL_FIND_MAP, - methods::MANUAL_SATURATING_ARITHMETIC, - methods::MANUAL_SPLIT_ONCE, - methods::MANUAL_STR_REPEAT, - methods::MAP_COLLECT_RESULT_UNIT, - methods::MAP_FLATTEN, - methods::MAP_IDENTITY, - methods::MAP_UNWRAP_OR, - methods::NEEDLESS_OPTION_AS_DEREF, - methods::NEEDLESS_OPTION_TAKE, - methods::NEEDLESS_SPLITN, - methods::NEW_RET_NO_SELF, - methods::NO_EFFECT_REPLACE, - methods::OBFUSCATED_IF_ELSE, - methods::OK_EXPECT, - methods::OPTION_AS_REF_DEREF, - methods::OPTION_FILTER_MAP, - methods::OPTION_MAP_OR_NONE, - methods::OR_FUN_CALL, - methods::OR_THEN_UNWRAP, - methods::RESULT_MAP_OR_INTO_OPTION, - methods::SEARCH_IS_SOME, - methods::SHOULD_IMPLEMENT_TRAIT, - methods::SINGLE_CHAR_ADD_STR, - methods::SINGLE_CHAR_PATTERN, - methods::SKIP_WHILE_NEXT, - methods::STRING_EXTEND_CHARS, - methods::SUSPICIOUS_MAP, - methods::SUSPICIOUS_SPLITN, - methods::UNINIT_ASSUMED_INIT, - methods::UNNECESSARY_FILTER_MAP, - methods::UNNECESSARY_FIND_MAP, - methods::UNNECESSARY_FOLD, - methods::UNNECESSARY_JOIN, - methods::UNNECESSARY_LAZY_EVALUATIONS, - methods::UNNECESSARY_TO_OWNED, - methods::UNWRAP_OR_ELSE_DEFAULT, - methods::UNWRAP_USED, - methods::USELESS_ASREF, - methods::WRONG_SELF_CONVENTION, - methods::ZST_OFFSET, - minmax::MIN_MAX, - misc::SHORT_CIRCUIT_STATEMENT, - misc::TOPLEVEL_REF_ARG, - misc::USED_UNDERSCORE_BINDING, - misc::ZERO_PTR, - misc_early::BUILTIN_TYPE_SHADOW, - misc_early::DOUBLE_NEG, - misc_early::DUPLICATE_UNDERSCORE_ARGUMENT, - misc_early::MIXED_CASE_HEX_LITERALS, - misc_early::REDUNDANT_PATTERN, - misc_early::SEPARATED_LITERAL_SUFFIX, - misc_early::UNNEEDED_FIELD_PATTERN, - misc_early::UNNEEDED_WILDCARD_PATTERN, - misc_early::UNSEPARATED_LITERAL_SUFFIX, - misc_early::ZERO_PREFIXED_LITERAL, - mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER, - missing_const_for_fn::MISSING_CONST_FOR_FN, - missing_doc::MISSING_DOCS_IN_PRIVATE_ITEMS, - missing_enforced_import_rename::MISSING_ENFORCED_IMPORT_RENAMES, - missing_inline::MISSING_INLINE_IN_PUBLIC_ITEMS, - mixed_read_write_in_expression::DIVERGING_SUB_EXPRESSION, - mixed_read_write_in_expression::MIXED_READ_WRITE_IN_EXPRESSION, - module_style::MOD_MODULE_FILES, - module_style::SELF_NAMED_MODULE_FILES, - mut_key::MUTABLE_KEY_TYPE, - mut_mut::MUT_MUT, - mut_mutex_lock::MUT_MUTEX_LOCK, - mut_reference::UNNECESSARY_MUT_PASSED, - mutable_debug_assertion::DEBUG_ASSERT_WITH_MUT_CALL, - mutex_atomic::MUTEX_ATOMIC, - mutex_atomic::MUTEX_INTEGER, - needless_arbitrary_self_type::NEEDLESS_ARBITRARY_SELF_TYPE, - needless_bool::BOOL_COMPARISON, - needless_bool::NEEDLESS_BOOL, - needless_borrowed_ref::NEEDLESS_BORROWED_REFERENCE, - needless_continue::NEEDLESS_CONTINUE, - needless_for_each::NEEDLESS_FOR_EACH, - needless_late_init::NEEDLESS_LATE_INIT, - needless_parens_on_range_literals::NEEDLESS_PARENS_ON_RANGE_LITERALS, - needless_pass_by_value::NEEDLESS_PASS_BY_VALUE, - needless_question_mark::NEEDLESS_QUESTION_MARK, - needless_update::NEEDLESS_UPDATE, - neg_cmp_op_on_partial_ord::NEG_CMP_OP_ON_PARTIAL_ORD, - neg_multiply::NEG_MULTIPLY, - new_without_default::NEW_WITHOUT_DEFAULT, - no_effect::NO_EFFECT, - no_effect::NO_EFFECT_UNDERSCORE_BINDING, - no_effect::UNNECESSARY_OPERATION, - non_copy_const::BORROW_INTERIOR_MUTABLE_CONST, - non_copy_const::DECLARE_INTERIOR_MUTABLE_CONST, - non_expressive_names::JUST_UNDERSCORES_AND_DIGITS, - non_expressive_names::MANY_SINGLE_CHAR_NAMES, - non_expressive_names::SIMILAR_NAMES, - non_octal_unix_permissions::NON_OCTAL_UNIX_PERMISSIONS, - non_send_fields_in_send_ty::NON_SEND_FIELDS_IN_SEND_TY, - nonstandard_macro_braces::NONSTANDARD_MACRO_BRACES, - octal_escapes::OCTAL_ESCAPES, - only_used_in_recursion::ONLY_USED_IN_RECURSION, - open_options::NONSENSICAL_OPEN_OPTIONS, - operators::ABSURD_EXTREME_COMPARISONS, - operators::ARITHMETIC, - operators::ASSIGN_OP_PATTERN, - operators::BAD_BIT_MASK, - operators::CMP_NAN, - operators::CMP_OWNED, - operators::DOUBLE_COMPARISONS, - operators::DURATION_SUBSEC, - operators::EQ_OP, - operators::ERASING_OP, - operators::FLOAT_ARITHMETIC, - operators::FLOAT_CMP, - operators::FLOAT_CMP_CONST, - operators::FLOAT_EQUALITY_WITHOUT_ABS, - operators::IDENTITY_OP, - operators::INEFFECTIVE_BIT_MASK, - operators::INTEGER_ARITHMETIC, - operators::INTEGER_DIVISION, - operators::MISREFACTORED_ASSIGN_OP, - operators::MODULO_ARITHMETIC, - operators::MODULO_ONE, - operators::NEEDLESS_BITWISE_BOOL, - operators::OP_REF, - operators::PTR_EQ, - operators::SELF_ASSIGNMENT, - operators::VERBOSE_BIT_MASK, - option_env_unwrap::OPTION_ENV_UNWRAP, - option_if_let_else::OPTION_IF_LET_ELSE, - overflow_check_conditional::OVERFLOW_CHECK_CONDITIONAL, - panic_in_result_fn::PANIC_IN_RESULT_FN, - panic_unimplemented::PANIC, - panic_unimplemented::TODO, - panic_unimplemented::UNIMPLEMENTED, - panic_unimplemented::UNREACHABLE, - partialeq_ne_impl::PARTIALEQ_NE_IMPL, - partialeq_to_none::PARTIALEQ_TO_NONE, - pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE, - pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF, - path_buf_push_overwrite::PATH_BUF_PUSH_OVERWRITE, - pattern_type_mismatch::PATTERN_TYPE_MISMATCH, - precedence::PRECEDENCE, - ptr::CMP_NULL, - ptr::INVALID_NULL_PTR_USAGE, - ptr::MUT_FROM_REF, - ptr::PTR_ARG, - ptr_offset_with_cast::PTR_OFFSET_WITH_CAST, - pub_use::PUB_USE, - question_mark::QUESTION_MARK, - ranges::MANUAL_RANGE_CONTAINS, - ranges::RANGE_MINUS_ONE, - ranges::RANGE_PLUS_ONE, - ranges::RANGE_ZIP_WITH_LEN, - ranges::REVERSED_EMPTY_RANGES, - rc_clone_in_vec_init::RC_CLONE_IN_VEC_INIT, - read_zero_byte_vec::READ_ZERO_BYTE_VEC, - redundant_clone::REDUNDANT_CLONE, - redundant_closure_call::REDUNDANT_CLOSURE_CALL, - redundant_else::REDUNDANT_ELSE, - redundant_field_names::REDUNDANT_FIELD_NAMES, - redundant_pub_crate::REDUNDANT_PUB_CRATE, - redundant_slicing::DEREF_BY_SLICING, - redundant_slicing::REDUNDANT_SLICING, - redundant_static_lifetimes::REDUNDANT_STATIC_LIFETIMES, - ref_option_ref::REF_OPTION_REF, - reference::DEREF_ADDROF, - regex::INVALID_REGEX, - regex::TRIVIAL_REGEX, - repeat_once::REPEAT_ONCE, - return_self_not_must_use::RETURN_SELF_NOT_MUST_USE, - returns::LET_AND_RETURN, - returns::NEEDLESS_RETURN, - same_name_method::SAME_NAME_METHOD, - self_named_constructors::SELF_NAMED_CONSTRUCTORS, - semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED, - serde_api::SERDE_API_MISUSE, - shadow::SHADOW_REUSE, - shadow::SHADOW_SAME, - shadow::SHADOW_UNRELATED, - single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES, - single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS, - size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT, - slow_vector_initialization::SLOW_VECTOR_INITIALIZATION, - stable_sort_primitive::STABLE_SORT_PRIMITIVE, - std_instead_of_core::ALLOC_INSTEAD_OF_CORE, - std_instead_of_core::STD_INSTEAD_OF_ALLOC, - std_instead_of_core::STD_INSTEAD_OF_CORE, - strings::STRING_ADD, - strings::STRING_ADD_ASSIGN, - strings::STRING_FROM_UTF8_AS_BYTES, - strings::STRING_LIT_AS_BYTES, - strings::STRING_SLICE, - strings::STRING_TO_STRING, - strings::STR_TO_STRING, - strings::TRIM_SPLIT_WHITESPACE, - strlen_on_c_strings::STRLEN_ON_C_STRINGS, - suspicious_operation_groupings::SUSPICIOUS_OPERATION_GROUPINGS, - suspicious_trait_impl::SUSPICIOUS_ARITHMETIC_IMPL, - suspicious_trait_impl::SUSPICIOUS_OP_ASSIGN_IMPL, - swap::ALMOST_SWAPPED, - swap::MANUAL_SWAP, - swap_ptr_to_ref::SWAP_PTR_TO_REF, - tabs_in_doc_comments::TABS_IN_DOC_COMMENTS, - temporary_assignment::TEMPORARY_ASSIGNMENT, - to_digit_is_some::TO_DIGIT_IS_SOME, - trailing_empty_array::TRAILING_EMPTY_ARRAY, - trait_bounds::TRAIT_DUPLICATION_IN_BOUNDS, - trait_bounds::TYPE_REPETITION_IN_BOUNDS, - transmute::CROSSPOINTER_TRANSMUTE, - transmute::TRANSMUTES_EXPRESSIBLE_AS_PTR_CASTS, - transmute::TRANSMUTE_BYTES_TO_STR, - transmute::TRANSMUTE_FLOAT_TO_INT, - transmute::TRANSMUTE_INT_TO_BOOL, - transmute::TRANSMUTE_INT_TO_CHAR, - transmute::TRANSMUTE_INT_TO_FLOAT, - transmute::TRANSMUTE_NUM_TO_BYTES, - transmute::TRANSMUTE_PTR_TO_PTR, - transmute::TRANSMUTE_PTR_TO_REF, - transmute::TRANSMUTE_UNDEFINED_REPR, - transmute::UNSOUND_COLLECTION_TRANSMUTE, - transmute::USELESS_TRANSMUTE, - transmute::WRONG_TRANSMUTE, - transmuting_null::TRANSMUTING_NULL, - types::BORROWED_BOX, - types::BOX_COLLECTION, - types::LINKEDLIST, - types::OPTION_OPTION, - types::RC_BUFFER, - types::RC_MUTEX, - types::REDUNDANT_ALLOCATION, - types::TYPE_COMPLEXITY, - types::VEC_BOX, - undocumented_unsafe_blocks::UNDOCUMENTED_UNSAFE_BLOCKS, - unicode::INVISIBLE_CHARACTERS, - unicode::NON_ASCII_LITERAL, - unicode::UNICODE_NOT_NFC, - uninit_vec::UNINIT_VEC, - unit_hash::UNIT_HASH, - unit_return_expecting_ord::UNIT_RETURN_EXPECTING_ORD, - unit_types::LET_UNIT_VALUE, - unit_types::UNIT_ARG, - unit_types::UNIT_CMP, - unnamed_address::FN_ADDRESS_COMPARISONS, - unnamed_address::VTABLE_ADDRESS_COMPARISONS, - unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS, - unnecessary_reserve::UNNECESSARY_RESERVE, - unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS, - unnecessary_sort_by::UNNECESSARY_SORT_BY, - unnecessary_wraps::UNNECESSARY_WRAPS, - unnested_or_patterns::UNNESTED_OR_PATTERNS, - unsafe_removed_from_name::UNSAFE_REMOVED_FROM_NAME, - unused_async::UNUSED_ASYNC, - unused_io_amount::UNUSED_IO_AMOUNT, - unused_rounding::UNUSED_ROUNDING, - unused_self::UNUSED_SELF, - unused_unit::UNUSED_UNIT, - unwrap::PANICKING_UNWRAP, - unwrap::UNNECESSARY_UNWRAP, - unwrap_in_result::UNWRAP_IN_RESULT, - upper_case_acronyms::UPPER_CASE_ACRONYMS, - use_self::USE_SELF, - useless_conversion::USELESS_CONVERSION, - vec::USELESS_VEC, - vec_init_then_push::VEC_INIT_THEN_PUSH, - vec_resize_to_zero::VEC_RESIZE_TO_ZERO, - verbose_file_reads::VERBOSE_FILE_READS, - wildcard_imports::ENUM_GLOB_USE, - wildcard_imports::WILDCARD_IMPORTS, - write::PRINTLN_EMPTY_STRING, - write::PRINT_LITERAL, - write::PRINT_STDERR, - write::PRINT_STDOUT, - write::PRINT_WITH_NEWLINE, - write::USE_DEBUG, - write::WRITELN_EMPTY_STRING, - write::WRITE_LITERAL, - write::WRITE_WITH_NEWLINE, - zero_div_zero::ZERO_DIVIDED_BY_ZERO, - zero_sized_map_values::ZERO_SIZED_MAP_VALUES, -]) diff --git a/clippy_lints/src/lib.register_pedantic.rs b/clippy_lints/src/lib.register_pedantic.rs deleted file mode 100644 index 69fbc625983b..000000000000 --- a/clippy_lints/src/lib.register_pedantic.rs +++ /dev/null @@ -1,102 +0,0 @@ -// This file was generated by `cargo dev update_lints`. -// Use that command to update this file and do not edit by hand. -// Manual edits will be overwritten. - -store.register_group(true, "clippy::pedantic", Some("clippy_pedantic"), vec![ - LintId::of(attrs::INLINE_ALWAYS), - LintId::of(borrow_as_ptr::BORROW_AS_PTR), - LintId::of(bytecount::NAIVE_BYTECOUNT), - LintId::of(case_sensitive_file_extension_comparisons::CASE_SENSITIVE_FILE_EXTENSION_COMPARISONS), - LintId::of(casts::CAST_LOSSLESS), - LintId::of(casts::CAST_POSSIBLE_TRUNCATION), - LintId::of(casts::CAST_POSSIBLE_WRAP), - LintId::of(casts::CAST_PRECISION_LOSS), - LintId::of(casts::CAST_PTR_ALIGNMENT), - LintId::of(casts::CAST_SIGN_LOSS), - LintId::of(casts::PTR_AS_PTR), - LintId::of(checked_conversions::CHECKED_CONVERSIONS), - LintId::of(copies::SAME_FUNCTIONS_IN_IF_CONDITION), - LintId::of(copy_iterator::COPY_ITERATOR), - LintId::of(default::DEFAULT_TRAIT_ACCESS), - LintId::of(dereference::EXPLICIT_DEREF_METHODS), - LintId::of(dereference::REF_BINDING_TO_REFERENCE), - LintId::of(derive::EXPL_IMPL_CLONE_ON_COPY), - LintId::of(derive::UNSAFE_DERIVE_DESERIALIZE), - LintId::of(doc::DOC_MARKDOWN), - LintId::of(doc::MISSING_ERRORS_DOC), - LintId::of(doc::MISSING_PANICS_DOC), - LintId::of(doc_link_with_quotes::DOC_LINK_WITH_QUOTES), - LintId::of(empty_enum::EMPTY_ENUM), - LintId::of(enum_variants::MODULE_NAME_REPETITIONS), - LintId::of(eta_reduction::REDUNDANT_CLOSURE_FOR_METHOD_CALLS), - LintId::of(excessive_bools::FN_PARAMS_EXCESSIVE_BOOLS), - LintId::of(excessive_bools::STRUCT_EXCESSIVE_BOOLS), - LintId::of(functions::MUST_USE_CANDIDATE), - LintId::of(functions::TOO_MANY_LINES), - LintId::of(if_not_else::IF_NOT_ELSE), - LintId::of(implicit_hasher::IMPLICIT_HASHER), - LintId::of(implicit_saturating_sub::IMPLICIT_SATURATING_SUB), - LintId::of(inconsistent_struct_constructor::INCONSISTENT_STRUCT_CONSTRUCTOR), - LintId::of(infinite_iter::MAYBE_INFINITE_ITER), - LintId::of(invalid_upcast_comparisons::INVALID_UPCAST_COMPARISONS), - LintId::of(items_after_statements::ITEMS_AFTER_STATEMENTS), - LintId::of(iter_not_returning_iterator::ITER_NOT_RETURNING_ITERATOR), - LintId::of(large_stack_arrays::LARGE_STACK_ARRAYS), - LintId::of(let_underscore::LET_UNDERSCORE_DROP), - LintId::of(literal_representation::LARGE_DIGIT_GROUPS), - LintId::of(literal_representation::UNREADABLE_LITERAL), - LintId::of(loops::EXPLICIT_INTO_ITER_LOOP), - LintId::of(loops::EXPLICIT_ITER_LOOP), - LintId::of(macro_use::MACRO_USE_IMPORTS), - LintId::of(manual_assert::MANUAL_ASSERT), - LintId::of(manual_instant_elapsed::MANUAL_INSTANT_ELAPSED), - LintId::of(manual_ok_or::MANUAL_OK_OR), - LintId::of(matches::MATCH_BOOL), - LintId::of(matches::MATCH_ON_VEC_ITEMS), - LintId::of(matches::MATCH_SAME_ARMS), - LintId::of(matches::MATCH_WILDCARD_FOR_SINGLE_VARIANTS), - LintId::of(matches::MATCH_WILD_ERR_ARM), - LintId::of(matches::SINGLE_MATCH_ELSE), - LintId::of(methods::CLONED_INSTEAD_OF_COPIED), - LintId::of(methods::FILTER_MAP_NEXT), - LintId::of(methods::FLAT_MAP_OPTION), - LintId::of(methods::FROM_ITER_INSTEAD_OF_COLLECT), - LintId::of(methods::IMPLICIT_CLONE), - LintId::of(methods::INEFFICIENT_TO_STRING), - LintId::of(methods::MAP_UNWRAP_OR), - LintId::of(methods::UNNECESSARY_JOIN), - LintId::of(misc::USED_UNDERSCORE_BINDING), - LintId::of(mismatching_type_param_order::MISMATCHING_TYPE_PARAM_ORDER), - LintId::of(mut_mut::MUT_MUT), - LintId::of(needless_continue::NEEDLESS_CONTINUE), - LintId::of(needless_for_each::NEEDLESS_FOR_EACH), - LintId::of(needless_pass_by_value::NEEDLESS_PASS_BY_VALUE), - LintId::of(no_effect::NO_EFFECT_UNDERSCORE_BINDING), - LintId::of(non_expressive_names::MANY_SINGLE_CHAR_NAMES), - LintId::of(non_expressive_names::SIMILAR_NAMES), - LintId::of(operators::FLOAT_CMP), - LintId::of(operators::NEEDLESS_BITWISE_BOOL), - LintId::of(operators::VERBOSE_BIT_MASK), - LintId::of(pass_by_ref_or_value::LARGE_TYPES_PASSED_BY_VALUE), - LintId::of(pass_by_ref_or_value::TRIVIALLY_COPY_PASS_BY_REF), - LintId::of(ranges::RANGE_MINUS_ONE), - LintId::of(ranges::RANGE_PLUS_ONE), - LintId::of(redundant_else::REDUNDANT_ELSE), - LintId::of(ref_option_ref::REF_OPTION_REF), - LintId::of(return_self_not_must_use::RETURN_SELF_NOT_MUST_USE), - LintId::of(semicolon_if_nothing_returned::SEMICOLON_IF_NOTHING_RETURNED), - LintId::of(stable_sort_primitive::STABLE_SORT_PRIMITIVE), - LintId::of(strings::STRING_ADD_ASSIGN), - LintId::of(transmute::TRANSMUTE_PTR_TO_PTR), - LintId::of(types::LINKEDLIST), - LintId::of(types::OPTION_OPTION), - LintId::of(unicode::UNICODE_NOT_NFC), - LintId::of(unnecessary_reserve::UNNECESSARY_RESERVE), - LintId::of(unnecessary_wraps::UNNECESSARY_WRAPS), - LintId::of(unnested_or_patterns::UNNESTED_OR_PATTERNS), - LintId::of(unused_async::UNUSED_ASYNC), - LintId::of(unused_self::UNUSED_SELF), - LintId::of(wildcard_imports::ENUM_GLOB_USE), - LintId::of(wildcard_imports::WILDCARD_IMPORTS), - LintId::of(zero_sized_map_values::ZERO_SIZED_MAP_VALUES), -]) From 3ae7b1298fa9fbddf67cf7abcb21a812cc62cb5d Mon Sep 17 00:00:00 2001 From: chansuke Date: Sat, 7 Jan 2023 19:43:38 +0900 Subject: [PATCH 13/21] hotfix: replace `check_block` with `check_expr` --- clippy_lints/src/unnecessary_reserve.rs | 34 ++---- tests/ui/unnecessary_reserve.stderr | 132 +++++++++++++++++------- 2 files changed, 100 insertions(+), 66 deletions(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 0bf3c01979fc..015e58c1f07f 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -1,9 +1,9 @@ use clippy_utils::diagnostics::span_lint_and_then; use clippy_utils::msrvs::{self, Msrv}; -use clippy_utils::{match_def_path, paths, visitors::for_each_expr, SpanlessEq}; +use clippy_utils::{get_enclosing_block, match_def_path, paths, visitors::for_each_expr, SpanlessEq}; use core::ops::ControlFlow; use rustc_errors::Applicability; -use rustc_hir::{Block, ExprKind, PathSegment, StmtKind}; +use rustc_hir::{Block, Expr, ExprKind, PathSegment}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_session::{declare_tool_lint, impl_lint_pass}; @@ -47,17 +47,16 @@ impl UnnecessaryReserve { } impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { - fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) { + fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) { if !self.msrv.meets(msrvs::CHECK_UNNECESSARY_RESERVE) { return; } - for (idx, stmt) in block.stmts.iter().enumerate() { - if let StmtKind::Semi(semi_expr) = stmt.kind - && let ExprKind::MethodCall(PathSegment { ident: method, .. }, struct_calling_on, _, _) = semi_expr.kind + if let ExprKind::MethodCall(PathSegment { ident: method, .. }, struct_calling_on, _, _) = expr.kind && method.name.as_str() == "reserve" && acceptable_type(cx, struct_calling_on) - && let Some(next_stmt_span) = check_extend_method(cx, block, idx, struct_calling_on) + && let Some(block) = get_enclosing_block(cx, expr.hir_id) + && let Some(next_stmt_span) = check_extend_method(cx, block, struct_calling_on) && !next_stmt_span.from_expansion() { span_lint_and_then( @@ -67,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { "unnecessary call to `reserve`", |diag| { diag.span_suggestion( - semi_expr.span, + expr.span, "remove this line", String::new(), Applicability::MaybeIncorrect, @@ -75,7 +74,6 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { } ); } - } } extract_msrv_attr!(LateContext); @@ -96,7 +94,6 @@ fn acceptable_type(cx: &LateContext<'_>, struct_calling_on: &rustc_hir::Expr<'_> fn check_extend_method( cx: &LateContext<'_>, block: &Block<'_>, - idx: usize, struct_expr: &rustc_hir::Expr<'_>, ) -> Option { let mut read_found = false; @@ -116,20 +113,5 @@ fn check_extend_method( ControlFlow::Continue(()) }); - let next_stmt_span: rustc_span::Span = if idx == block.stmts.len() - 1 { - if let Some(e) = block.expr { - e.span - } else { - return None; - } - } else { - let next_stmt = &block.stmts[idx + 1]; - return Some(next_stmt.span); - }; - - if read_found { - return Some(next_stmt_span); - } - - None + if read_found { Some(block.span) } else { None } } diff --git a/tests/ui/unnecessary_reserve.stderr b/tests/ui/unnecessary_reserve.stderr index 65f62d5d6d6f..75308423d020 100644 --- a/tests/ui/unnecessary_reserve.stderr +++ b/tests/ui/unnecessary_reserve.stderr @@ -1,68 +1,120 @@ error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:20:5 + --> $DIR/unnecessary_reserve.rs:14:18 | -LL | vec.reserve(1); - | -------------- help: remove this line -LL | vec.extend([1]); - | ^^^^^^^^^^^^^^^^ +LL | fn vec_reserve() { + | __________________^ +LL | | let mut vec: Vec = vec![]; +LL | | let array: &[usize] = &[1, 2]; +LL | | +LL | | // do not lint +LL | | vec.reserve(1); + | | -------------- help: remove this line +... | +LL | | vec.extend([1]) +LL | | } + | |_^ | = note: `-D clippy::unnecessary-reserve` implied by `-D warnings` error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:24:5 + --> $DIR/unnecessary_reserve.rs:14:18 | -LL | vec.reserve(array.len()); - | ------------------------ help: remove this line -LL | vec.extend(array); - | ^^^^^^^^^^^^^^^^^^ +LL | fn vec_reserve() { + | __________________^ +LL | | let mut vec: Vec = vec![]; +LL | | let array: &[usize] = &[1, 2]; +LL | | +... | +LL | | vec.reserve(array.len()); + | | ------------------------ help: remove this line +... | +LL | | vec.extend([1]) +LL | | } + | |_^ error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:34:5 + --> $DIR/unnecessary_reserve.rs:27:5 | -LL | vec.reserve(array.len()); - | ------------------------ help: remove this line -LL | vec.push(1); - | ^^^^^^^^^^^^ +LL | / { +LL | | vec.reserve(array.len()); + | | ------------------------ help: remove this line +LL | | vec.extend(array) +LL | | }; + | |_____^ error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:29:9 + --> $DIR/unnecessary_reserve.rs:14:18 | -LL | vec.reserve(array.len()); - | ------------------------ help: remove this line -LL | vec.extend(array) - | ^^^^^^^^^^^^^^^^^ +LL | fn vec_reserve() { + | __________________^ +LL | | let mut vec: Vec = vec![]; +LL | | let array: &[usize] = &[1, 2]; +LL | | +... | +LL | | vec.reserve(array.len()); + | | ------------------------ help: remove this line +... | +LL | | vec.extend([1]) +LL | | } + | |_^ error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:49:5 + --> $DIR/unnecessary_reserve.rs:43:24 | -LL | vec_deque.reserve(1); - | -------------------- help: remove this line -LL | vec_deque.extend([1]); - | ^^^^^^^^^^^^^^^^^^^^^^ +LL | fn vec_deque_reserve() { + | ________________________^ +LL | | let mut vec_deque: VecDeque = [1].into(); +LL | | let array: &[usize] = &[1, 2]; +LL | | +LL | | // do not lint +LL | | vec_deque.reserve(1); + | | -------------------- help: remove this line +... | +LL | | vec_deque.extend([1]) +LL | | } + | |_^ error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:53:5 + --> $DIR/unnecessary_reserve.rs:43:24 | -LL | vec_deque.reserve(array.len()); - | ------------------------------ help: remove this line -LL | vec_deque.extend(array); - | ^^^^^^^^^^^^^^^^^^^^^^^^ +LL | fn vec_deque_reserve() { + | ________________________^ +LL | | let mut vec_deque: VecDeque = [1].into(); +LL | | let array: &[usize] = &[1, 2]; +LL | | +... | +LL | | vec_deque.reserve(array.len()); + | | ------------------------------ help: remove this line +... | +LL | | vec_deque.extend([1]) +LL | | } + | |_^ error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:63:5 + --> $DIR/unnecessary_reserve.rs:56:5 | -LL | vec_deque.reserve(array.len() + 1); - | ---------------------------------- help: remove this line -LL | vec_deque.push_back(1); - | ^^^^^^^^^^^^^^^^^^^^^^^ +LL | / { +LL | | vec_deque.reserve(1); + | | -------------------- help: remove this line +LL | | vec_deque.extend([1]) +LL | | }; + | |_____^ error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:58:9 + --> $DIR/unnecessary_reserve.rs:43:24 | -LL | vec_deque.reserve(1); - | -------------------- help: remove this line -LL | vec_deque.extend([1]) - | ^^^^^^^^^^^^^^^^^^^^^ +LL | fn vec_deque_reserve() { + | ________________________^ +LL | | let mut vec_deque: VecDeque = [1].into(); +LL | | let array: &[usize] = &[1, 2]; +LL | | +... | +LL | | vec_deque.reserve(array.len() + 1); + | | ---------------------------------- help: remove this line +... | +LL | | vec_deque.extend([1]) +LL | | } + | |_^ error: aborting due to 8 previous errors From 37fd6b3ddf1a8c4d35bd599d3248bd8f0beaf9dc Mon Sep 17 00:00:00 2001 From: chansuke Date: Sat, 7 Jan 2023 21:44:47 +0900 Subject: [PATCH 14/21] hotfix: prevent linting raw int --- clippy_lints/src/unnecessary_reserve.rs | 8 +++- tests/ui/unnecessary_reserve.stderr | 64 ++----------------------- 2 files changed, 9 insertions(+), 63 deletions(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 015e58c1f07f..9caf0250dea7 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -52,11 +52,11 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { return; } - if let ExprKind::MethodCall(PathSegment { ident: method, .. }, struct_calling_on, _, _) = expr.kind + if let ExprKind::MethodCall(PathSegment { ident: method, .. }, struct_calling_on, args_a, _) = expr.kind && method.name.as_str() == "reserve" && acceptable_type(cx, struct_calling_on) && let Some(block) = get_enclosing_block(cx, expr.hir_id) - && let Some(next_stmt_span) = check_extend_method(cx, block, struct_calling_on) + && let Some(next_stmt_span) = check_extend_method(cx, block, struct_calling_on, &args_a[0]) && !next_stmt_span.from_expansion() { span_lint_and_then( @@ -95,13 +95,17 @@ fn check_extend_method( cx: &LateContext<'_>, block: &Block<'_>, struct_expr: &rustc_hir::Expr<'_>, + args_a: &rustc_hir::Expr<'_>, ) -> Option { + let args_a_kind = &args_a.kind; let mut read_found = false; let mut spanless_eq = SpanlessEq::new(cx); let _: Option = for_each_expr(block, |expr| { if let ExprKind::MethodCall(_, struct_calling_on, _,_) = expr.kind && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let ExprKind::MethodCall(PathSegment { ident: method_call_a, .. },..) = args_a_kind + && method_call_a.name.as_str() == "len" && match_def_path(cx, expr_def_id, &paths::ITER_EXTEND) && acceptable_type(cx, struct_calling_on) // Check that both expr are equal diff --git a/tests/ui/unnecessary_reserve.stderr b/tests/ui/unnecessary_reserve.stderr index 75308423d020..23cb227924cc 100644 --- a/tests/ui/unnecessary_reserve.stderr +++ b/tests/ui/unnecessary_reserve.stderr @@ -1,21 +1,3 @@ -error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:14:18 - | -LL | fn vec_reserve() { - | __________________^ -LL | | let mut vec: Vec = vec![]; -LL | | let array: &[usize] = &[1, 2]; -LL | | -LL | | // do not lint -LL | | vec.reserve(1); - | | -------------- help: remove this line -... | -LL | | vec.extend([1]) -LL | | } - | |_^ - | - = note: `-D clippy::unnecessary-reserve` implied by `-D warnings` - error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:14:18 | @@ -31,6 +13,8 @@ LL | | vec.reserve(array.len()); LL | | vec.extend([1]) LL | | } | |_^ + | + = note: `-D clippy::unnecessary-reserve` implied by `-D warnings` error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:27:5 @@ -58,22 +42,6 @@ LL | | vec.extend([1]) LL | | } | |_^ -error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:43:24 - | -LL | fn vec_deque_reserve() { - | ________________________^ -LL | | let mut vec_deque: VecDeque = [1].into(); -LL | | let array: &[usize] = &[1, 2]; -LL | | -LL | | // do not lint -LL | | vec_deque.reserve(1); - | | -------------------- help: remove this line -... | -LL | | vec_deque.extend([1]) -LL | | } - | |_^ - error: unnecessary call to `reserve` --> $DIR/unnecessary_reserve.rs:43:24 | @@ -90,31 +58,5 @@ LL | | vec_deque.extend([1]) LL | | } | |_^ -error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:56:5 - | -LL | / { -LL | | vec_deque.reserve(1); - | | -------------------- help: remove this line -LL | | vec_deque.extend([1]) -LL | | }; - | |_____^ - -error: unnecessary call to `reserve` - --> $DIR/unnecessary_reserve.rs:43:24 - | -LL | fn vec_deque_reserve() { - | ________________________^ -LL | | let mut vec_deque: VecDeque = [1].into(); -LL | | let array: &[usize] = &[1, 2]; -LL | | -... | -LL | | vec_deque.reserve(array.len() + 1); - | | ---------------------------------- help: remove this line -... | -LL | | vec_deque.extend([1]) -LL | | } - | |_^ - -error: aborting due to 8 previous errors +error: aborting due to 4 previous errors From 37eb8c3c0e0eb05605d540891095a7c887013a25 Mon Sep 17 00:00:00 2001 From: chansuke Date: Sat, 7 Jan 2023 21:55:20 +0900 Subject: [PATCH 15/21] refactor: use `rustc_span::sym` for method name comparison --- clippy_lints/src/unnecessary_reserve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 9caf0250dea7..7a5c89aba7f3 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -105,7 +105,7 @@ fn check_extend_method( if let ExprKind::MethodCall(_, struct_calling_on, _,_) = expr.kind && let Some(expr_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) && let ExprKind::MethodCall(PathSegment { ident: method_call_a, .. },..) = args_a_kind - && method_call_a.name.as_str() == "len" + && method_call_a.name == rustc_span::sym::len && match_def_path(cx, expr_def_id, &paths::ITER_EXTEND) && acceptable_type(cx, struct_calling_on) // Check that both expr are equal From 1f087652b6d5463c4ce6b047cf401738d6c4a82a Mon Sep 17 00:00:00 2001 From: chansuke Date: Tue, 7 Feb 2023 22:24:48 +0900 Subject: [PATCH 16/21] hotfix: remove unnecessary path --- clippy_utils/src/paths.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs index 664b7e772cfd..1a875d3f7b50 100644 --- a/clippy_utils/src/paths.rs +++ b/clippy_utils/src/paths.rs @@ -50,8 +50,6 @@ pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"]; pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"]; pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"]; pub const ITER_EXTEND: [&str; 6] = ["core", "iter", "traits", "collect", "Extend", "extend"]; -pub const ITER_REPEAT: [&str; 5] = ["core", "iter", "sources", "repeat", "repeat"]; -#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"]; #[cfg(feature = "internal")] pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"]; From 2da64a9160ea31c94d7f2c99ded0b260fae16bdd Mon Sep 17 00:00:00 2001 From: chansuke Date: Tue, 7 Feb 2023 22:26:20 +0900 Subject: [PATCH 17/21] hotfix: update declare_lints name --- clippy_lints/src/declared_lints.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs index 9836b752a645..1e4851ed8b01 100644 --- a/clippy_lints/src/declared_lints.rs +++ b/clippy_lints/src/declared_lints.rs @@ -624,7 +624,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[ crate::unnamed_address::VTABLE_ADDRESS_COMPARISONS_INFO, crate::unnecessary_box_returns::UNNECESSARY_BOX_RETURNS_INFO, crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO, - crate::unnecessary_reserve::UNNECESSARY_RESERVE_INFO, + crate::unnecessary_reserve::UNNECESSARY_RESERVE, crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO, crate::unnecessary_struct_initialization::UNNECESSARY_STRUCT_INITIALIZATION_INFO, crate::unnecessary_wraps::UNNECESSARY_WRAPS_INFO, From 4df0eba0e5c843048daaf2c15e8489eabc1918d9 Mon Sep 17 00:00:00 2001 From: chansuke Date: Tue, 7 Feb 2023 22:29:44 +0900 Subject: [PATCH 18/21] refactor: update MSRV constant name to follow naming convention --- clippy_lints/src/unnecessary_reserve.rs | 2 +- clippy_utils/src/msrvs.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 7a5c89aba7f3..2372e5852313 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -48,7 +48,7 @@ impl UnnecessaryReserve { impl<'tcx> LateLintPass<'tcx> for UnnecessaryReserve { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) { - if !self.msrv.meets(msrvs::CHECK_UNNECESSARY_RESERVE) { + if !self.msrv.meets(msrvs::EXTEND_IMPLICIT_RESERVE) { return; } diff --git a/clippy_utils/src/msrvs.rs b/clippy_utils/src/msrvs.rs index d82e4eba4add..b22deaea6ec2 100644 --- a/clippy_utils/src/msrvs.rs +++ b/clippy_utils/src/msrvs.rs @@ -21,7 +21,7 @@ macro_rules! msrv_aliases { msrv_aliases! { 1,68,0 { PATH_MAIN_SEPARATOR_STR } 1,65,0 { LET_ELSE } - 1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, CHECK_UNNECESSARY_RESERVE } + 1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, EXTEND_IMPLICIT_RESERVE } 1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY } 1,55,0 { SEEK_REWIND } 1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR } From 452717bd441111af8ea9333d8c8357b2d4a50ebb Mon Sep 17 00:00:00 2001 From: chansuke Date: Tue, 7 Feb 2023 23:21:58 +0900 Subject: [PATCH 19/21] hotfix: rollback declare lints name --- clippy_lints/src/declared_lints.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs index 1e4851ed8b01..9836b752a645 100644 --- a/clippy_lints/src/declared_lints.rs +++ b/clippy_lints/src/declared_lints.rs @@ -624,7 +624,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[ crate::unnamed_address::VTABLE_ADDRESS_COMPARISONS_INFO, crate::unnecessary_box_returns::UNNECESSARY_BOX_RETURNS_INFO, crate::unnecessary_owned_empty_strings::UNNECESSARY_OWNED_EMPTY_STRINGS_INFO, - crate::unnecessary_reserve::UNNECESSARY_RESERVE, + crate::unnecessary_reserve::UNNECESSARY_RESERVE_INFO, crate::unnecessary_self_imports::UNNECESSARY_SELF_IMPORTS_INFO, crate::unnecessary_struct_initialization::UNNECESSARY_STRUCT_INITIALIZATION_INFO, crate::unnecessary_wraps::UNNECESSARY_WRAPS_INFO, From 696c11e5f7daca8200d2dd32add0c650fd1e7d80 Mon Sep 17 00:00:00 2001 From: chansuke Date: Sat, 25 Feb 2023 20:16:36 +0900 Subject: [PATCH 20/21] hotfix: add type annotation to let binding --- clippy_lints/src/unnecessary_reserve.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clippy_lints/src/unnecessary_reserve.rs b/clippy_lints/src/unnecessary_reserve.rs index 2372e5852313..03fb7c31d64d 100644 --- a/clippy_lints/src/unnecessary_reserve.rs +++ b/clippy_lints/src/unnecessary_reserve.rs @@ -113,7 +113,7 @@ fn check_extend_method( { read_found = true; } - let _ = !read_found; + let _: bool = !read_found; ControlFlow::Continue(()) }); From f3dda972e58565929e422ae8f1ff145fe6b05d09 Mon Sep 17 00:00:00 2001 From: chansuke Date: Tue, 11 Apr 2023 22:56:25 +0900 Subject: [PATCH 21/21] hotfix: deduplicate registration --- clippy_lints/src/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs index baf366a03263..e0b1351b830e 100644 --- a/clippy_lints/src/lib.rs +++ b/clippy_lints/src/lib.rs @@ -960,7 +960,6 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf: store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule)); store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation)); store.register_early_pass(|| Box::new(suspicious_doc_comments::SuspiciousDocComments)); - store.register_late_pass(move || Box::new(unnecessary_reserve::UnnecessaryReserve::new(msrv))); store.register_late_pass(move |_| Box::new(unnecessary_reserve::UnnecessaryReserve::new(msrv()))); // add lints here, do not remove this comment, it's used in `new_lint` }