Module rustc_lint::builtin
source · [−]Expand description
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
Lint
s
that are used by other parts of the compiler.INCOMPLETE_FEATURES
in rustc_feature/src/active.rs
.Lint
s
which are used by other parts of the compiler.pub
that aren’t reachable from other crates.#[feature(...)]
attributeEnums
Constants
Statics
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 nameanonymous_parameters
lint detects anonymous parameters in trait
definitions.arithmetic_overflow
lint detects that an arithmetic operation
will overflow.asm_sub_register
lint detects using only a subset of a register
for inline asm inputs.bad_asm_style
lint detects the use of the .intel_syntax
and
.att_syntax
directives.bare_trait_objects
lint suggests using dyn Trait
for trait
objects.bindings_with_variant_name
lint detects pattern bindings with
the same name as one of the matched variants.box_pointers
lints use of the Box type.break_with_label_and_loop
lint detects labeled break
expressions with
an unlabeled loop as their value expression.clashing_extern_declarations
lint detects when an extern fn
has been declared with the same name but different types.coherence_leak_check
lint detects conflicting implementations of
a trait that are only distinguished by the old leak-check code.conflicting_repr_hints
lint detects repr
attributes with
conflicting hints.const_err
lint detects an erroneous expression while doing
constant evaluation.const_evaluatable_unchecked
lint detects a generic constant used
in a type.const_item_mutation
lint detects attempts to mutate a const
item.dead_code
lint detects unused, unexported items.deprecated
lint detects use of deprecated items.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
lint is internal to rustc and should not be
used by user code.deprecated_where_clause_location
lint detects when a where clause in front of the equals
in an associated type.deref_into_dyn_supertrait
lint is output whenever there is a use of the
Deref
implementation with a dyn SuperTrait
type as Output
.deref_nullptr
lint detects when an null pointer is dereferenced,
which causes undefined behavior.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
lint detects the use of hidden
lifetime parameters.ellipsis_inclusive_range_patterns
lint detects the ...
range
pattern, which is deprecated.explicit_outlives_requirements
lint detects unnecessary
lifetime bounds that can be inferred.exported_private_dependencies
lint detects private dependencies
that are exposed in a public interface.ffi_unwind_calls
lint detects calls to foreign functions or function pointers with
C-unwind
or other FFI-unwind ABIs.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
lint detects function references that are
formatted with fmt::Pointer
or transmuted.fuzzy_provenance_casts
lint detects an as
cast between an integer
and a pointer.illegal_floating_point_literal_pattern
lint detects
floating-point literals used in patterns.ill_formed_attribute_input
lint detects ill-formed attribute
inputs that were previously accepted and used in practice.incomplete_features
lint detects unstable features enabled with
the feature
attribute that may function improperly in some or all
cases.incomplete_include
lint detects the use of the include!
macro with a file that contains more than one expression.ineffective_unstable_trait_impl
lint detects #[unstable]
attributes which are not used.invalid_doc_attributes
lint detects when the #[doc(...)]
is
misused.invalid_type_param_default
lint detects type parameter defaults
erroneously allowed in an invalid location.invalid_value
lint detects creating a value that is not valid,
such as a null reference.irrefutable_let_patterns
lint detects irrefutable patterns
in if let
s, while let
s, and if let
guards.keyword_idents
lint detects edition keywords being used as an
identifier.large_assignments
lint detects when objects of large
types are being moved around.late_bound_lifetime_arguments
lint detects generic lifetime
arguments in path segments with late bound lifetime parameters.legacy_derive_helpers
lint detects derive helper attributes
that are used before they are introduced.lossy_provenance_casts
lint detects an as
cast between a pointer
and an integer.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
lint detects the use of the
macro_use
attribute.meta_variable_misuse
lint detects possible meta-variable misuse
in macro definitions.missing_abi
lint detects cases where the ABI is omitted from
extern declarations.missing_copy_implementations
lint detects potentially-forgotten
implementations of Copy
.missing_debug_implementations
lint detects missing
implementations of fmt::Debug
.missing_docs
lint detects missing documentation for public items.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
lint guards against values that shouldn’t be held across suspend points
(.await
)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
lint detects the use of named labels in the
inline asm!
macro.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
lint detects when a wildcard (_
or ..
) in a
pattern for a #[non_exhaustive]
struct or enum is reachable.non_shorthand_field_patterns
lint detects using Struct { x: x }
instead of Struct { x }
in a pattern.no_mangle_generic_items
lint detects generic items that must be
mangled.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
lint detects match
arms that have range patterns that
overlap on their endpoints.patterns_in_fns_without_body
lint detects mut
identifier
patterns as a parameter in functions without a body.pointer_structural_match
lint detects pointers used in patterns whose behaviour
cannot be relied upon across compiler versions and optimization levels.private_in_public
lint detects private items in public
interfaces not caught by the old implementation.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
lint detects proc macro
derives using inaccessible names from parent modules.pub_use_of_private_extern_crate
lint detects a specific
situation of re-exporting a private extern crate
.renamed_and_removed_lints
lint detects lints that have been
renamed or removed.repr_transparent_external_private_fields
lint
detects types marked #[repr(transparent)]
that (transitively)
contain an external ZST type marked #[non_exhaustive]
or containing
private fieldsrust_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
lint detects usage of old versions of or-patterns.rust_2021_prefixes_incompatible_syntax
lint detects identifiers that will be parsed as a
prefix instead in Rust 2021.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
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
lint detects lifetimes that are only used
once.soft_unstable
lint detects unstable features that were
unintentionally allowed on stable.special_module_name
lint detects module
declarations for files that have a special meaning.stable_features
lint detects a feature
attribute that
has since been made stable.suspicious_auto_trait_impls
lint checks for potentially incorrect
implementations of auto traits.test_unstable_lint
lint tests unstable lints and is perma-unstable.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
lint detects trait bounds that don’t depend on
any type parameters.trivial_casts
lint detects trivial casts which could be replaced
with coercion, which may require type ascription or a temporary
variable.trivial_numeric_casts
lint detects trivial numeric casts of types
which could be removed.type_alias_bounds
lint detects bounds in type aliases.tyvar_behind_raw_pointer
lint detects raw pointer to an
inference variable.unaligned_references
lint detects unaligned references to fields
of packed structs.unconditional_panic
lint detects an operation that will cause a
panic at runtime.unconditional_recursion
lint detects functions that cannot
return without calling themselves.undefined_naked_function_abi
lint detects naked function definitions that
either do not specify an ABI or specify the Rust ABI.unexpected_cfgs
lint detects unexpected conditional compilation conditions.unfulfilled_lint_expectations
lint detects lint trigger expectations
that have not been fulfilled.uninhabited_static
lint detects uninhabited statics.unknown_crate_types
lint detects an unknown crate type found in
a crate_type
attribute.unknown_lints
lint detects unrecognized lint attributes.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
lint detects unreachable code paths.unreachable_patterns
lint detects unreachable patterns.unreachable_pub
lint triggers for pub
items not reachable from
the crate root.unsafe_code
lint catches usage of unsafe
code.unsafe_op_in_unsafe_fn
lint detects unsafe operations in unsafe
functions without an explicit unsafe block.unstable_features
is deprecated and should no longer be used.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
lint detects the use of unstable
syntax that is discarded during attribute expansion.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
lint detects assignments that will never be read.unused_attributes
lint detects attributes that were not used by
the compiler.unused_crate_dependencies
lint detects crate dependencies that
are never used.unused_doc_comments
lint detects doc comments that aren’t used
by rustdoc
.unused_extern_crates
lint guards against extern crate
items
that are never used.unused_features
lint detects unused or unknown features found in
crate-level feature
attributes.unused_imports
lint detects imports that are never used.unused_labels
lint detects labels that are never used.unused_lifetimes
lint detects lifetime parameters that are never
used.unused_macros
lint detects macros that were not used.unused_macro_rules
lint detects macro rules that were not used.unused_mut
lint detects mut variables which don’t need to be
mutable.unused_qualifications
lint detects unnecessarily qualified
names.unused_tuple_struct_fields
lint detects fields of tuple structs
that are never read.unused_unsafe
lint detects unnecessary use of an unsafe
block.unused_variables
lint detects variables which are not used in
any way.useless_deprecated
lint detects deprecation attributes with no effect.warnings
lint allows you to change the level of other
lints which produce warnings.while_true
lint detects while true { }
.