Module builtin

Some lints that are built in to the compiler.

These are the built-in lints that are emitted direct in the main compiler code, rather than using their own custom pass. Those lints are all available in rustc_lint::builtin.

When removing a lint, make sure to also add a call to register_removed in compiler/rustc_lint/src/lib.rs.

Structs

HardwiredLints

Does nothing as a lint pass, but registers some Lints that are used by other parts of the compiler.

UnusedDocComment

Statics

AARCH64_SOFTFLOAT_NEON

The aarch64_softfloat_neon lint detects usage of #[target_feature(enable = "neon")] on softfloat aarch64 targets. Enabling this target feature causes LLVM to alter the ABI of function calls, making this attribute unsound to use.

ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE

The absolute_paths_not_starting_with_crate lint detects fully qualified paths that start with a module name instead of crate, self, or an extern crate name

AMBIGUOUS_ASSOCIATED_ITEMS

The ambiguous_associated_items lint detects ambiguity between associated items and enum variants.

AMBIGUOUS_GLOB_IMPORTS

The ambiguous_glob_imports lint detects glob imports that should report ambiguity errors, but previously didn’t do that due to rustc bugs.

AMBIGUOUS_GLOB_REEXPORTS

The ambiguous_glob_reexports lint detects cases where names re-exported via globs collide. Downstream users trying to use the same name re-exported from multiple globs will receive a warning pointing out redefinition of the same name.

ARITHMETIC_OVERFLOW

The arithmetic_overflow lint detects that an arithmetic operation will overflow.

ASM_SUB_REGISTER

The asm_sub_register lint detects using only a subset of a register for inline asm inputs.

BAD_ASM_STYLE

The bad_asm_style lint detects the use of the .intel_syntax and .att_syntax directives.

BARE_TRAIT_OBJECTS

The bare_trait_objects lint suggests using dyn Trait for trait objects.

BINDINGS_WITH_VARIANT_NAME

The bindings_with_variant_name lint detects pattern bindings with the same name as one of the matched variants.

BREAK_WITH_LABEL_AND_LOOP

The break_with_label_and_loop lint detects labeled break expressions with an unlabeled loop as their value expression.

COHERENCE_LEAK_CHECK

The coherence_leak_check lint detects conflicting implementations of a trait that are only distinguished by the old leak-check code.

CONFLICTING_REPR_HINTS

The conflicting_repr_hints lint detects repr attributes with conflicting hints.

CONST_EVALUATABLE_UNCHECKED

The const_evaluatable_unchecked lint detects a generic constant used in a type.

CONST_ITEM_MUTATION

The const_item_mutation lint detects attempts to mutate a const item.

DEAD_CODE

The dead_code lint detects unused, unexported items.

DEPENDENCY_ON_UNIT_NEVER_TYPE_FALLBACK

The dependency_on_unit_never_type_fallback lint detects cases where code compiles with never type fallback being (), but will stop compiling with fallback being !.

DEPRECATED

The deprecated lint detects use of deprecated items.

DEPRECATED_IN_FUTURE

The deprecated_in_future lint is internal to rustc and should not be used by user code.

DEPRECATED_SAFE_2024

The deprecated_safe_2024 lint detects unsafe functions being used as safe functions.

DEPRECATED_WHERE_CLAUSE_LOCATION

The deprecated_where_clause_location lint detects when a where clause in front of the equals in an associated type.

DUPLICATE_MACRO_ATTRIBUTES

The duplicate_macro_attributes lint detects when a #[test]-like built-in macro attribute is duplicated on an item. This lint may trigger on bench, cfg_eval, test and test_case.

ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT

The elided_lifetimes_in_associated_constant lint detects elided lifetimes in associated constants when there are other lifetimes in scope. This was accidentally supported, and this lint was later relaxed to allow eliding lifetimes to 'static when there are no lifetimes in scope.

ELIDED_LIFETIMES_IN_PATHS

The elided_lifetimes_in_paths lint detects the use of hidden lifetime parameters.

