Module builtin

Expand description

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§

ABI_UNSUPPORTED_VECTOR_TYPES: The abi_unsupported_vector_types lint detects function definitions and calls whose ABI depends on enabling certain target features, but those features are not enabled.
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.
ELIDED_NAMED_LIFETIMES: The elided_named_lifetimes lint detects when an elided lifetime ends up being a named lifetime, such as 'static or some lifetime parameter 'a.
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.
META_VARIABLE_MISUSE: The meta_variable_misuse lint detects possible meta-variable misuse in macro definitions.
MISSING_ABI: The missing_abi lint detects cases where the ABI is omitted from extern declarations.
MISSING_FRAGMENT_SPECIFIER: The missing_fragment_specifier lint is issued when an unused pattern in a macro_rules! macro definition has a meta-variable (e.g. $e) that is not followed by a fragment specifier (e.g. :expr).
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.
PTR_TO_INTEGER_TRANSMUTE_IN_CONSTS: The ptr_to_integer_transmute_in_consts lint detects pointer to integer transmute in const functions and associated constants.
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.
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.
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_LINTS: The unknown_lints lint detects unrecognized lint attributes.
UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES: The unknown_or_malformed_diagnostic_attributes lint detects unrecognized or otherwise malformed diagnostic 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_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.
WASM_C_ABI: The wasm_c_abi lint detects usage of the extern "C" ABI of wasm that is affected by a planned ABI change that has the goal of aligning Rust with the standard C ABI of this target.

Module builtinCopy item path

Structs§

Statics§

Module builtin