Module rustc_lint_defs::builtin
source · 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
.
Structs
- Does nothing as a lint pass, but registers some
Lint
s that are used by other parts of the compiler.
Statics
- The
absolute_paths_not_starting_with_crate
lint detects fully qualified paths that start with a module name instead ofcrate
,self
, or an extern crate name - The
arithmetic_overflow
lint detects that an arithmetic operation will overflow. - The
asm_sub_register
lint detects using only a subset of a register for inline asm inputs. - The
bad_asm_style
lint detects the use of the.intel_syntax
and.att_syntax
directives. - The
bare_trait_objects
lint suggests usingdyn Trait
for trait objects. - The
bindings_with_variant_name
lint detects pattern bindings with the same name as one of the matched variants. - The
break_with_label_and_loop
lint detects labeledbreak
expressions with an unlabeled loop as their value expression. - 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 apacked
struct that derives one or more built-in traits. - The
coherence_leak_check
lint detects conflicting implementations of a trait that are only distinguished by the old leak-check code. - The
conflicting_repr_hints
lint detectsrepr
attributes with conflicting hints. - The
const_evaluatable_unchecked
lint detects a generic constant used in a type. - The
const_item_mutation
lint detects attempts to mutate aconst
item. - The
dead_code
lint detects unused, unexported items. - The
deprecated
lint detects use of deprecated items. - 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. - The
deprecated_in_future
lint is internal to rustc and should not be used by user code. - The
deprecated_where_clause_location
lint detects when a where clause in front of the equals in an associated type. - The
duplicate_macro_attributes
lint detects when a#[test]
-like built-in macro attribute is duplicated on an item. This lint may trigger onbench
,cfg_eval
,test
andtest_case
. - The
elided_lifetimes_in_paths
lint detects the use of hidden lifetime parameters. - The
explicit_outlives_requirements
lint detects unnecessary lifetime bounds that can be inferred. - The
exported_private_dependencies
lint detects private dependencies that are exposed in a public interface. - The
ffi_unwind_calls
lint detects calls to foreign functions or function pointers withC-unwind
or other FFI-unwind ABIs. - The
forbidden_lint_groups
lint detects violations offorbid
applied to a lint group. Due to a bug in the compiler, these used to be overlooked entirely. They now generate a warning. - The
function_item_references
lint detects function references that are formatted withfmt::Pointer
or transmuted. - The
fuzzy_provenance_casts
lint detects anas
cast between an integer and a pointer. - The
illegal_floating_point_literal_pattern
lint detects floating-point literals used in patterns. - The
ill_formed_attribute_input
lint detects ill-formed attribute inputs that were previously accepted and used in practice. - 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. - The
incomplete_include
lint detects the use of theinclude!
macro with a file that contains more than one expression. - The
ineffective_unstable_trait_impl
lint detects#[unstable]
attributes which are not used. - The
invalid_alignment
lint detects dereferences of misaligned pointers during constant evluation. - The
invalid_doc_attributes
lint detects when the#[doc(...)]
is misused. - The
invalid_macro_export_arguments
lint detects cases where#[macro_export]
is being used with invalid arguments. - The
invalid_type_param_default
lint detects type parameter defaults erroneously allowed in an invalid location. - The
irrefutable_let_patterns
lint detects irrefutable patterns inif let
s,while let
s, andif let
guards. - The
large_assignments
lint detects when objects of large types are being moved around. - The
late_bound_lifetime_arguments
lint detects generic lifetime arguments in path segments with late bound lifetime parameters. - The
legacy_derive_helpers
lint detects derive helper attributes that are used before they are introduced. - The
lossy_provenance_casts
lint detects anas
cast between a pointer and an integer. - The
macro_expanded_macro_exports_accessed_by_absolute_paths
lint detects macro-expandedmacro_export
macros from the current crate that cannot be referred to by absolute paths. - The
macro_use_extern_crate
lint detects the use of themacro_use
attribute. - The
meta_variable_misuse
lint detects possible meta-variable misuse in macro definitions. - The
missing_abi
lint detects cases where the ABI is omitted from extern declarations. - The
missing_fragment_specifier
lint is issued when an unused pattern in amacro_rules!
macro definition has a meta-variable (e.g.$e
) that is not followed by a fragment specifier (e.g.:expr
). - The
must_not_suspend
lint guards against values that shouldn’t be held across suspend points (.await
) - 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. - 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. SoOption<NotStructuralMatch>
is ok if the constant is justNone
. - The
non_exhaustive_omitted_patterns
lint detects when a wildcard (_
or..
) in a pattern for a#[non_exhaustive]
struct or enum is reachable. - 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. - The
overlapping_range_endpoints
lint detectsmatch
arms that have range patterns that overlap on their endpoints. - The
patterns_in_fns_without_body
lint detectsmut
identifier patterns as a parameter in functions without a body. - The
pointer_structural_match
lint detects pointers used in patterns whose behaviour cannot be relied upon across compiler versions and optimization levels. - The
private_in_public
lint detects private items in public interfaces not caught by the old implementation. - The
proc_macro_back_compat
lint detects uses of old versions of certain proc-macro crates, which have hardcoded workarounds in the compiler. - The
proc_macro_derive_resolution_fallback
lint detects proc macro derives using inaccessible names from parent modules. - The
pub_use_of_private_extern_crate
lint detects a specific situation of re-exporting a privateextern crate
. - The
renamed_and_removed_lints
lint detects lints that have been renamed or removed. - 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 - The
rust_2021_incompatible_closure_captures
lint detects variables that aren’t completely captured in Rust 2021, such that theDrop
order of their fields may differ between Rust 2018 and 2021. - The
rust_2021_incompatible_or_patterns
lint detects usage of old versions of or-patterns. - The
rust_2021_prefixes_incompatible_syntax
lint detects identifiers that will be parsed as a prefix instead in Rust 2021. - The
rust_2021_prelude_collisions
lint detects the usage of trait methods which are ambiguous with traits added to the prelude in future editions. - 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. - The
single_use_lifetimes
lint detects lifetimes that are only used once. - The
soft_unstable
lint detects unstable features that were unintentionally allowed on stable. - The
stable_features
lint detects afeature
attribute that has since been made stable. - The
suspicious_auto_trait_impls
lint checks for potentially incorrect implementations of auto traits. - The
test_unstable_lint
lint tests unstable lints and is perma-unstable. - 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. - The
trivial_casts
lint detects trivial casts which could be replaced with coercion, which may require a temporary variable. - The
trivial_numeric_casts
lint detects trivial numeric casts of types which could be removed. - The
tyvar_behind_raw_pointer
lint detects raw pointer to an inference variable. - The
unconditional_panic
lint detects an operation that will cause a panic at runtime. - The
unconditional_recursion
lint detects functions that cannot return without calling themselves. - The
undefined_naked_function_abi
lint detects naked function definitions that either do not specify an ABI or specify the Rust ABI. - The
unexpected_cfgs
lint detects unexpected conditional compilation conditions. - The
unfulfilled_lint_expectations
lint detects lint trigger expectations that have not been fulfilled. - The
uninhabited_static
lint detects uninhabited statics. - The
unknown_crate_types
lint detects an unknown crate type found in acrate_type
attribute. - The
unknown_lints
lint detects unrecognized lint attributes. - The
unreachable_code
lint detects unreachable code paths. - The
unreachable_patterns
lint detects unreachable patterns. - The
unsafe_op_in_unsafe_fn
lint detects unsafe operations in unsafe functions without an explicit unsafe block. - The
unstable_name_collisions
lint detects that you have used a name that the standard library plans to add in the future. - The
unstable_syntax_pre_expansion
lint detects the use of unstable syntax that is discarded during attribute expansion. - The
unsupported_calling_conventions
lint is output whenever there is a use of thestdcall
,fastcall
,thiscall
,vectorcall
calling conventions (or their unwind variants) on targets that cannot meaningfully be supported for the requested target. - The
unused_assignments
lint detects assignments that will never be read. - The
unused_attributes
lint detects attributes that were not used by the compiler. - The
unused_crate_dependencies
lint detects crate dependencies that are never used. - The
unused_doc_comments
lint detects doc comments that aren’t used byrustdoc
. - The
unused_extern_crates
lint guards againstextern crate
items that are never used. - The
unused_features
lint detects unused or unknown features found in crate-levelfeature
attributes. - The
unused_imports
lint detects imports that are never used. - The
unused_labels
lint detects labels that are never used. - The
unused_lifetimes
lint detects lifetime parameters that are never used. - The
unused_macros
lint detects macros that were not used. - The
unused_macro_rules
lint detects macro rules that were not used. - The
unused_mut
lint detects mut variables which don’t need to be mutable. - The
unused_qualifications
lint detects unnecessarily qualified names. - The
unused_tuple_struct_fields
lint detects fields of tuple structs that are never read. - The
unused_unsafe
lint detects unnecessary use of anunsafe
block. - The
unused_variables
lint detects variables which are not used in any way. - The
useless_deprecated
lint detects deprecation attributes with no effect. - The
warnings
lint allows you to change the level of other lints which produce warnings.