EXPLICIT_BUILTIN_CFGS_IN_FLAGS

The explicit_builtin_cfgs_in_flags lint detects builtin cfgs set via the --cfg flag.

EXPLICIT_OUTLIVES_REQUIREMENTS

The explicit_outlives_requirements lint detects unnecessary lifetime bounds that can be inferred.

EXPORTED_PRIVATE_DEPENDENCIES

The exported_private_dependencies lint detects private dependencies that are exposed in a public interface.

FFI_UNWIND_CALLS

The ffi_unwind_calls lint detects calls to foreign functions or function pointers with C-unwind or other FFI-unwind ABIs.

FORBIDDEN_LINT_GROUPS

The forbidden_lint_groups lint detects violations of forbid applied to a lint group. Due to a bug in the compiler, these used to be overlooked entirely. They now generate a warning.

FUNCTION_ITEM_REFERENCES

The function_item_references lint detects function references that are formatted with fmt::Pointer or transmuted.

FUZZY_PROVENANCE_CASTS

The fuzzy_provenance_casts lint detects an as cast between an integer and a pointer.

HIDDEN_GLOB_REEXPORTS

The hidden_glob_reexports lint detects cases where glob re-export items are shadowed by private items.

ILL_FORMED_ATTRIBUTE_INPUT

The ill_formed_attribute_input lint detects ill-formed attribute inputs that were previously accepted and used in practice.

INCOMPLETE_INCLUDE

The incomplete_include lint detects the use of the include! macro with a file that contains more than one expression.

INEFFECTIVE_UNSTABLE_TRAIT_IMPL

The ineffective_unstable_trait_impl lint detects #[unstable] attributes which are not used.

INLINE_NO_SANITIZE

The inline_no_sanitize lint detects incompatible use of #[inline(always)] and #[no_sanitize(...)].

INVALID_DOC_ATTRIBUTES

The invalid_doc_attributes lint detects when the #[doc(...)] is misused.

INVALID_MACRO_EXPORT_ARGUMENTS

The invalid_macro_export_arguments lint detects cases where #[macro_export] is being used with invalid arguments.

INVALID_TYPE_PARAM_DEFAULT

The invalid_type_param_default lint detects type parameter defaults erroneously allowed in an invalid location.

IRREFUTABLE_LET_PATTERNS

The irrefutable_let_patterns lint detects irrefutable patterns in if lets, while lets, and if let guards.

LARGE_ASSIGNMENTS

The large_assignments lint detects when objects of large types are being moved around.

LATE_BOUND_LIFETIME_ARGUMENTS

The late_bound_lifetime_arguments lint detects generic lifetime arguments in path segments with late bound lifetime parameters.

LEGACY_DERIVE_HELPERS

The legacy_derive_helpers lint detects derive helper attributes that are used before they are introduced.

LINKER_MESSAGES

The linker_messages lint forwards warnings from the linker.

LONG_RUNNING_CONST_EVAL

The long_running_const_eval lint is emitted when const eval is running for a long time to ensure rustc terminates even if you accidentally wrote an infinite loop.

LOSSY_PROVENANCE_CASTS

The lossy_provenance_casts lint detects an as cast between a pointer and an integer.

MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS

The macro_expanded_macro_exports_accessed_by_absolute_paths lint detects macro-expanded macro_export macros from the current crate that cannot be referred to by absolute paths.

MACRO_USE_EXTERN_CRATE

The macro_use_extern_crate lint detects the use of the macro_use attribute.

MALFORMED_DIAGNOSTIC_ATTRIBUTES

The malformed_diagnostic_attributes lint detects malformed diagnostic attributes.

MALFORMED_DIAGNOSTIC_FORMAT_LITERALS

The malformed_diagnostic_format_literals lint detects malformed diagnostic format literals.

META_VARIABLE_MISUSE

The meta_variable_misuse lint detects possible meta-variable misuse in macro definitions.

MISPLACED_DIAGNOSTIC_ATTRIBUTES

