Module rustc_lint::builtin

Lints in the Rust compiler.

This contains lints which can feasibly be implemented as their own AST visitor. Also see rustc_session::lint::builtin, which contains the definitions of lints that are emitted directly inside the main compiler.

To add a new lint to rustc, declare it here using declare_lint!(). Then add code to emit the new lint in the appropriate circumstances. You can do that in an existing LintPass if it makes sense, or in a new LintPass, or using Session::add_lint elsewhere in the compiler. Only do the latter if the check can’t be written cleanly as a LintPass (also, note that such lints will need to be defined in rustc_session::lint::builtin, not here).

If you define a new EarlyLintPass, you will also need to add it to the add_early_builtin! or add_early_builtin_with_new! invocation in lib.rs. Use the former for unit-like structs and the latter for structs with a pub fn new().

If you define a new LateLintPass, you will also need to add it to the late_lint_methods! invocation in lib.rs.

Structs

• AnonymousParameters
  Checks for use of anonymous parameters (RFC 1685).
• BoxPointers
• ClashingExternDeclarations
• DeprecatedAttr
  Check for use of attributes which have been deprecated.
• DerefNullPtr
• EllipsisInclusiveRangePatterns
• ExplicitOutlivesRequirements
• HardwiredLints
  Does nothing as a lint pass, but registers some Lints that are used by other parts of the compiler.
• IncompleteFeatures
  Check for used feature gates in INCOMPLETE_FEATURES in rustc_feature/src/active.rs.
• InitError
  Information about why a type cannot be initialized this way.
• InvalidNoMangleItems
• InvalidValue
• KeywordIdents
  Check for uses of edition keywords used as an identifier.
• MissingCopyImplementations
• MissingDebugImplementations
• MissingDoc
• MutableTransmutes
• NamedAsmLabels
• NonShorthandFieldPatterns
• SoftLints
  Does nothing as a lint pass, but registers some Lints which are used by other parts of the compiler.
• SpecialModuleName
• TrivialConstraints
  Lint for trait and lifetime bounds that don’t depend on type parameters which either do nothing, or stop the item from being used.
• TypeAliasBounds
  Lint for trait and lifetime bounds in type aliases being mostly ignored. They are relevant when using associated types, but otherwise neither checked at definition site nor enforced at use site.
• UnderMacro 🔒
• UnexpectedCfgs
• UngatedAsyncFnTrackCaller
  Explains corresponding feature flag must be enabled for the #[track_caller] attribute to do anything
• UnnameableTestItems
• UnreachablePub
  Lint for items marked pub that aren’t reachable from other crates.
• UnsafeCode
• UnstableFeatures
  Forbids using the #[feature(...)] attribute
• UnusedBrokenConst
  Lint constants that are erroneous. Without this lint, we might not get any diagnostic if the constant is unused within this crate, even though downstream crates can’t use it without producing an error.
• UnusedDocComment
• WhileTrue

Enums

• InitKind 🔒
• SymbolName 🔒
  Differentiate between whether the name for an extern decl came from the link_name attribute or just from declaration itself. This is important because we don’t want to report clashes on symbol name if they don’t actually clash because one or the other links against a symbol with a different name.

Constants

• HAS_MIN_FEATURES 🔒
• MAX_SIZE 🔒

Statics

• 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_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.
• ANONYMOUS_PARAMETERS
  The anonymous_parameters lint detects anonymous parameters in trait definitions.
• 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.
• BOX_POINTERS 🔒
  The box_pointers lints use of the Box type.
• BREAK_WITH_LABEL_AND_LOOP
  The break_with_label_and_loop lint detects labeled break expressions with an unlabeled loop as their value expression.
• BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE
  The byte_slice_in_packed_struct_with_derive lint detects cases where a byte slice field ([u8]) or string slice field (str) is used in a packed struct that derives one or more built-in traits.
• CALLSITE 🔒
• CALLSITE 🔒
• CALLSITE 🔒
• CALLSITE 🔒
• CALLSITE 🔒
• CALLSITE 🔒
• CALLSITE 🔒
• CALLSITE 🔒
• CALLSITE 🔒
• CENUM_IMPL_DROP_CAST
  The cenum_impl_drop_cast lint detects an as cast of a field-less enum that implements Drop.
