Module rustc_ap_rustc_lint_defs::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.

Structs

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

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.
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.
CENUM_IMPL_DROP_CAST	The cenum_impl_drop_cast lint detects an as cast of a field-less enum that implements Drop.
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_ERR	The const_err lint detects an erroneous expression while doing constant evaluation.
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_IN_FUTURE	The deprecated_in_future lint is internal to rustc and should not be used by user code.
DISJOINT_CAPTURE_MIGRATION	The disjoint_capture_migration lint detects variables that aren’t completely captured when the feature capture_disjoint_fields is enabled and it affects the Drop order of at least one path starting at this variable. It can also detect when a variable implements a trait, but one of its field does not and the field is captured by a closure and used with the assumption that said field implements the same trait as the root variable.
ELIDED_LIFETIMES_IN_PATHS	The elided_lifetimes_in_paths lint detects the use of hidden lifetime parameters.
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.
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.
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.
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_DOC_ATTRIBUTES	The invalid_doc_attributes lint detects when the #[doc(...)] is misused.
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.
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).
MUTABLE_BORROW_RESERVATION_CONFLICT	The mutable_borrow_reservation_conflict lint detects the reservation of a two-phased borrow that conflicts with other shared borrows.
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<NotStruturalMatch> is ok if the constant is just None.
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.
OR_PATTERNS_BACK_COMPAT	The or_patterns_back_compat lint detects usage of old versions of or-patterns.
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.
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.
TRIVIAL_CASTS	The trivial_casts lint detects trivial casts which could be replaced with coercion, which may require type ascription or 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.
UNALIGNED_REFERENCES	The unaligned_references lint detects unaligned references to fields of packed structs.
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.
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 attribute.
UNREACHABLE_CODE	The unreachable_code lint detects unreachable code paths.
UNREACHABLE_PATTERNS	The unreachable_patterns lint detects unreachable patterns.
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.
UNSUPPORTED_NAKED_FUNCTIONS	The unsupported_naked_functions lint detects naked function definitions that are unsupported but were previously accepted.
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_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.
WHERE_CLAUSES_OBJECT_SAFETY	The where_clauses_object_safety lint detects for object safety of where clauses.