The misplaced_diagnostic_attributes lint detects wrongly placed diagnostic attributes.

MISSING_ABI

The missing_abi lint detects cases where the ABI is omitted from extern declarations.

MISSING_UNSAFE_ON_EXTERN

The missing_unsafe_on_extern lint detects missing unsafe keyword on extern declarations.

MUST_NOT_SUSPEND

The must_not_suspend lint guards against values that shouldn’t be held across suspend points (.await)

NAMED_ARGUMENTS_USED_POSITIONALLY

The named_arguments_used_positionally lint detects cases where named arguments are only used positionally in format strings. This usage is valid but potentially very confusing.

NEVER_TYPE_FALLBACK_FLOWING_INTO_UNSAFE

The never_type_fallback_flowing_into_unsafe lint detects cases where never type fallback affects unsafe function calls.

NON_CONTIGUOUS_RANGE_ENDPOINTS

The non_contiguous_range_endpoints lint detects likely off-by-one errors when using exclusive range patterns.

NON_EXHAUSTIVE_OMITTED_PATTERNS

The non_exhaustive_omitted_patterns lint aims to help consumers of a #[non_exhaustive] struct or enum who want to match all of its fields/variants explicitly.

OUT_OF_SCOPE_MACRO_CALLS

The out_of_scope_macro_calls lint detects macro_rules called when they are not in scope, above their definition, which may happen in key-value attributes.

OVERLAPPING_RANGE_ENDPOINTS

The overlapping_range_endpoints lint detects match arms that have range patterns that overlap on their endpoints.

PATTERNS_IN_FNS_WITHOUT_BODY

The patterns_in_fns_without_body lint detects mut identifier patterns as a parameter in functions without a body.

PRIVATE_BOUNDS

The private_bounds lint detects types in a secondary interface of an item, that are more private than the item itself. Secondary interface of an item consists of bounds on generic parameters and where clauses, including supertraits for trait items.

PRIVATE_INTERFACES

The private_interfaces lint detects types in a primary interface of an item, that are more private than the item itself. Primary interface of an item is all its interface except for bounds on generic parameters and where clauses.

PRIVATE_MACRO_USE

The private_macro_use lint detects private macros that are imported with #[macro_use].

PROC_MACRO_DERIVE_RESOLUTION_FALLBACK

The proc_macro_derive_resolution_fallback lint detects proc macro derives using inaccessible names from parent modules.

PUB_USE_OF_PRIVATE_EXTERN_CRATE

The pub_use_of_private_extern_crate lint detects a specific situation of re-exporting a private extern crate.

REDUNDANT_IMPORTS

The redundant_imports lint detects imports that are redundant due to being imported already; either through a previous import, or being present in the prelude.

REDUNDANT_LIFETIMES

The redundant_lifetimes lint detects lifetime parameters that are redundant because they are equal to another named lifetime.

REFINING_IMPL_TRAIT_INTERNAL

The refining_impl_trait_internal lint detects impl Trait return types in method signatures that are refined by a trait implementation, meaning the implementation adds information about the return type that is not present in the trait.

REFINING_IMPL_TRAIT_REACHABLE

The refining_impl_trait_reachable lint detects impl Trait return types in method signatures that are refined by a publically reachable trait implementation, meaning the implementation adds information about the return type that is not present in the trait.

RENAMED_AND_REMOVED_LINTS

The renamed_and_removed_lints lint detects lints that have been renamed or removed.

REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS

The repr_transparent_external_private_fields lint detects types marked #[repr(transparent)] that (transitively) contain an external ZST type marked #[non_exhaustive] or containing private fields

RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES

The rust_2021_incompatible_closure_captures lint detects variables that aren’t completely captured in Rust 2021, such that the Drop order of their fields may differ between Rust 2018 and 2021.

RUST_2021_INCOMPATIBLE_OR_PATTERNS

The rust_2021_incompatible_or_patterns lint detects usage of old versions of or-patterns.

RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX

The rust_2021_prefixes_incompatible_syntax lint detects identifiers that will be parsed as a prefix instead in Rust 2021.