• CLASHING_EXTERN_DECLARATIONS
  The clashing_extern_declarations lint detects when an extern fn has been declared with the same name but different types.
• 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.
• DEPRECATED
  The deprecated lint detects use of deprecated items.
• DEPRECATED_CFG_ATTR_CRATE_TYPE_NAME
  The deprecated_cfg_attr_crate_type_name lint detects uses of the #![cfg_attr(..., crate_type = "...")] and #![cfg_attr(..., crate_name = "...")] attributes to conditionally specify the crate type and name in the source code.
• DEPRECATED_IN_FUTURE
  The deprecated_in_future lint is internal to rustc and should not be used by user code.
• DEPRECATED_WHERE_CLAUSE_LOCATION
  The deprecated_where_clause_location lint detects when a where clause in front of the equals in an associated type.
• DEREF_NULLPTR
  The deref_nullptr lint detects when an null pointer is dereferenced, which causes undefined behavior.
• 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_PATHS
  The elided_lifetimes_in_paths lint detects the use of hidden lifetime parameters.
• ELLIPSIS_INCLUSIVE_RANGE_PATTERNS
  The ellipsis_inclusive_range_patterns lint detects the ... range pattern, which is deprecated.
• 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.
• ILLEGAL_FLOATING_POINT_LITERAL_PATTERN
  The illegal_floating_point_literal_pattern lint detects floating-point literals used in patterns.
• ILL_FORMED_ATTRIBUTE_INPUT
  The ill_formed_attribute_input lint detects ill-formed attribute inputs that were previously accepted and used in practice.
• IMPLIED_BOUNDS_ENTAILMENT
  The implied_bounds_entailment lint detects cases where the arguments of an impl method have stronger implied bounds than those from the trait method it’s implementing.
• INCOMPLETE_FEATURES
  The incomplete_features lint detects unstable features enabled with the feature attribute that may function improperly in some or all cases.
• INCOMPLETE_INCLUDE
  The incomplete_include lint detects the use of the include! macro with a file that contains more than one expression.
• INDIRECT_STRUCTURAL_MATCH
  The indirect_structural_match lint detects a const in a pattern that manually implements PartialEq and Eq.
• 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_ALIGNMENT
  The invalid_alignment lint detects dereferences of misaligned pointers during constant evluation.
• 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.
• INVALID_VALUE
  The invalid_value lint detects creating a value that is not valid, such as a null reference.
• IRREFUTABLE_LET_PATTERNS
  The irrefutable_let_patterns lint detects irrefutable patterns in if lets, while lets, and if let guards.
• KEYWORD_IDENTS
  The keyword_idents lint detects edition keywords being used as an identifier.
• 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.
• 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 🔒
• META 🔒
• META 🔒
• META 🔒
• META 🔒
• META 🔒
• META 🔒
• META 🔒
• META 🔒
• 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_COPY_IMPLEMENTATIONS
  The missing_copy_implementations lint detects potentially-forgotten implementations of Copy.
• MISSING_DEBUG_IMPLEMENTATIONS 🔒
  The missing_debug_implementations lint detects missing implementations of fmt::Debug.
• MISSING_DOCS
  The missing_docs lint detects missing documentation for public items.
• 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).
• MUST_NOT_SUSPEND
  The must_not_suspend lint guards against values that shouldn’t be held across suspend points (.await)
• MUTABLE_TRANSMUTES 🔒
  The mutable_transmutes lint catches transmuting from &T to &mut T because it is undefined behavior.
• 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.
• NAMED_ASM_LABELS
  The named_asm_labels lint detects the use of named labels in the inline asm! macro.
• NONTRIVIAL_STRUCTURAL_MATCH
  The nontrivial_structural_match lint detects constants that are used in patterns, whose type is not structural-match and whose initializer body actually uses values that are not structural-match. So Option<NotStructuralMatch> is ok if the constant is just None.
• NON_EXHAUSTIVE_OMITTED_PATTERNS
  The non_exhaustive_omitted_patterns lint detects when a wildcard (_ or ..) in a pattern for a #[non_exhaustive] struct or enum is reachable.
• NON_SHORTHAND_FIELD_PATTERNS 🔒
  The non_shorthand_field_patterns lint detects using Struct { x: x } instead of Struct { x } in a pattern.
• NO_MANGLE_CONST_ITEMS 🔒
  The no_mangle_const_items lint detects any const items with the no_mangle attribute.