RUST_2021_PRELUDE_COLLISIONS

The rust_2021_prelude_collisions lint detects the usage of trait methods which are ambiguous with traits added to the prelude in future editions.

RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX

The rust_2024_guarded_string_incompatible_syntax lint detects # tokens that will be parsed as part of a guarded string literal in Rust 2024.

RUST_2024_INCOMPATIBLE_PAT

The rust_2024_incompatible_pat lint detects patterns whose meaning will change in the Rust 2024 edition.

RUST_2024_PRELUDE_COLLISIONS

The rust_2024_prelude_collisions lint detects the usage of trait methods which are ambiguous with traits added to the prelude in future editions.

SELF_CONSTRUCTOR_FROM_OUTER_ITEM

The self_constructor_from_outer_item lint detects cases where the Self constructor was silently allowed due to a bug in the resolver, and which may produce surprising and unintended behavior.

SEMICOLON_IN_EXPRESSIONS_FROM_MACROS

The semicolon_in_expressions_from_macros lint detects trailing semicolons in macro bodies when the macro is invoked in expression position. This was previous accepted, but is being phased out.

SINGLE_USE_LIFETIMES

The single_use_lifetimes lint detects lifetimes that are only used once.

SOFT_UNSTABLE

The soft_unstable lint detects unstable features that were unintentionally allowed on stable. This is a future-incompatible lint to transition this to a hard error in the future. See issue #64266 for more details.

STABLE_FEATURES

The stable_features lint detects a feature attribute that has since been made stable.

SUPERTRAIT_ITEM_SHADOWING_DEFINITION

The supertrait_item_shadowing_definition lint detects when the definition of an item that is provided by both a subtrait and supertrait is shadowed, preferring the subtrait.

SUPERTRAIT_ITEM_SHADOWING_USAGE

The supertrait_item_shadowing_usage lint detects when the usage of an item that is provided by both a subtrait and supertrait is shadowed, preferring the subtrait.

TAIL_EXPR_DROP_ORDER

The tail_expr_drop_order lint looks for those values generated at the tail expression location, that runs a custom Drop destructor. Some of them may be dropped earlier in Edition 2024 that they used to in Edition 2021 and prior. This lint detects those cases and provides you information on those values and their custom destructor implementations. Your discretion on this information is required.

TEST_UNSTABLE_LINT

The test_unstable_lint lint tests unstable lints and is perma-unstable.

TEXT_DIRECTION_CODEPOINT_IN_COMMENT

The text_direction_codepoint_in_comment lint detects Unicode codepoints in comments that change the visual representation of text on screen in a way that does not correspond to their on memory representation.

TEXT_DIRECTION_CODEPOINT_IN_LITERAL

The text_direction_codepoint_in_literal lint detects Unicode codepoints that change the visual representation of text on screen in a way that does not correspond to their on memory representation.

TRIVIAL_CASTS

The trivial_casts lint detects trivial casts which could be replaced with coercion, which may require a temporary variable.

TRIVIAL_NUMERIC_CASTS

The trivial_numeric_casts lint detects trivial numeric casts of types which could be removed.

TYVAR_BEHIND_RAW_POINTER

The tyvar_behind_raw_pointer lint detects raw pointer to an inference variable.

UNCONDITIONAL_PANIC

The unconditional_panic lint detects an operation that will cause a panic at runtime.

UNCONDITIONAL_RECURSION

The unconditional_recursion lint detects functions that cannot return without calling themselves.

UNCOVERED_PARAM_IN_PROJECTION

The uncovered_param_in_projection lint detects a violation of one of Rust’s orphan rules for foreign trait implementations that concerns the use of type parameters inside trait associated type paths (“projections”) whose output may not be a local type that is mistakenly considered to “cover” said parameters which is unsound and which may be rejected by a future version of the compiler.

UNEXPECTED_CFGS

The unexpected_cfgs lint detects unexpected conditional compilation conditions.

UNFULFILLED_LINT_EXPECTATIONS

The unfulfilled_lint_expectations lint detects when a lint expectation is unfulfilled.

UNINHABITED_STATIC

The uninhabited_static lint detects uninhabited statics.

UNKNOWN_CRATE_TYPES

The unknown_crate_types lint detects an unknown crate type found in a crate_type attribute.

UNKNOWN_DIAGNOSTIC_ATTRIBUTES

The unknown_diagnostic_attributes lint detects unknown diagnostic attributes.

UNKNOWN_LINTS

The unknown_lints lint detects unrecognized lint attributes.

UNNAMEABLE_TEST_ITEMS

The unnameable_test_items lint detects #[test] functions that are not able to be run by the test harness because they are in a position where they are not nameable.

UNNAMEABLE_TYPES

The unnameable_types lint detects types for which you can get objects of that type, but cannot name the type itself.

UNREACHABLE_CODE

The unreachable_code lint detects unreachable code paths.

UNREACHABLE_PATTERNS

The unreachable_patterns lint detects unreachable patterns.

UNSAFE_ATTR_OUTSIDE_UNSAFE

The unsafe_attr_outside_unsafe lint detects a missing unsafe keyword on attributes considered unsafe.

UNSAFE_OP_IN_UNSAFE_FN

The unsafe_op_in_unsafe_fn lint detects unsafe operations in unsafe functions without an explicit unsafe block.

UNSTABLE_NAME_COLLISIONS

The unstable_name_collisions lint detects that you have used a name that the standard library plans to add in the future.

UNSTABLE_SYNTAX_PRE_EXPANSION

The unstable_syntax_pre_expansion lint detects the use of unstable syntax that is discarded during attribute expansion.

UNSUPPORTED_CALLING_CONVENTIONS

The unsupported_calling_conventions lint is output whenever there is a use of the stdcall, fastcall, and cdecl calling conventions (or their unwind variants) on targets that cannot meaningfully be supported for the requested target.

UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS

The unsupported_fn_ptr_calling_conventions lint is output whenever there is a use of a target dependent calling convention on a target that does not support this calling convention on a function pointer.

UNUSED_ASSIGNMENTS

The unused_assignments lint detects assignments that will never be read.

UNUSED_ASSOCIATED_TYPE_BOUNDS

The unused_associated_type_bounds lint is emitted when an associated type bound is added to a trait object, but the associated type has a where Self: Sized bound, and is thus unavailable on the trait object anyway.

UNUSED_ATTRIBUTES

The unused_attributes lint detects attributes that were not used by the compiler.

UNUSED_CRATE_DEPENDENCIES

The unused_crate_dependencies lint detects crate dependencies that are never used.

UNUSED_DOC_COMMENTS

The unused_doc_comments lint detects doc comments that aren’t used by rustdoc.

UNUSED_EXTERN_CRATES

The unused_extern_crates lint guards against extern crate items that are never used.

UNUSED_FEATURES

The unused_features lint detects unused or unknown features found in crate-level feature attributes.

UNUSED_IMPORTS

The unused_imports lint detects imports that are never used.

UNUSED_LABELS

The unused_labels lint detects labels that are never used.

UNUSED_LIFETIMES

The unused_lifetimes lint detects lifetime parameters that are never used.

UNUSED_MACROS

The unused_macros lint detects macros that were not used.

UNUSED_MACRO_RULES

The unused_macro_rules lint detects macro rules that were not used.

UNUSED_MUT

The unused_mut lint detects mut variables which don’t need to be mutable.

UNUSED_QUALIFICATIONS

The unused_qualifications lint detects unnecessarily qualified names.

UNUSED_UNSAFE

The unused_unsafe lint detects unnecessary use of an unsafe block.

UNUSED_VARIABLES

The unused_variables lint detects variables which are not used in any way.

USELESS_DEPRECATED

The useless_deprecated lint detects deprecation attributes with no effect.

WARNINGS

The warnings lint allows you to change the level of other lints which produce warnings.