• NO_MANGLE_GENERIC_ITEMS 🔒
  The no_mangle_generic_items lint detects generic items that must be mangled.
• ORDER_DEPENDENT_TRAIT_OBJECTS
  The order_dependent_trait_objects lint detects a trait coherency violation that would allow creating two trait impls for the same dynamic trait object involving marker traits.
• 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.
• POINTER_STRUCTURAL_MATCH
  The pointer_structural_match lint detects pointers used in patterns whose behaviour cannot be relied upon across compiler versions and optimization levels.
• PRIVATE_IN_PUBLIC
  The private_in_public lint detects private items in public interfaces not caught by the old implementation.
• PROC_MACRO_BACK_COMPAT
  The proc_macro_back_compat lint detects uses of old versions of certain proc-macro crates, which have hardcoded workarounds in the compiler.
• 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.
• 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.
• 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.
• SPECIAL_MODULE_NAME
  The special_module_name lint detects module declarations for files that have a special meaning.
• STABLE_FEATURES
  The stable_features lint detects a feature attribute that has since been made stable.
• SUSPICIOUS_AUTO_TRAIT_IMPLS
  The suspicious_auto_trait_impls lint checks for potentially incorrect implementations of auto traits.
• 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_BOUNDS 🔒
  The trivial_bounds lint detects trait bounds that don’t depend on any type parameters.
• 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.
• TYPE_ALIAS_BOUNDS 🔒
  The type_alias_bounds lint detects bounds in type aliases.
• 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.
• UNDEFINED_NAKED_FUNCTION_ABI
  The undefined_naked_function_abi lint detects naked function definitions that either do not specify an ABI or specify the Rust ABI.
• UNEXPECTED_CFGS
  The unexpected_cfgs lint detects unexpected conditional compilation conditions.
• UNFULFILLED_LINT_EXPECTATIONS
  The unfulfilled_lint_expectations lint detects lint trigger expectations that have not been fulfilled.
• UNGATED_ASYNC_FN_TRACK_CALLER 🔒
  The ungated_async_fn_track_caller lint warns when the #[track_caller] attribute is used on an async function, method, or closure, without enabling the corresponding unstable feature flag.
• 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.
• 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.
• UNREACHABLE_CODE
  The unreachable_code lint detects unreachable code paths.
• UNREACHABLE_PATTERNS
  The unreachable_patterns lint detects unreachable patterns.
• UNREACHABLE_PUB
  The unreachable_pub lint triggers for pub items not reachable from the crate root.
• UNSAFE_CODE 🔒
  The unsafe_code lint catches usage of unsafe code.
• UNSAFE_OP_IN_UNSAFE_FN
  The unsafe_op_in_unsafe_fn lint detects unsafe operations in unsafe functions without an explicit unsafe block.
• UNSTABLE_FEATURES 🔒
  The unstable_features is deprecated and should no longer be used.
• 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, thiscall, vectorcall calling conventions (or their unwind variants) on targets that cannot meaningfully be supported for the requested target.
• UNUSED_ASSIGNMENTS
  The unused_assignments lint detects assignments that will never be read.
• 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_TUPLE_STRUCT_FIELDS
  The unused_tuple_struct_fields lint detects fields of tuple structs that are never read.
• 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.
• WHERE_CLAUSES_OBJECT_SAFETY
  The where_clauses_object_safety lint detects for object safety of where clauses.
• WHILE_TRUE 🔒
  The while_true lint detects while true { }.

Functions

• def_id_is_transmute 🔒
• get_transmute_from_to 🔒
• has_doc 🔒
• is_dangerous_init 🔒
  Determine if this expression is a “dangerous initialization”.
• is_null_ptr 🔒
  test if expression is a null ptr
• is_zero 🔒
  Test if this constant is all-0.
• is_zero 🔒
  test if expression is the literal 0
• matches_ellipsis_pat 🔒
  If pat is a ... pattern, return the start and end of the range, as well as the span corresponding to the ellipsis.
• pierce_parens 🔒
  Traverse through any amount of parenthesis and return the first non-parens expression.
• structurally_same_type_impl 🔒
• ty_find_init_error 🔒
  Return Some only if we are sure this type does not allow zero initialization.
• variant_find_init_error 🔒
• warn_if_doc 🔒