Skip to main content

rustc_lint_defs/
builtin.rs

1//! Some lints that are built in to the compiler.
2//!
3//! These are the built-in lints that are emitted direct in the main
4//! compiler code, rather than using their own custom pass. Those
5//! lints are all available in `rustc_lint::builtin`.
6//!
7//! When removing a lint, make sure to also add a call to `register_removed` in
8//! compiler/rustc_lint/src/lib.rs.
9
10use crate::{declare_lint, declare_lint_pass, fcw};
11
12pub mod hardwired {
13    use super::*;
14
15    pub fn lint_vec() -> crate::LintVec {
16        ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
        [AARCH64_SOFTFLOAT_NEON, ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
                ALIGNED_FIELDS_IN_PACKED, AMBIGUOUS_ASSOCIATED_ITEMS,
                AMBIGUOUS_DERIVE_HELPERS, AMBIGUOUS_GLOB_IMPORTED_TRAITS,
                AMBIGUOUS_GLOB_IMPORTS, AMBIGUOUS_GLOB_REEXPORTS,
                AMBIGUOUS_IMPORT_VISIBILITIES, AMBIGUOUS_PANIC_IMPORTS,
                ARITHMETIC_OVERFLOW, ASM_SUB_REGISTER, BAD_ASM_STYLE,
                BARE_TRAIT_OBJECTS, BINDINGS_WITH_VARIANT_NAME,
                BREAK_WITH_LABEL_AND_LOOP, COHERENCE_LEAK_CHECK,
                CONFLICTING_REPR_HINTS, CONST_EVALUATABLE_UNCHECKED,
                CONST_ITEM_MUTATION, DEAD_CODE, DEAD_CODE_PUB_IN_BINARY,
                DEPRECATED, DEPRECATED_IN_FUTURE, DEPRECATED_LLVM_INTRINSIC,
                DEPRECATED_SAFE_2024, DEPRECATED_WHERE_CLAUSE_LOCATION,
                DUPLICATE_FEATURES, DUPLICATE_MACRO_ATTRIBUTES,
                DUPLICATE_TOOLS, ELIDED_LIFETIMES_IN_PATHS,
                EXPLICIT_BUILTIN_CFGS_IN_FLAGS, EXPORTED_PRIVATE_DEPENDENCIES,
                FFI_UNWIND_CALLS, FLOAT_LITERAL_F32_FALLBACK,
                FORBIDDEN_LINT_GROUPS, FUNCTION_ITEM_REFERENCES,
                HIDDEN_GLOB_REEXPORTS, ILL_FORMED_ATTRIBUTE_INPUT,
                INCOMPLETE_INCLUDE, INEFFECTIVE_UNSTABLE_REEXPORTS,
                INEFFECTIVE_UNSTABLE_TRAIT_IMPL, INLINE_NO_SANITIZE,
                INVALID_DOC_ATTRIBUTES, INVALID_MACRO_EXPORT_ARGUMENTS,
                INVALID_TYPE_PARAM_DEFAULT, IRREFUTABLE_LET_PATTERNS,
                LARGE_ASSIGNMENTS, LATE_BOUND_LIFETIME_ARGUMENTS,
                LEGACY_DERIVE_HELPERS, LINKER_INFO, LINKER_MESSAGES,
                LONG_RUNNING_CONST_EVAL,
                MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
                MACRO_USE_EXTERN_CRATE, MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                MALFORMED_DIAGNOSTIC_FILTERS,
                MALFORMED_DIAGNOSTIC_FORMAT_LITERALS, META_VARIABLE_MISUSE,
                METHOD_CALL_ON_DIVERGING_INFER_VAR,
                MISPLACED_DIAGNOSTIC_ATTRIBUTES, MISSING_ABI,
                MISSING_UNSAFE_ON_EXTERN, MUST_NOT_SUSPEND,
                NAMED_ARGUMENTS_USED_POSITIONALLY,
                NEVER_TYPE_FALLBACK_FLOWING_INTO_UNSAFE,
                NON_CONTIGUOUS_RANGE_ENDPOINTS,
                NON_EXHAUSTIVE_OMITTED_PATTERNS, NO_LINK_ATTRIBUTES,
                OUT_OF_SCOPE_MACRO_CALLS, OVERLAPPING_RANGE_ENDPOINTS,
                PARTIAL_STACK_PROTECTOR, PATTERNS_IN_FNS_WITHOUT_BODY,
                PRIVATE_BOUNDS, PRIVATE_INTERFACES,
                PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
                PUB_USE_OF_PRIVATE_EXTERN_CRATE,
                RECURSION_DEPTH_EXCEEDING_LIMIT, REDUNDANT_IMPORTS,
                REDUNDANT_LIFETIMES, REFINING_IMPL_TRAIT_INTERNAL,
                REFINING_IMPL_TRAIT_REACHABLE, RENAMED_AND_REMOVED_LINTS,
                REPEATED_REPRS, REPR_C_ENUMS_LARGER_THAN_INT,
                RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS,
                RTSAN_NONBLOCKING_ASYNC,
                RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
                RUST_2021_INCOMPATIBLE_OR_PATTERNS,
                RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
                RUST_2021_PRELUDE_COLLISIONS,
                RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
                RUST_2024_INCOMPATIBLE_PAT, RUST_2024_PRELUDE_COLLISIONS,
                SELF_CONSTRUCTOR_FROM_OUTER_ITEM,
                SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
                SEMICOLON_IN_EXPRESSIONS_FROM_NON_LOCAL_MACROS,
                SHADOWING_SUPERTRAIT_ITEMS, SINGLE_USE_LIFETIMES,
                STABLE_FEATURES, TAIL_CALL_TRACK_CALLER, TAIL_EXPR_DROP_ORDER,
                TEST_UNSTABLE_LINT, TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
                TEXT_DIRECTION_CODEPOINT_IN_LITERAL, TRIVIAL_CASTS,
                TRIVIAL_NUMERIC_CASTS, TYVAR_BEHIND_RAW_POINTER,
                UNCONDITIONAL_PANIC, UNCONDITIONAL_RECURSION,
                UNCOVERED_PARAM_IN_PROJECTION,
                UNEVALUATED_DEFAULT_FIELD_VALUE, UNEXPECTED_CFGS,
                UNFULFILLED_LINT_EXPECTATIONS, UNINHABITED_STATIC,
                UNKNOWN_CRATE_TYPES, UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
                UNKNOWN_LINTS, UNNAMEABLE_TEST_ITEMS, UNNAMEABLE_TYPES,
                UNREACHABLE_CFG_SELECT_PREDICATES, UNREACHABLE_CODE,
                UNREACHABLE_PATTERNS, UNSAFE_ATTR_OUTSIDE_UNSAFE,
                UNSAFE_OP_IN_UNSAFE_FN, UNSTABLE_IMPORTS,
                UNSTABLE_NAME_COLLISIONS, UNSTABLE_SYNTAX_PRE_EXPANSION,
                UNSUPPORTED_CALLING_CONVENTIONS, UNUSED_ASSIGNMENTS,
                UNUSED_ASSOCIATED_TYPE_BOUNDS, UNUSED_ATTRIBUTES,
                UNUSED_CRATE_DEPENDENCIES, UNUSED_EXTERN_CRATES,
                UNUSED_FEATURES, UNUSED_IMPORTS, UNUSED_LABELS,
                UNUSED_LIFETIMES, UNUSED_MACROS, UNUSED_MACRO_RULES,
                UNUSED_MUT, UNUSED_QUALIFICATIONS, UNUSED_UNSAFE,
                UNUSED_VARIABLES, UNUSED_VISIBILITIES, USELESS_DEPRECATED,
                VARARGS_WITHOUT_PATTERN, WARNINGS, X86_SOFTFLOAT_SSE]))vec![
17            // tidy-alphabetical-start
18            AARCH64_SOFTFLOAT_NEON,
19            ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
20            ALIGNED_FIELDS_IN_PACKED,
21            AMBIGUOUS_ASSOCIATED_ITEMS,
22            AMBIGUOUS_DERIVE_HELPERS,
23            AMBIGUOUS_GLOB_IMPORTED_TRAITS,
24            AMBIGUOUS_GLOB_IMPORTS,
25            AMBIGUOUS_GLOB_REEXPORTS,
26            AMBIGUOUS_IMPORT_VISIBILITIES,
27            AMBIGUOUS_PANIC_IMPORTS,
28            ARITHMETIC_OVERFLOW,
29            ASM_SUB_REGISTER,
30            BAD_ASM_STYLE,
31            BARE_TRAIT_OBJECTS,
32            BINDINGS_WITH_VARIANT_NAME,
33            BREAK_WITH_LABEL_AND_LOOP,
34            COHERENCE_LEAK_CHECK,
35            CONFLICTING_REPR_HINTS,
36            CONST_EVALUATABLE_UNCHECKED,
37            CONST_ITEM_MUTATION,
38            DEAD_CODE,
39            DEAD_CODE_PUB_IN_BINARY,
40            DEPRECATED,
41            DEPRECATED_IN_FUTURE,
42            DEPRECATED_LLVM_INTRINSIC,
43            DEPRECATED_SAFE_2024,
44            DEPRECATED_WHERE_CLAUSE_LOCATION,
45            DUPLICATE_FEATURES,
46            DUPLICATE_MACRO_ATTRIBUTES,
47            DUPLICATE_TOOLS,
48            ELIDED_LIFETIMES_IN_PATHS,
49            EXPLICIT_BUILTIN_CFGS_IN_FLAGS,
50            EXPORTED_PRIVATE_DEPENDENCIES,
51            FFI_UNWIND_CALLS,
52            FLOAT_LITERAL_F32_FALLBACK,
53            FORBIDDEN_LINT_GROUPS,
54            FUNCTION_ITEM_REFERENCES,
55            HIDDEN_GLOB_REEXPORTS,
56            ILL_FORMED_ATTRIBUTE_INPUT,
57            INCOMPLETE_INCLUDE,
58            INEFFECTIVE_UNSTABLE_REEXPORTS,
59            INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
60            INLINE_NO_SANITIZE,
61            INVALID_DOC_ATTRIBUTES,
62            INVALID_MACRO_EXPORT_ARGUMENTS,
63            INVALID_TYPE_PARAM_DEFAULT,
64            IRREFUTABLE_LET_PATTERNS,
65            LARGE_ASSIGNMENTS,
66            LATE_BOUND_LIFETIME_ARGUMENTS,
67            LEGACY_DERIVE_HELPERS,
68            LINKER_INFO,
69            LINKER_MESSAGES,
70            LONG_RUNNING_CONST_EVAL,
71            MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
72            MACRO_USE_EXTERN_CRATE,
73            MALFORMED_DIAGNOSTIC_ATTRIBUTES,
74            MALFORMED_DIAGNOSTIC_FILTERS,
75            MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
76            META_VARIABLE_MISUSE,
77            METHOD_CALL_ON_DIVERGING_INFER_VAR,
78            MISPLACED_DIAGNOSTIC_ATTRIBUTES,
79            MISSING_ABI,
80            MISSING_UNSAFE_ON_EXTERN,
81            MUST_NOT_SUSPEND,
82            NAMED_ARGUMENTS_USED_POSITIONALLY,
83            NEVER_TYPE_FALLBACK_FLOWING_INTO_UNSAFE,
84            NON_CONTIGUOUS_RANGE_ENDPOINTS,
85            NON_EXHAUSTIVE_OMITTED_PATTERNS,
86            NO_LINK_ATTRIBUTES,
87            OUT_OF_SCOPE_MACRO_CALLS,
88            OVERLAPPING_RANGE_ENDPOINTS,
89            PARTIAL_STACK_PROTECTOR,
90            PATTERNS_IN_FNS_WITHOUT_BODY,
91            PRIVATE_BOUNDS,
92            PRIVATE_INTERFACES,
93            PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
94            PUB_USE_OF_PRIVATE_EXTERN_CRATE,
95            RECURSION_DEPTH_EXCEEDING_LIMIT,
96            REDUNDANT_IMPORTS,
97            REDUNDANT_LIFETIMES,
98            REFINING_IMPL_TRAIT_INTERNAL,
99            REFINING_IMPL_TRAIT_REACHABLE,
100            RENAMED_AND_REMOVED_LINTS,
101            REPEATED_REPRS,
102            REPR_C_ENUMS_LARGER_THAN_INT,
103            RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS,
104            RTSAN_NONBLOCKING_ASYNC,
105            RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
106            RUST_2021_INCOMPATIBLE_OR_PATTERNS,
107            RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
108            RUST_2021_PRELUDE_COLLISIONS,
109            RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
110            RUST_2024_INCOMPATIBLE_PAT,
111            RUST_2024_PRELUDE_COLLISIONS,
112            SELF_CONSTRUCTOR_FROM_OUTER_ITEM,
113            SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
114            SEMICOLON_IN_EXPRESSIONS_FROM_NON_LOCAL_MACROS,
115            SHADOWING_SUPERTRAIT_ITEMS,
116            SINGLE_USE_LIFETIMES,
117            STABLE_FEATURES,
118            TAIL_CALL_TRACK_CALLER,
119            TAIL_EXPR_DROP_ORDER,
120            TEST_UNSTABLE_LINT,
121            TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
122            TEXT_DIRECTION_CODEPOINT_IN_LITERAL,
123            TRIVIAL_CASTS,
124            TRIVIAL_NUMERIC_CASTS,
125            TYVAR_BEHIND_RAW_POINTER,
126            UNCONDITIONAL_PANIC,
127            UNCONDITIONAL_RECURSION,
128            UNCOVERED_PARAM_IN_PROJECTION,
129            UNEVALUATED_DEFAULT_FIELD_VALUE,
130            UNEXPECTED_CFGS,
131            UNFULFILLED_LINT_EXPECTATIONS,
132            UNINHABITED_STATIC,
133            UNKNOWN_CRATE_TYPES,
134            UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
135            UNKNOWN_LINTS,
136            UNNAMEABLE_TEST_ITEMS,
137            UNNAMEABLE_TYPES,
138            UNREACHABLE_CFG_SELECT_PREDICATES,
139            UNREACHABLE_CODE,
140            UNREACHABLE_PATTERNS,
141            UNSAFE_ATTR_OUTSIDE_UNSAFE,
142            UNSAFE_OP_IN_UNSAFE_FN,
143            UNSTABLE_IMPORTS,
144            UNSTABLE_NAME_COLLISIONS,
145            UNSTABLE_SYNTAX_PRE_EXPANSION,
146            UNSUPPORTED_CALLING_CONVENTIONS,
147            UNUSED_ASSIGNMENTS,
148            UNUSED_ASSOCIATED_TYPE_BOUNDS,
149            UNUSED_ATTRIBUTES,
150            UNUSED_CRATE_DEPENDENCIES,
151            UNUSED_EXTERN_CRATES,
152            UNUSED_FEATURES,
153            UNUSED_IMPORTS,
154            UNUSED_LABELS,
155            UNUSED_LIFETIMES,
156            UNUSED_MACROS,
157            UNUSED_MACRO_RULES,
158            UNUSED_MUT,
159            UNUSED_QUALIFICATIONS,
160            UNUSED_UNSAFE,
161            UNUSED_VARIABLES,
162            UNUSED_VISIBILITIES,
163            USELESS_DEPRECATED,
164            VARARGS_WITHOUT_PATTERN,
165            WARNINGS,
166            X86_SOFTFLOAT_SSE,
167            // tidy-alphabetical-end
168        ]
169    }
170}
171
172#[doc = r" The `forbidden_lint_groups` lint detects violations of"]
#[doc = r" `forbid` applied to a lint group. Due to a bug in the compiler,"]
#[doc =
r" these used to be overlooked entirely. They now generate a warning."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![forbid(warnings)]"]
#[doc = r" #![warn(bad_style)]"]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Recommended fix"]
#[doc = r""]
#[doc = r" If your crate is using `#![forbid(warnings)]`,"]
#[doc = r" we recommend that you change to `#![deny(warnings)]`."]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Due to a compiler bug, applying `forbid` to lint groups"]
#[doc = r" previously had no effect. The bug is now fixed but instead of"]
#[doc = r" enforcing `forbid` we issue this future-compatibility warning"]
#[doc = r" to avoid breaking existing crates."]
pub static FORBIDDEN_LINT_GROUPS: &crate::Lint =
    &crate::Lint {
            name: "FORBIDDEN_LINT_GROUPS",
            default_level: crate::Warn,
            desc: "applying forbid to lint-groups",
            ignore_deny_warnings: true,
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 81670,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
173    /// The `forbidden_lint_groups` lint detects violations of
174    /// `forbid` applied to a lint group. Due to a bug in the compiler,
175    /// these used to be overlooked entirely. They now generate a warning.
176    ///
177    /// ### Example
178    ///
179    /// ```rust
180    /// #![forbid(warnings)]
181    /// #![warn(bad_style)]
182    ///
183    /// fn main() {}
184    /// ```
185    ///
186    /// {{produces}}
187    ///
188    /// ### Recommended fix
189    ///
190    /// If your crate is using `#![forbid(warnings)]`,
191    /// we recommend that you change to `#![deny(warnings)]`.
192    ///
193    /// ### Explanation
194    ///
195    /// Due to a compiler bug, applying `forbid` to lint groups
196    /// previously had no effect. The bug is now fixed but instead of
197    /// enforcing `forbid` we issue this future-compatibility warning
198    /// to avoid breaking existing crates.
199    pub FORBIDDEN_LINT_GROUPS,
200    Warn,
201    "applying forbid to lint-groups",
202    @future_incompatible = FutureIncompatibleInfo {
203        reason: fcw!(FutureReleaseError #81670),
204        report_in_deps: true,
205    };
206    // We exempt `FORBIDDEN_LINT_GROUPS` from `-Dwarnings` because it specifically
207    // triggers in cases (like #80988) where you have `forbid(warnings)`,
208    // and so if we turned that into an error, it'd defeat the purpose of the
209    // future compatibility warning.
210    ignore_deny_warnings
211}
212
213#[doc =
r" The `ill_formed_attribute_input` lint detects ill-formed attribute"]
#[doc = r" inputs that were previously accepted and used in practice."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r#" #[inline = "this is not valid"]"#]
#[doc = r" fn foo() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Previously, inputs for many built-in attributes weren't validated and"]
#[doc = r" nonsensical attribute inputs were accepted. After validation was"]
#[doc =
r" added, it was determined that some existing projects made use of these"]
#[doc =
r" invalid forms. This is a [future-incompatible] lint to transition this"]
#[doc =
r" to a hard error in the future. See [issue #57571] for more details."]
#[doc = r""]
#[doc =
r" Check the [attribute reference] for details on the valid inputs for"]
#[doc = r" attributes."]
#[doc = r""]
#[doc = r" [issue #57571]: https://github.com/rust-lang/rust/issues/57571"]
#[doc =
r" [attribute reference]: https://doc.rust-lang.org/nightly/reference/attributes.html"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static ILL_FORMED_ATTRIBUTE_INPUT: &crate::Lint =
    &crate::Lint {
            name: "ILL_FORMED_ATTRIBUTE_INPUT",
            default_level: crate::Deny,
            desc: "ill-formed attribute inputs that were previously accepted and used in practice",
            crate_level_only: true,
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 57571,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
214    /// The `ill_formed_attribute_input` lint detects ill-formed attribute
215    /// inputs that were previously accepted and used in practice.
216    ///
217    /// ### Example
218    ///
219    /// ```rust,compile_fail
220    /// #[inline = "this is not valid"]
221    /// fn foo() {}
222    /// ```
223    ///
224    /// {{produces}}
225    ///
226    /// ### Explanation
227    ///
228    /// Previously, inputs for many built-in attributes weren't validated and
229    /// nonsensical attribute inputs were accepted. After validation was
230    /// added, it was determined that some existing projects made use of these
231    /// invalid forms. This is a [future-incompatible] lint to transition this
232    /// to a hard error in the future. See [issue #57571] for more details.
233    ///
234    /// Check the [attribute reference] for details on the valid inputs for
235    /// attributes.
236    ///
237    /// [issue #57571]: https://github.com/rust-lang/rust/issues/57571
238    /// [attribute reference]: https://doc.rust-lang.org/nightly/reference/attributes.html
239    /// [future-incompatible]: ../index.md#future-incompatible-lints
240    pub ILL_FORMED_ATTRIBUTE_INPUT,
241    Deny,
242    "ill-formed attribute inputs that were previously accepted and used in practice",
243    @future_incompatible = FutureIncompatibleInfo {
244        reason: fcw!(FutureReleaseError #57571),
245        report_in_deps: true,
246    };
247    crate_level_only
248}
249
250#[doc =
r" The `conflicting_repr_hints` lint detects [`repr` attributes] with"]
#[doc = r" conflicting hints."]
#[doc = r""]
#[doc =
r" [`repr` attributes]: https://doc.rust-lang.org/reference/type-layout.html#representations"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #[repr(u32, u64)]"]
#[doc = r" enum Foo {"]
#[doc = r"     Variant1,"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The compiler incorrectly accepted these conflicting representations in"]
#[doc =
r" the past. This is a [future-incompatible] lint to transition this to a"]
#[doc = r" hard error in the future. See [issue #68585] for more details."]
#[doc = r""]
#[doc = r" To correct the issue, remove one of the conflicting hints."]
#[doc = r""]
#[doc = r" [issue #68585]: https://github.com/rust-lang/rust/issues/68585"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static CONFLICTING_REPR_HINTS: &crate::Lint =
    &crate::Lint {
            name: "CONFLICTING_REPR_HINTS",
            default_level: crate::Deny,
            desc: "conflicts between `#[repr(..)]` hints that were previously accepted and used in practice",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 68585,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
251    /// The `conflicting_repr_hints` lint detects [`repr` attributes] with
252    /// conflicting hints.
253    ///
254    /// [`repr` attributes]: https://doc.rust-lang.org/reference/type-layout.html#representations
255    ///
256    /// ### Example
257    ///
258    /// ```rust,compile_fail
259    /// #[repr(u32, u64)]
260    /// enum Foo {
261    ///     Variant1,
262    /// }
263    /// ```
264    ///
265    /// {{produces}}
266    ///
267    /// ### Explanation
268    ///
269    /// The compiler incorrectly accepted these conflicting representations in
270    /// the past. This is a [future-incompatible] lint to transition this to a
271    /// hard error in the future. See [issue #68585] for more details.
272    ///
273    /// To correct the issue, remove one of the conflicting hints.
274    ///
275    /// [issue #68585]: https://github.com/rust-lang/rust/issues/68585
276    /// [future-incompatible]: ../index.md#future-incompatible-lints
277    pub CONFLICTING_REPR_HINTS,
278    Deny,
279    "conflicts between `#[repr(..)]` hints that were previously accepted and used in practice",
280    @future_incompatible = FutureIncompatibleInfo {
281        reason: fcw!(FutureReleaseError #68585),
282        report_in_deps: true,
283    };
284}
285
286#[doc = r" The `repeated_reprs` lint detects when the same representation is"]
#[doc = r" specified more than once in a `#[repr(..)]` attribute."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #[repr(C)]"]
#[doc = r" #[repr(C)]"]
#[doc = r" enum Foo { A }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" While some representations may be specified more than once, the compiler"]
#[doc =
r" will reject repeated uses of some others. For consistency, prefer to"]
#[doc = r" only specify the representation once."]
pub static REPEATED_REPRS: &crate::Lint =
    &crate::Lint {
            name: "REPEATED_REPRS",
            default_level: crate::Warn,
            desc: "detects repeated representations in `#[repr(..)]` attributes",
            ..
        };declare_lint! {
287    /// The `repeated_reprs` lint detects when the same representation is
288    /// specified more than once in a `#[repr(..)]` attribute.
289    ///
290    /// ### Example
291    ///
292    /// ```rust
293    /// #[repr(C)]
294    /// #[repr(C)]
295    /// enum Foo { A }
296    /// ```
297    ///
298    /// {{produces}}
299    ///
300    /// ### Explanation
301    ///
302    /// While some representations may be specified more than once, the compiler
303    /// will reject repeated uses of some others. For consistency, prefer to
304    /// only specify the representation once.
305    pub REPEATED_REPRS,
306    Warn,
307    "detects repeated representations in `#[repr(..)]` attributes",
308}
309
310#[doc =
r" The `meta_variable_misuse` lint detects possible meta-variable misuse"]
#[doc = r" in macro definitions."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(meta_variable_misuse)]"]
#[doc = r""]
#[doc = r" macro_rules! foo {"]
#[doc = r"     () => {};"]
#[doc =
r"     ($( $i:ident = $($j:ident),+ );*) => { $( $( $i = $k; )+ )* };"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     foo!();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" There are quite a few different ways a [`macro_rules`] macro can be"]
#[doc =
r" improperly defined. Many of these errors were previously only detected"]
#[doc =
r" when the macro was expanded or not at all. This lint is an attempt to"]
#[doc = r" catch some of these problems when the macro is *defined*."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because it may have false positives"#]
#[doc = r" and other issues. See [issue #61053] for more details."]
#[doc = r""]
#[doc =
r" [`macro_rules`]: https://doc.rust-lang.org/reference/macros-by-example.html"]
#[doc = r" [issue #61053]: https://github.com/rust-lang/rust/issues/61053"]
pub static META_VARIABLE_MISUSE: &crate::Lint =
    &crate::Lint {
            name: "META_VARIABLE_MISUSE",
            default_level: crate::Allow,
            desc: "possible meta-variable misuse at macro definition",
            ..
        };declare_lint! {
311    /// The `meta_variable_misuse` lint detects possible meta-variable misuse
312    /// in macro definitions.
313    ///
314    /// ### Example
315    ///
316    /// ```rust,compile_fail
317    /// #![deny(meta_variable_misuse)]
318    ///
319    /// macro_rules! foo {
320    ///     () => {};
321    ///     ($( $i:ident = $($j:ident),+ );*) => { $( $( $i = $k; )+ )* };
322    /// }
323    ///
324    /// fn main() {
325    ///     foo!();
326    /// }
327    /// ```
328    ///
329    /// {{produces}}
330    ///
331    /// ### Explanation
332    ///
333    /// There are quite a few different ways a [`macro_rules`] macro can be
334    /// improperly defined. Many of these errors were previously only detected
335    /// when the macro was expanded or not at all. This lint is an attempt to
336    /// catch some of these problems when the macro is *defined*.
337    ///
338    /// This lint is "allow" by default because it may have false positives
339    /// and other issues. See [issue #61053] for more details.
340    ///
341    /// [`macro_rules`]: https://doc.rust-lang.org/reference/macros-by-example.html
342    /// [issue #61053]: https://github.com/rust-lang/rust/issues/61053
343    pub META_VARIABLE_MISUSE,
344    Allow,
345    "possible meta-variable misuse at macro definition"
346}
347
348#[doc = r" The `incomplete_include` lint detects the use of the [`include!`]"]
#[doc = r" macro with a file that contains more than one expression."]
#[doc = r""]
#[doc = r" [`include!`]: https://doc.rust-lang.org/std/macro.include.html"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs separate file)"]
#[doc = r" fn main() {"]
#[doc = r#"     include!("foo.txt");"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" where the file `foo.txt` contains:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r#" println!("hi!");"#]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" produces:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" error: include macro expected single expression in source"]
#[doc = r"  --> foo.txt:1:14"]
#[doc = r"   |"]
#[doc = r#" 1 | println!("1");"#]
#[doc = r"   |              ^"]
#[doc = r"   |"]
#[doc = r"   = note: `#[deny(incomplete_include)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" The [`include!`] macro is currently only intended to be used to"]
#[doc =
r" include a single [expression] or multiple [items]. Historically it"]
#[doc =
r" would ignore any contents after the first expression, but that can be"]
#[doc =
r" confusing. In the example above, the `println!` expression ends just"]
#[doc =
r#" before the semicolon, making the semicolon "extra" information that is"#]
#[doc = r" ignored. Perhaps even more surprising, if the included file had"]
#[doc = r" multiple print statements, the subsequent ones would be ignored!"]
#[doc = r""]
#[doc =
r" One workaround is to place the contents in braces to create a [block"]
#[doc = r" expression]. Also consider alternatives, like using functions to"]
#[doc = r" encapsulate the expressions, or use [proc-macros]."]
#[doc = r""]
#[doc =
r" This is a lint instead of a hard error because existing projects were"]
#[doc =
r" found to hit this error. To be cautious, it is a lint for now. The"]
#[doc = r" future semantics of the `include!` macro are also uncertain, see"]
#[doc = r" [issue #35560]."]
#[doc = r""]
#[doc = r" [items]: https://doc.rust-lang.org/reference/items.html"]
#[doc =
r" [expression]: https://doc.rust-lang.org/reference/expressions.html"]
#[doc =
r" [block expression]: https://doc.rust-lang.org/reference/expressions/block-expr.html"]
#[doc =
r" [proc-macros]: https://doc.rust-lang.org/reference/procedural-macros.html"]
#[doc = r" [issue #35560]: https://github.com/rust-lang/rust/issues/35560"]
pub static INCOMPLETE_INCLUDE: &crate::Lint =
    &crate::Lint {
            name: "INCOMPLETE_INCLUDE",
            default_level: crate::Deny,
            desc: "trailing content in included file",
            ..
        };declare_lint! {
349    /// The `incomplete_include` lint detects the use of the [`include!`]
350    /// macro with a file that contains more than one expression.
351    ///
352    /// [`include!`]: https://doc.rust-lang.org/std/macro.include.html
353    ///
354    /// ### Example
355    ///
356    /// ```rust,ignore (needs separate file)
357    /// fn main() {
358    ///     include!("foo.txt");
359    /// }
360    /// ```
361    ///
362    /// where the file `foo.txt` contains:
363    ///
364    /// ```text
365    /// println!("hi!");
366    /// ```
367    ///
368    /// produces:
369    ///
370    /// ```text
371    /// error: include macro expected single expression in source
372    ///  --> foo.txt:1:14
373    ///   |
374    /// 1 | println!("1");
375    ///   |              ^
376    ///   |
377    ///   = note: `#[deny(incomplete_include)]` on by default
378    /// ```
379    ///
380    /// ### Explanation
381    ///
382    /// The [`include!`] macro is currently only intended to be used to
383    /// include a single [expression] or multiple [items]. Historically it
384    /// would ignore any contents after the first expression, but that can be
385    /// confusing. In the example above, the `println!` expression ends just
386    /// before the semicolon, making the semicolon "extra" information that is
387    /// ignored. Perhaps even more surprising, if the included file had
388    /// multiple print statements, the subsequent ones would be ignored!
389    ///
390    /// One workaround is to place the contents in braces to create a [block
391    /// expression]. Also consider alternatives, like using functions to
392    /// encapsulate the expressions, or use [proc-macros].
393    ///
394    /// This is a lint instead of a hard error because existing projects were
395    /// found to hit this error. To be cautious, it is a lint for now. The
396    /// future semantics of the `include!` macro are also uncertain, see
397    /// [issue #35560].
398    ///
399    /// [items]: https://doc.rust-lang.org/reference/items.html
400    /// [expression]: https://doc.rust-lang.org/reference/expressions.html
401    /// [block expression]: https://doc.rust-lang.org/reference/expressions/block-expr.html
402    /// [proc-macros]: https://doc.rust-lang.org/reference/procedural-macros.html
403    /// [issue #35560]: https://github.com/rust-lang/rust/issues/35560
404    pub INCOMPLETE_INCLUDE,
405    Deny,
406    "trailing content in included file"
407}
408
409#[doc =
r" The `arithmetic_overflow` lint detects that an arithmetic operation"]
#[doc = r" will [overflow]."]
#[doc = r""]
#[doc =
r" [overflow]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" 1_i32 << 32;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is very likely a mistake to perform an arithmetic operation that"]
#[doc =
r" overflows its value. If the compiler is able to detect these kinds of"]
#[doc = r" overflows at compile-time, it will trigger this lint. Consider"]
#[doc =
r" adjusting the expression to avoid overflow, or use a data type that"]
#[doc = r" will not overflow."]
pub static ARITHMETIC_OVERFLOW: &crate::Lint =
    &crate::Lint {
            name: "ARITHMETIC_OVERFLOW",
            default_level: crate::Deny,
            desc: "arithmetic operation overflows",
            eval_always: true,
            ..
        };declare_lint! {
410    /// The `arithmetic_overflow` lint detects that an arithmetic operation
411    /// will [overflow].
412    ///
413    /// [overflow]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#overflow
414    ///
415    /// ### Example
416    ///
417    /// ```rust,compile_fail
418    /// 1_i32 << 32;
419    /// ```
420    ///
421    /// {{produces}}
422    ///
423    /// ### Explanation
424    ///
425    /// It is very likely a mistake to perform an arithmetic operation that
426    /// overflows its value. If the compiler is able to detect these kinds of
427    /// overflows at compile-time, it will trigger this lint. Consider
428    /// adjusting the expression to avoid overflow, or use a data type that
429    /// will not overflow.
430    pub ARITHMETIC_OVERFLOW,
431    Deny,
432    "arithmetic operation overflows",
433    @eval_always = true
434}
435
436#[doc =
r" The `unconditional_panic` lint detects an operation that will cause a"]
#[doc = r" panic at runtime."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" # #![allow(unused)]"]
#[doc = r" let x = 1 / 0;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This lint detects code that is very likely incorrect because it will"]
#[doc = r" always panic, such as division by zero and out-of-bounds array"]
#[doc =
r" accesses. Consider adjusting your code if this is a bug, or using the"]
#[doc =
r" `panic!` or `unreachable!` macro instead in case the panic is intended."]
pub static UNCONDITIONAL_PANIC: &crate::Lint =
    &crate::Lint {
            name: "UNCONDITIONAL_PANIC",
            default_level: crate::Deny,
            desc: "operation will cause a panic at runtime",
            eval_always: true,
            ..
        };declare_lint! {
437    /// The `unconditional_panic` lint detects an operation that will cause a
438    /// panic at runtime.
439    ///
440    /// ### Example
441    ///
442    /// ```rust,compile_fail
443    /// # #![allow(unused)]
444    /// let x = 1 / 0;
445    /// ```
446    ///
447    /// {{produces}}
448    ///
449    /// ### Explanation
450    ///
451    /// This lint detects code that is very likely incorrect because it will
452    /// always panic, such as division by zero and out-of-bounds array
453    /// accesses. Consider adjusting your code if this is a bug, or using the
454    /// `panic!` or `unreachable!` macro instead in case the panic is intended.
455    pub UNCONDITIONAL_PANIC,
456    Deny,
457    "operation will cause a panic at runtime",
458    @eval_always = true
459}
460
461#[doc = r" The `unused_imports` lint detects imports that are never used."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" use std::collections::HashMap;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused imports may signal a mistake or unfinished code, and clutter"]
#[doc =
r" the code, and should be removed. If you intended to re-export the item"]
#[doc =
r" to make it available outside of the module, add a visibility modifier"]
#[doc = r" like `pub`."]
pub static UNUSED_IMPORTS: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_IMPORTS",
            default_level: crate::Warn,
            desc: "imports that are never used",
            ..
        };declare_lint! {
462    /// The `unused_imports` lint detects imports that are never used.
463    ///
464    /// ### Example
465    ///
466    /// ```rust
467    /// use std::collections::HashMap;
468    /// ```
469    ///
470    /// {{produces}}
471    ///
472    /// ### Explanation
473    ///
474    /// Unused imports may signal a mistake or unfinished code, and clutter
475    /// the code, and should be removed. If you intended to re-export the item
476    /// to make it available outside of the module, add a visibility modifier
477    /// like `pub`.
478    pub UNUSED_IMPORTS,
479    Warn,
480    "imports that are never used"
481}
482
483#[doc =
r" The `redundant_imports` lint detects imports that are redundant due to being"]
#[doc =
r" imported already; either through a previous import, or being present in"]
#[doc = r" the prelude."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(redundant_imports)]"]
#[doc = r" use std::option::Option::None;"]
#[doc = r" fn foo() -> Option<i32> { None }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Redundant imports are unnecessary and can be removed to simplify code."]
#[doc =
r" If you intended to re-export the item to make it available outside of the"]
#[doc = r" module, add a visibility modifier like `pub`."]
pub static REDUNDANT_IMPORTS: &crate::Lint =
    &crate::Lint {
            name: "REDUNDANT_IMPORTS",
            default_level: crate::Allow,
            desc: "imports that are redundant due to being imported already",
            ..
        };declare_lint! {
484    /// The `redundant_imports` lint detects imports that are redundant due to being
485    /// imported already; either through a previous import, or being present in
486    /// the prelude.
487    ///
488    /// ### Example
489    ///
490    /// ```rust,compile_fail
491    /// #![deny(redundant_imports)]
492    /// use std::option::Option::None;
493    /// fn foo() -> Option<i32> { None }
494    /// ```
495    ///
496    /// {{produces}}
497    ///
498    /// ### Explanation
499    ///
500    /// Redundant imports are unnecessary and can be removed to simplify code.
501    /// If you intended to re-export the item to make it available outside of the
502    /// module, add a visibility modifier like `pub`.
503    pub REDUNDANT_IMPORTS,
504    Allow,
505    "imports that are redundant due to being imported already"
506}
507
508#[doc =
r" The `must_not_suspend` lint guards against values that shouldn't be held across suspend points"]
#[doc = r" (`.await`)"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![feature(must_not_suspend)]"]
#[doc = r" #![warn(must_not_suspend)]"]
#[doc = r""]
#[doc = r" #[must_not_suspend]"]
#[doc = r" struct SyncThing {}"]
#[doc = r""]
#[doc = r" async fn yield_now() {}"]
#[doc = r""]
#[doc = r" pub async fn uhoh() {"]
#[doc = r"     let guard = SyncThing {};"]
#[doc = r"     yield_now().await;"]
#[doc = r"     let _guard = guard;"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The `must_not_suspend` lint detects values that are marked with the `#[must_not_suspend]`"]
#[doc =
r#" attribute being held across suspend points. A "suspend" point is usually a `.await` in an async"#]
#[doc = r" function."]
#[doc = r""]
#[doc =
r" This attribute can be used to mark values that are semantically incorrect across suspends"]
#[doc =
r" (like certain types of timers), values that have async alternatives, and values that"]
#[doc =
r" regularly cause problems with the `Send`-ness of async fn's returned futures (like"]
#[doc = r" `MutexGuard`'s)"]
#[doc = r""]
pub static MUST_NOT_SUSPEND: &crate::Lint =
    &crate::Lint {
            name: "MUST_NOT_SUSPEND",
            default_level: crate::Allow,
            desc: "use of a `#[must_not_suspend]` value across a yield point",
            feature_gate: Some(rustc_span::sym::must_not_suspend),
            ..
        };declare_lint! {
509    /// The `must_not_suspend` lint guards against values that shouldn't be held across suspend points
510    /// (`.await`)
511    ///
512    /// ### Example
513    ///
514    /// ```rust
515    /// #![feature(must_not_suspend)]
516    /// #![warn(must_not_suspend)]
517    ///
518    /// #[must_not_suspend]
519    /// struct SyncThing {}
520    ///
521    /// async fn yield_now() {}
522    ///
523    /// pub async fn uhoh() {
524    ///     let guard = SyncThing {};
525    ///     yield_now().await;
526    ///     let _guard = guard;
527    /// }
528    /// ```
529    ///
530    /// {{produces}}
531    ///
532    /// ### Explanation
533    ///
534    /// The `must_not_suspend` lint detects values that are marked with the `#[must_not_suspend]`
535    /// attribute being held across suspend points. A "suspend" point is usually a `.await` in an async
536    /// function.
537    ///
538    /// This attribute can be used to mark values that are semantically incorrect across suspends
539    /// (like certain types of timers), values that have async alternatives, and values that
540    /// regularly cause problems with the `Send`-ness of async fn's returned futures (like
541    /// `MutexGuard`'s)
542    ///
543    pub MUST_NOT_SUSPEND,
544    Allow,
545    "use of a `#[must_not_suspend]` value across a yield point",
546    @feature_gate = must_not_suspend;
547}
548
549#[doc =
r" The `unused_extern_crates` lint guards against `extern crate` items"]
#[doc = r" that are never used."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(unused_extern_crates)]"]
#[doc = r" #![deny(warnings)]"]
#[doc = r" extern crate proc_macro;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" `extern crate` items that are unused have no effect and should be"]
#[doc =
r" removed. Note that there are some cases where specifying an `extern"]
#[doc =
r" crate` is desired for the side effect of ensuring the given crate is"]
#[doc =
r" linked, even though it is not otherwise directly referenced. The lint"]
#[doc = r" can be silenced by aliasing the crate to an underscore, such as"]
#[doc =
r" `extern crate foo as _`. Also note that it is no longer idiomatic to"]
#[doc =
r" use `extern crate` in the [2018 edition], as extern crates are now"]
#[doc = r" automatically added in scope."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because it can be noisy, and produce"#]
#[doc =
r" false-positives. If a dependency is being removed from a project, it"]
#[doc = r" is recommended to remove it from the build configuration (such as"]
#[doc = r" `Cargo.toml`) to ensure stale build entries aren't left behind."]
#[doc = r""]
#[doc =
r" [2018 edition]: https://doc.rust-lang.org/edition-guide/rust-2018/module-system/path-clarity.html#no-more-extern-crate"]
pub static UNUSED_EXTERN_CRATES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_EXTERN_CRATES",
            default_level: crate::Allow,
            desc: "extern crates that are never used",
            ..
        };declare_lint! {
550    /// The `unused_extern_crates` lint guards against `extern crate` items
551    /// that are never used.
552    ///
553    /// ### Example
554    ///
555    /// ```rust,compile_fail
556    /// #![deny(unused_extern_crates)]
557    /// #![deny(warnings)]
558    /// extern crate proc_macro;
559    /// ```
560    ///
561    /// {{produces}}
562    ///
563    /// ### Explanation
564    ///
565    /// `extern crate` items that are unused have no effect and should be
566    /// removed. Note that there are some cases where specifying an `extern
567    /// crate` is desired for the side effect of ensuring the given crate is
568    /// linked, even though it is not otherwise directly referenced. The lint
569    /// can be silenced by aliasing the crate to an underscore, such as
570    /// `extern crate foo as _`. Also note that it is no longer idiomatic to
571    /// use `extern crate` in the [2018 edition], as extern crates are now
572    /// automatically added in scope.
573    ///
574    /// This lint is "allow" by default because it can be noisy, and produce
575    /// false-positives. If a dependency is being removed from a project, it
576    /// is recommended to remove it from the build configuration (such as
577    /// `Cargo.toml`) to ensure stale build entries aren't left behind.
578    ///
579    /// [2018 edition]: https://doc.rust-lang.org/edition-guide/rust-2018/module-system/path-clarity.html#no-more-extern-crate
580    pub UNUSED_EXTERN_CRATES,
581    Allow,
582    "extern crates that are never used"
583}
584
585#[doc =
r" The `unused_crate_dependencies` lint detects crate dependencies that"]
#[doc = r" are never used."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs extern crate)"]
#[doc = r" #![deny(unused_crate_dependencies)]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" error: extern crate `regex` is unused in crate `lint_example`"]
#[doc = r"   |"]
#[doc =
r"   = help: remove the dependency or add `use regex as _;` to the crate root"]
#[doc = r" note: the lint level is defined here"]
#[doc = r"  --> src/lib.rs:1:9"]
#[doc = r"   |"]
#[doc = r" 1 | #![deny(unused_crate_dependencies)]"]
#[doc = r"   |         ^^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" After removing the code that uses a dependency, this usually also"]
#[doc = r" requires removing the dependency from the build configuration."]
#[doc =
r" However, sometimes that step can be missed, which leads to time wasted"]
#[doc = r" building dependencies that are no longer used. This lint can be"]
#[doc =
r" enabled to detect dependencies that are never used (more specifically,"]
#[doc =
r" any dependency passed with the `--extern` command-line flag that is"]
#[doc =
r" never referenced via [`use`], [`extern crate`], or in any [path])."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because it can provide false positives"#]
#[doc =
r" depending on how the build system is configured. For example, when"]
#[doc = r#" using Cargo, a "package" consists of multiple crates (such as a"#]
#[doc = r" library and a binary), but the dependencies are defined for the"]
#[doc =
r" package as a whole. If there is a dependency that is only used in the"]
#[doc =
r" binary, but not the library, then the lint will be incorrectly issued"]
#[doc = r" in the library."]
#[doc = r""]
#[doc = r" [path]: https://doc.rust-lang.org/reference/paths.html"]
#[doc =
r" [`use`]: https://doc.rust-lang.org/reference/items/use-declarations.html"]
#[doc =
r" [`extern crate`]: https://doc.rust-lang.org/reference/items/extern-crates.html"]
pub static UNUSED_CRATE_DEPENDENCIES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_CRATE_DEPENDENCIES",
            default_level: crate::Allow,
            desc: "crate dependencies that are never used",
            crate_level_only: true,
            ..
        };declare_lint! {
586    /// The `unused_crate_dependencies` lint detects crate dependencies that
587    /// are never used.
588    ///
589    /// ### Example
590    ///
591    /// ```rust,ignore (needs extern crate)
592    /// #![deny(unused_crate_dependencies)]
593    /// ```
594    ///
595    /// This will produce:
596    ///
597    /// ```text
598    /// error: extern crate `regex` is unused in crate `lint_example`
599    ///   |
600    ///   = help: remove the dependency or add `use regex as _;` to the crate root
601    /// note: the lint level is defined here
602    ///  --> src/lib.rs:1:9
603    ///   |
604    /// 1 | #![deny(unused_crate_dependencies)]
605    ///   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
606    /// ```
607    ///
608    /// ### Explanation
609    ///
610    /// After removing the code that uses a dependency, this usually also
611    /// requires removing the dependency from the build configuration.
612    /// However, sometimes that step can be missed, which leads to time wasted
613    /// building dependencies that are no longer used. This lint can be
614    /// enabled to detect dependencies that are never used (more specifically,
615    /// any dependency passed with the `--extern` command-line flag that is
616    /// never referenced via [`use`], [`extern crate`], or in any [path]).
617    ///
618    /// This lint is "allow" by default because it can provide false positives
619    /// depending on how the build system is configured. For example, when
620    /// using Cargo, a "package" consists of multiple crates (such as a
621    /// library and a binary), but the dependencies are defined for the
622    /// package as a whole. If there is a dependency that is only used in the
623    /// binary, but not the library, then the lint will be incorrectly issued
624    /// in the library.
625    ///
626    /// [path]: https://doc.rust-lang.org/reference/paths.html
627    /// [`use`]: https://doc.rust-lang.org/reference/items/use-declarations.html
628    /// [`extern crate`]: https://doc.rust-lang.org/reference/items/extern-crates.html
629    pub UNUSED_CRATE_DEPENDENCIES,
630    Allow,
631    "crate dependencies that are never used",
632    crate_level_only
633}
634
635#[doc = r" The `unused_qualifications` lint detects unnecessarily qualified"]
#[doc = r" names."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(unused_qualifications)]"]
#[doc = r" mod foo {"]
#[doc = r"     pub fn bar() {}"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     use foo::bar;"]
#[doc = r"     foo::bar();"]
#[doc = r"     bar();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" If an item from another module is already brought into scope, then"]
#[doc = r" there is no need to qualify it in this case. You can call `bar()`"]
#[doc = r" directly, without the `foo::`."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because it is somewhat pedantic, and"#]
#[doc =
r" doesn't indicate an actual problem, but rather a stylistic choice, and"]
#[doc = r" can be noisy when refactoring or moving around code."]
pub static UNUSED_QUALIFICATIONS: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_QUALIFICATIONS",
            default_level: crate::Allow,
            desc: "detects unnecessarily qualified names",
            ..
        };declare_lint! {
636    /// The `unused_qualifications` lint detects unnecessarily qualified
637    /// names.
638    ///
639    /// ### Example
640    ///
641    /// ```rust,compile_fail
642    /// #![deny(unused_qualifications)]
643    /// mod foo {
644    ///     pub fn bar() {}
645    /// }
646    ///
647    /// fn main() {
648    ///     use foo::bar;
649    ///     foo::bar();
650    ///     bar();
651    /// }
652    /// ```
653    ///
654    /// {{produces}}
655    ///
656    /// ### Explanation
657    ///
658    /// If an item from another module is already brought into scope, then
659    /// there is no need to qualify it in this case. You can call `bar()`
660    /// directly, without the `foo::`.
661    ///
662    /// This lint is "allow" by default because it is somewhat pedantic, and
663    /// doesn't indicate an actual problem, but rather a stylistic choice, and
664    /// can be noisy when refactoring or moving around code.
665    pub UNUSED_QUALIFICATIONS,
666    Allow,
667    "detects unnecessarily qualified names"
668}
669
670#[doc = r" The `unknown_lints` lint detects unrecognized lint attributes."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![allow(not_a_real_lint)]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is usually a mistake to specify a lint that does not exist. Check"]
#[doc =
r" the spelling, and check the lint listing for the correct name. Also"]
#[doc =
r" consider if you are using an old version of the compiler, and the lint"]
#[doc = r" is only available in a newer version."]
pub static UNKNOWN_LINTS: &crate::Lint =
    &crate::Lint {
            name: "UNKNOWN_LINTS",
            default_level: crate::Warn,
            desc: "unrecognized lint attribute",
            eval_always: true,
            ..
        };declare_lint! {
671    /// The `unknown_lints` lint detects unrecognized lint attributes.
672    ///
673    /// ### Example
674    ///
675    /// ```rust
676    /// #![allow(not_a_real_lint)]
677    /// ```
678    ///
679    /// {{produces}}
680    ///
681    /// ### Explanation
682    ///
683    /// It is usually a mistake to specify a lint that does not exist. Check
684    /// the spelling, and check the lint listing for the correct name. Also
685    /// consider if you are using an old version of the compiler, and the lint
686    /// is only available in a newer version.
687    pub UNKNOWN_LINTS,
688    Warn,
689    "unrecognized lint attribute",
690    @eval_always = true
691}
692
693#[doc =
r" The `unfulfilled_lint_expectations` lint detects when a lint expectation is"]
#[doc = r" unfulfilled."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #[expect(unused_variables)]"]
#[doc = r" let x = 10;"]
#[doc = r#" println!("{}", x);"#]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The `#[expect]` attribute can be used to create a lint expectation. The"]
#[doc =
r" expectation is fulfilled, if a `#[warn]` attribute at the same location"]
#[doc =
r" would result in a lint emission. If the expectation is unfulfilled,"]
#[doc =
r" because no lint was emitted, this lint will be emitted on the attribute."]
#[doc = r""]
pub static UNFULFILLED_LINT_EXPECTATIONS: &crate::Lint =
    &crate::Lint {
            name: "UNFULFILLED_LINT_EXPECTATIONS",
            default_level: crate::Warn,
            desc: "unfulfilled lint expectation",
            ..
        };declare_lint! {
694    /// The `unfulfilled_lint_expectations` lint detects when a lint expectation is
695    /// unfulfilled.
696    ///
697    /// ### Example
698    ///
699    /// ```rust
700    /// #[expect(unused_variables)]
701    /// let x = 10;
702    /// println!("{}", x);
703    /// ```
704    ///
705    /// {{produces}}
706    ///
707    /// ### Explanation
708    ///
709    /// The `#[expect]` attribute can be used to create a lint expectation. The
710    /// expectation is fulfilled, if a `#[warn]` attribute at the same location
711    /// would result in a lint emission. If the expectation is unfulfilled,
712    /// because no lint was emitted, this lint will be emitted on the attribute.
713    ///
714    pub UNFULFILLED_LINT_EXPECTATIONS,
715    Warn,
716    "unfulfilled lint expectation"
717}
718
719#[doc =
r" The `unused_variables` lint detects variables which are not used in"]
#[doc = r" any way."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" let x = 5;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused variables may signal a mistake or unfinished code. To silence"]
#[doc =
r" the warning for the individual variable, prefix it with an underscore"]
#[doc = r" such as `_x`."]
pub static UNUSED_VARIABLES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_VARIABLES",
            default_level: crate::Warn,
            desc: "detect variables which are not used in any way",
            ..
        };declare_lint! {
720    /// The `unused_variables` lint detects variables which are not used in
721    /// any way.
722    ///
723    /// ### Example
724    ///
725    /// ```rust
726    /// let x = 5;
727    /// ```
728    ///
729    /// {{produces}}
730    ///
731    /// ### Explanation
732    ///
733    /// Unused variables may signal a mistake or unfinished code. To silence
734    /// the warning for the individual variable, prefix it with an underscore
735    /// such as `_x`.
736    pub UNUSED_VARIABLES,
737    Warn,
738    "detect variables which are not used in any way"
739}
740
741#[doc =
r" The `unused_visibilities` lint detects visibility qualifiers (like `pub`)"]
#[doc = r" on a `const _` item."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" pub const _: () = {};"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" These qualifiers have no effect, as `const _` items are unnameable."]
pub static UNUSED_VISIBILITIES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_VISIBILITIES",
            default_level: crate::Warn,
            desc: "detect visibility qualifiers on `const _` items",
            ..
        };declare_lint! {
742    /// The `unused_visibilities` lint detects visibility qualifiers (like `pub`)
743    /// on a `const _` item.
744    ///
745    /// ### Example
746    ///
747    /// ```rust
748    /// pub const _: () = {};
749    /// ```
750    ///
751    /// {{produces}}
752    ///
753    /// ### Explanation
754    ///
755    /// These qualifiers have no effect, as `const _` items are unnameable.
756    pub UNUSED_VISIBILITIES,
757    Warn,
758    "detect visibility qualifiers on `const _` items"
759}
760
761#[doc =
r" The `unused_assignments` lint detects assignments that will never be read."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" let mut x = 5;"]
#[doc = r" x = 6;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused assignments may signal a mistake or unfinished code. If the"]
#[doc =
r" variable is never used after being assigned, then the assignment can"]
#[doc =
r" be removed. Variables with an underscore prefix such as `_x` will not"]
#[doc = r" trigger this lint."]
pub static UNUSED_ASSIGNMENTS: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_ASSIGNMENTS",
            default_level: crate::Warn,
            desc: "detect assignments that will never be read",
            ..
        };declare_lint! {
762    /// The `unused_assignments` lint detects assignments that will never be read.
763    ///
764    /// ### Example
765    ///
766    /// ```rust
767    /// let mut x = 5;
768    /// x = 6;
769    /// ```
770    ///
771    /// {{produces}}
772    ///
773    /// ### Explanation
774    ///
775    /// Unused assignments may signal a mistake or unfinished code. If the
776    /// variable is never used after being assigned, then the assignment can
777    /// be removed. Variables with an underscore prefix such as `_x` will not
778    /// trigger this lint.
779    pub UNUSED_ASSIGNMENTS,
780    Warn,
781    "detect assignments that will never be read"
782}
783
784#[doc = r" The `dead_code` lint detects unused, unexported items."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" fn foo() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Dead code may signal a mistake or unfinished code. To silence the"]
#[doc =
r" warning for individual items, prefix the name with an underscore such"]
#[doc =
r" as `_foo`. If it was intended to expose the item outside of the crate,"]
#[doc = r" consider adding a visibility modifier like `pub`."]
#[doc = r""]
#[doc = r" To preserve the numbering of tuple structs with unused fields,"]
#[doc = r" change the unused fields to have unit type or use"]
#[doc = r" `PhantomData`."]
#[doc = r""]
#[doc = r" Otherwise consider removing the unused code."]
#[doc = r""]
#[doc = r" ### Limitations"]
#[doc = r""]
#[doc = r" Removing fields that are only used for side-effects and never"]
#[doc = r" read will result in behavioral changes. Examples of this"]
#[doc = r" include:"]
#[doc = r""]
#[doc = r" - If a field's value performs an action when it is dropped."]
#[doc = r" - If a field's type does not implement an auto trait"]
#[doc = r"   (e.g. `Send`, `Sync`, `Unpin`)."]
#[doc = r""]
#[doc = r" For side-effects from dropping field values, this lint should"]
#[doc = r" be allowed on those fields. For side-effects from containing"]
#[doc = r" field types, `PhantomData` should be used."]
pub static DEAD_CODE: &crate::Lint =
    &crate::Lint {
            name: "DEAD_CODE",
            default_level: crate::Warn,
            desc: "detect unused, unexported items",
            ..
        };declare_lint! {
785    /// The `dead_code` lint detects unused, unexported items.
786    ///
787    /// ### Example
788    ///
789    /// ```rust
790    /// fn foo() {}
791    /// ```
792    ///
793    /// {{produces}}
794    ///
795    /// ### Explanation
796    ///
797    /// Dead code may signal a mistake or unfinished code. To silence the
798    /// warning for individual items, prefix the name with an underscore such
799    /// as `_foo`. If it was intended to expose the item outside of the crate,
800    /// consider adding a visibility modifier like `pub`.
801    ///
802    /// To preserve the numbering of tuple structs with unused fields,
803    /// change the unused fields to have unit type or use
804    /// `PhantomData`.
805    ///
806    /// Otherwise consider removing the unused code.
807    ///
808    /// ### Limitations
809    ///
810    /// Removing fields that are only used for side-effects and never
811    /// read will result in behavioral changes. Examples of this
812    /// include:
813    ///
814    /// - If a field's value performs an action when it is dropped.
815    /// - If a field's type does not implement an auto trait
816    ///   (e.g. `Send`, `Sync`, `Unpin`).
817    ///
818    /// For side-effects from dropping field values, this lint should
819    /// be allowed on those fields. For side-effects from containing
820    /// field types, `PhantomData` should be used.
821    pub DEAD_CODE,
822    Warn,
823    "detect unused, unexported items"
824}
825
826#[doc = r" The `dead_code_pub_in_binary` lint detects unused `pub` items in"]
#[doc = r" executable crates."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(dead_code_pub_in_binary)]"]
#[doc = r""]
#[doc = r" pub fn unused_pub_fn() {}"]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In executable crates, `pub` items are often implementation details"]
#[doc =
r" rather than part of an external API. This lint helps find those items"]
#[doc = r" when they are never used."]
#[doc = r""]
#[doc =
r" This lint only applies to executable crates. In library crates, public"]
#[doc =
r" items are considered part of the crate's API and are not reported by"]
#[doc = r" this lint."]
pub static DEAD_CODE_PUB_IN_BINARY: &crate::Lint =
    &crate::Lint {
            name: "DEAD_CODE_PUB_IN_BINARY",
            default_level: crate::Allow,
            desc: "detect public items in executable crates that are never used",
            crate_level_only: true,
            ..
        };declare_lint! {
827    /// The `dead_code_pub_in_binary` lint detects unused `pub` items in
828    /// executable crates.
829    ///
830    /// ### Example
831    ///
832    /// ```rust,compile_fail
833    /// #![deny(dead_code_pub_in_binary)]
834    ///
835    /// pub fn unused_pub_fn() {}
836    ///
837    /// fn main() {}
838    /// ```
839    ///
840    /// {{produces}}
841    ///
842    /// ### Explanation
843    ///
844    /// In executable crates, `pub` items are often implementation details
845    /// rather than part of an external API. This lint helps find those items
846    /// when they are never used.
847    ///
848    /// This lint only applies to executable crates. In library crates, public
849    /// items are considered part of the crate's API and are not reported by
850    /// this lint.
851    pub DEAD_CODE_PUB_IN_BINARY,
852    Allow,
853    "detect public items in executable crates that are never used",
854    crate_level_only
855}
856
857#[doc =
r" The `unused_attributes` lint detects attributes that were not used by"]
#[doc = r" the compiler."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![ignore]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused [attributes] may indicate the attribute is placed in the wrong"]
#[doc =
r" position. Consider removing it, or placing it in the correct position."]
#[doc =
r" Also consider if you intended to use an _inner attribute_ (with a `!`"]
#[doc =
r" such as `#![allow(unused)]`) which applies to the item the attribute"]
#[doc = r" is within, or an _outer attribute_ (without a `!` such as"]
#[doc = r" `#[allow(unused)]`) which applies to the item *following* the"]
#[doc = r" attribute."]
#[doc = r""]
#[doc = r" [attributes]: https://doc.rust-lang.org/reference/attributes.html"]
pub static UNUSED_ATTRIBUTES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_ATTRIBUTES",
            default_level: crate::Warn,
            desc: "detects attributes that were not used by the compiler",
            ..
        };declare_lint! {
858    /// The `unused_attributes` lint detects attributes that were not used by
859    /// the compiler.
860    ///
861    /// ### Example
862    ///
863    /// ```rust
864    /// #![ignore]
865    /// ```
866    ///
867    /// {{produces}}
868    ///
869    /// ### Explanation
870    ///
871    /// Unused [attributes] may indicate the attribute is placed in the wrong
872    /// position. Consider removing it, or placing it in the correct position.
873    /// Also consider if you intended to use an _inner attribute_ (with a `!`
874    /// such as `#![allow(unused)]`) which applies to the item the attribute
875    /// is within, or an _outer attribute_ (without a `!` such as
876    /// `#[allow(unused)]`) which applies to the item *following* the
877    /// attribute.
878    ///
879    /// [attributes]: https://doc.rust-lang.org/reference/attributes.html
880    pub UNUSED_ATTRIBUTES,
881    Warn,
882    "detects attributes that were not used by the compiler"
883}
884
885#[doc = r" The `unreachable_code` lint detects unreachable code paths."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,no_run"]
#[doc = r#" panic!("we never go past here!");"#]
#[doc = r""]
#[doc = r" let x = 5;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unreachable code may signal a mistake or unfinished code. If the code"]
#[doc = r" is no longer in use, consider removing it."]
pub static UNREACHABLE_CODE: &crate::Lint =
    &crate::Lint {
            name: "UNREACHABLE_CODE",
            default_level: crate::Warn,
            desc: "detects unreachable code paths",
            report_in_external_macro: true,
            ..
        };declare_lint! {
886    /// The `unreachable_code` lint detects unreachable code paths.
887    ///
888    /// ### Example
889    ///
890    /// ```rust,no_run
891    /// panic!("we never go past here!");
892    ///
893    /// let x = 5;
894    /// ```
895    ///
896    /// {{produces}}
897    ///
898    /// ### Explanation
899    ///
900    /// Unreachable code may signal a mistake or unfinished code. If the code
901    /// is no longer in use, consider removing it.
902    pub UNREACHABLE_CODE,
903    Warn,
904    "detects unreachable code paths",
905    report_in_external_macro
906}
907
908#[doc = r" The `unreachable_patterns` lint detects unreachable patterns."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" let x = 5;"]
#[doc = r" match x {"]
#[doc = r"     y => (),"]
#[doc = r"     5 => (),"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This usually indicates a mistake in how the patterns are specified or"]
#[doc =
r" ordered. In this example, the `y` pattern will always match, so the"]
#[doc =
r" five is impossible to reach. Remember, match arms match in order, you"]
#[doc = r" probably wanted to put the `5` case above the `y` case."]
pub static UNREACHABLE_PATTERNS: &crate::Lint =
    &crate::Lint {
            name: "UNREACHABLE_PATTERNS",
            default_level: crate::Warn,
            desc: "detects unreachable patterns",
            ..
        };declare_lint! {
909    /// The `unreachable_patterns` lint detects unreachable patterns.
910    ///
911    /// ### Example
912    ///
913    /// ```rust
914    /// let x = 5;
915    /// match x {
916    ///     y => (),
917    ///     5 => (),
918    /// }
919    /// ```
920    ///
921    /// {{produces}}
922    ///
923    /// ### Explanation
924    ///
925    /// This usually indicates a mistake in how the patterns are specified or
926    /// ordered. In this example, the `y` pattern will always match, so the
927    /// five is impossible to reach. Remember, match arms match in order, you
928    /// probably wanted to put the `5` case above the `y` case.
929    pub UNREACHABLE_PATTERNS,
930    Warn,
931    "detects unreachable patterns"
932}
933
934#[doc =
r" The `unreachable_cfg_select_predicates` lint detects unreachable configuration"]
#[doc = r" predicates in the `cfg_select!` macro."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" cfg_select! {"]
#[doc = r"     _ => (),"]
#[doc = r"     windows => (),"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This usually indicates a mistake in how the predicates are specified or"]
#[doc =
r" ordered. In this example, the `_` predicate will always match, so the"]
#[doc =
r" `windows` is impossible to reach. Remember, arms match in order, you"]
#[doc = r" probably wanted to put the `windows` case above the `_` case."]
pub static UNREACHABLE_CFG_SELECT_PREDICATES: &crate::Lint =
    &crate::Lint {
            name: "UNREACHABLE_CFG_SELECT_PREDICATES",
            default_level: crate::Warn,
            desc: "detects unreachable configuration predicates in the cfg_select macro",
            ..
        };declare_lint! {
935    /// The `unreachable_cfg_select_predicates` lint detects unreachable configuration
936    /// predicates in the `cfg_select!` macro.
937    ///
938    /// ### Example
939    ///
940    /// ```rust
941    /// cfg_select! {
942    ///     _ => (),
943    ///     windows => (),
944    /// }
945    /// ```
946    ///
947    /// {{produces}}
948    ///
949    /// ### Explanation
950    ///
951    /// This usually indicates a mistake in how the predicates are specified or
952    /// ordered. In this example, the `_` predicate will always match, so the
953    /// `windows` is impossible to reach. Remember, arms match in order, you
954    /// probably wanted to put the `windows` case above the `_` case.
955    pub UNREACHABLE_CFG_SELECT_PREDICATES,
956    Warn,
957    "detects unreachable configuration predicates in the cfg_select macro",
958}
959
960#[doc =
r" The `overlapping_range_endpoints` lint detects `match` arms that have [range patterns] that"]
#[doc = r" overlap on their endpoints."]
#[doc = r""]
#[doc =
r" [range patterns]: https://doc.rust-lang.org/nightly/reference/patterns.html#range-patterns"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" let x = 123u8;"]
#[doc = r" match x {"]
#[doc = r#"     0..=100 => { println!("small"); }"#]
#[doc = r#"     100..=255 => { println!("large"); }"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is likely a mistake to have range patterns in a match expression that overlap in this"]
#[doc =
r" way. Check that the beginning and end values are what you expect, and keep in mind that"]
#[doc = r" with `..=` the left and right bounds are inclusive."]
pub static OVERLAPPING_RANGE_ENDPOINTS: &crate::Lint =
    &crate::Lint {
            name: "OVERLAPPING_RANGE_ENDPOINTS",
            default_level: crate::Warn,
            desc: "detects range patterns with overlapping endpoints",
            ..
        };declare_lint! {
961    /// The `overlapping_range_endpoints` lint detects `match` arms that have [range patterns] that
962    /// overlap on their endpoints.
963    ///
964    /// [range patterns]: https://doc.rust-lang.org/nightly/reference/patterns.html#range-patterns
965    ///
966    /// ### Example
967    ///
968    /// ```rust
969    /// let x = 123u8;
970    /// match x {
971    ///     0..=100 => { println!("small"); }
972    ///     100..=255 => { println!("large"); }
973    /// }
974    /// ```
975    ///
976    /// {{produces}}
977    ///
978    /// ### Explanation
979    ///
980    /// It is likely a mistake to have range patterns in a match expression that overlap in this
981    /// way. Check that the beginning and end values are what you expect, and keep in mind that
982    /// with `..=` the left and right bounds are inclusive.
983    pub OVERLAPPING_RANGE_ENDPOINTS,
984    Warn,
985    "detects range patterns with overlapping endpoints"
986}
987
988#[doc =
r" The `non_contiguous_range_endpoints` lint detects likely off-by-one errors when using"]
#[doc = r" exclusive [range patterns]."]
#[doc = r""]
#[doc =
r" [range patterns]: https://doc.rust-lang.org/nightly/reference/patterns.html#range-patterns"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" let x = 123u32;"]
#[doc = r" match x {"]
#[doc = r#"     0..100 => { println!("small"); }"#]
#[doc = r#"     101..1000 => { println!("large"); }"#]
#[doc = r#"     _ => { println!("larger"); }"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is likely a mistake to have range patterns in a match expression that miss out a single"]
#[doc =
r" number. Check that the beginning and end values are what you expect, and keep in mind that"]
#[doc =
r" with `..=` the right bound is inclusive, and with `..` it is exclusive."]
pub static NON_CONTIGUOUS_RANGE_ENDPOINTS: &crate::Lint =
    &crate::Lint {
            name: "NON_CONTIGUOUS_RANGE_ENDPOINTS",
            default_level: crate::Warn,
            desc: "detects off-by-one errors with exclusive range patterns",
            ..
        };declare_lint! {
989    /// The `non_contiguous_range_endpoints` lint detects likely off-by-one errors when using
990    /// exclusive [range patterns].
991    ///
992    /// [range patterns]: https://doc.rust-lang.org/nightly/reference/patterns.html#range-patterns
993    ///
994    /// ### Example
995    ///
996    /// ```rust
997    /// let x = 123u32;
998    /// match x {
999    ///     0..100 => { println!("small"); }
1000    ///     101..1000 => { println!("large"); }
1001    ///     _ => { println!("larger"); }
1002    /// }
1003    /// ```
1004    ///
1005    /// {{produces}}
1006    ///
1007    /// ### Explanation
1008    ///
1009    /// It is likely a mistake to have range patterns in a match expression that miss out a single
1010    /// number. Check that the beginning and end values are what you expect, and keep in mind that
1011    /// with `..=` the right bound is inclusive, and with `..` it is exclusive.
1012    pub NON_CONTIGUOUS_RANGE_ENDPOINTS,
1013    Warn,
1014    "detects off-by-one errors with exclusive range patterns"
1015}
1016
1017#[doc =
r" The `bindings_with_variant_name` lint detects pattern bindings with"]
#[doc = r" the same name as one of the matched variants."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" pub enum Enum {"]
#[doc = r"     Foo,"]
#[doc = r"     Bar,"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" pub fn foo(x: Enum) {"]
#[doc = r"     match x {"]
#[doc = r"         Foo => {}"]
#[doc = r"         Bar => {}"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" It is usually a mistake to specify an enum variant name as an"]
#[doc = r" [identifier pattern]. In the example above, the `match` arms are"]
#[doc =
r" specifying a variable name to bind the value of `x` to. The second arm"]
#[doc = r" is ignored because the first one matches *all* values. The likely"]
#[doc = r" intent is that the arm was intended to match on the enum variant."]
#[doc = r""]
#[doc = r" Two possible solutions are:"]
#[doc = r""]
#[doc = r" * Specify the enum variant using a [path pattern], such as"]
#[doc = r"   `Enum::Foo`."]
#[doc = r" * Bring the enum variants into local scope, such as adding `use"]
#[doc = r"   Enum::*;` to the beginning of the `foo` function in the example"]
#[doc = r"   above."]
#[doc = r""]
#[doc =
r" [identifier pattern]: https://doc.rust-lang.org/reference/patterns.html#identifier-patterns"]
#[doc =
r" [path pattern]: https://doc.rust-lang.org/reference/patterns.html#path-patterns"]
pub static BINDINGS_WITH_VARIANT_NAME: &crate::Lint =
    &crate::Lint {
            name: "BINDINGS_WITH_VARIANT_NAME",
            default_level: crate::Deny,
            desc: "detects pattern bindings with the same name as one of the matched variants",
            ..
        };declare_lint! {
1018    /// The `bindings_with_variant_name` lint detects pattern bindings with
1019    /// the same name as one of the matched variants.
1020    ///
1021    /// ### Example
1022    ///
1023    /// ```rust,compile_fail
1024    /// pub enum Enum {
1025    ///     Foo,
1026    ///     Bar,
1027    /// }
1028    ///
1029    /// pub fn foo(x: Enum) {
1030    ///     match x {
1031    ///         Foo => {}
1032    ///         Bar => {}
1033    ///     }
1034    /// }
1035    /// ```
1036    ///
1037    /// {{produces}}
1038    ///
1039    /// ### Explanation
1040    ///
1041    /// It is usually a mistake to specify an enum variant name as an
1042    /// [identifier pattern]. In the example above, the `match` arms are
1043    /// specifying a variable name to bind the value of `x` to. The second arm
1044    /// is ignored because the first one matches *all* values. The likely
1045    /// intent is that the arm was intended to match on the enum variant.
1046    ///
1047    /// Two possible solutions are:
1048    ///
1049    /// * Specify the enum variant using a [path pattern], such as
1050    ///   `Enum::Foo`.
1051    /// * Bring the enum variants into local scope, such as adding `use
1052    ///   Enum::*;` to the beginning of the `foo` function in the example
1053    ///   above.
1054    ///
1055    /// [identifier pattern]: https://doc.rust-lang.org/reference/patterns.html#identifier-patterns
1056    /// [path pattern]: https://doc.rust-lang.org/reference/patterns.html#path-patterns
1057    pub BINDINGS_WITH_VARIANT_NAME,
1058    Deny,
1059    "detects pattern bindings with the same name as one of the matched variants"
1060}
1061
1062#[doc = r" The `unused_macros` lint detects macros that were not used."]
#[doc = r""]
#[doc =
r" Note that this lint is distinct from the `unused_macro_rules` lint,"]
#[doc =
r" which checks for single rules that never match of an otherwise used"]
#[doc = r" macro, and thus never expand."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" macro_rules! unused {"]
#[doc = r"     () => {};"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused macros may signal a mistake or unfinished code. To silence the"]
#[doc =
r" warning for the individual macro, prefix the name with an underscore"]
#[doc =
r" such as `_my_macro`. If you intended to export the macro to make it"]
#[doc =
r" available outside of the crate, use the [`macro_export` attribute]."]
#[doc = r""]
#[doc =
r" [`macro_export` attribute]: https://doc.rust-lang.org/reference/macros-by-example.html#path-based-scope"]
pub static UNUSED_MACROS: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_MACROS",
            default_level: crate::Warn,
            desc: "detects macros that were not used",
            ..
        };declare_lint! {
1063    /// The `unused_macros` lint detects macros that were not used.
1064    ///
1065    /// Note that this lint is distinct from the `unused_macro_rules` lint,
1066    /// which checks for single rules that never match of an otherwise used
1067    /// macro, and thus never expand.
1068    ///
1069    /// ### Example
1070    ///
1071    /// ```rust
1072    /// macro_rules! unused {
1073    ///     () => {};
1074    /// }
1075    ///
1076    /// fn main() {
1077    /// }
1078    /// ```
1079    ///
1080    /// {{produces}}
1081    ///
1082    /// ### Explanation
1083    ///
1084    /// Unused macros may signal a mistake or unfinished code. To silence the
1085    /// warning for the individual macro, prefix the name with an underscore
1086    /// such as `_my_macro`. If you intended to export the macro to make it
1087    /// available outside of the crate, use the [`macro_export` attribute].
1088    ///
1089    /// [`macro_export` attribute]: https://doc.rust-lang.org/reference/macros-by-example.html#path-based-scope
1090    pub UNUSED_MACROS,
1091    Warn,
1092    "detects macros that were not used"
1093}
1094
1095#[doc =
r" The `unused_macro_rules` lint detects macro rules that were not used."]
#[doc = r""]
#[doc =
r" Note that the lint is distinct from the `unused_macros` lint, which"]
#[doc =
r" fires if the entire macro is never called, while this lint fires for"]
#[doc = r" single unused rules of the macro that is otherwise used."]
#[doc = r" `unused_macro_rules` fires only if `unused_macros` wouldn't fire."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #[warn(unused_macro_rules)]"]
#[doc = r" macro_rules! unused_empty {"]
#[doc =
r#"     (hello) => { println!("Hello, world!") }; // This rule is used"#]
#[doc = r#"     () => { println!("empty") }; // This rule is unused"#]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     unused_empty!(hello);"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused macro rules may signal a mistake or unfinished code. Furthermore,"]
#[doc =
r" they slow down compilation. Right now, silencing the warning is not"]
#[doc =
r" supported on a single rule level, so you have to add an allow to the"]
#[doc = r" entire macro definition."]
#[doc = r""]
#[doc = r" If you intended to export the macro to make it"]
#[doc =
r" available outside of the crate, use the [`macro_export` attribute]."]
#[doc = r""]
#[doc =
r" [`macro_export` attribute]: https://doc.rust-lang.org/reference/macros-by-example.html#path-based-scope"]
pub static UNUSED_MACRO_RULES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_MACRO_RULES",
            default_level: crate::Allow,
            desc: "detects macro rules that were not used",
            ..
        };declare_lint! {
1096    /// The `unused_macro_rules` lint detects macro rules that were not used.
1097    ///
1098    /// Note that the lint is distinct from the `unused_macros` lint, which
1099    /// fires if the entire macro is never called, while this lint fires for
1100    /// single unused rules of the macro that is otherwise used.
1101    /// `unused_macro_rules` fires only if `unused_macros` wouldn't fire.
1102    ///
1103    /// ### Example
1104    ///
1105    /// ```rust
1106    /// #[warn(unused_macro_rules)]
1107    /// macro_rules! unused_empty {
1108    ///     (hello) => { println!("Hello, world!") }; // This rule is used
1109    ///     () => { println!("empty") }; // This rule is unused
1110    /// }
1111    ///
1112    /// fn main() {
1113    ///     unused_empty!(hello);
1114    /// }
1115    /// ```
1116    ///
1117    /// {{produces}}
1118    ///
1119    /// ### Explanation
1120    ///
1121    /// Unused macro rules may signal a mistake or unfinished code. Furthermore,
1122    /// they slow down compilation. Right now, silencing the warning is not
1123    /// supported on a single rule level, so you have to add an allow to the
1124    /// entire macro definition.
1125    ///
1126    /// If you intended to export the macro to make it
1127    /// available outside of the crate, use the [`macro_export` attribute].
1128    ///
1129    /// [`macro_export` attribute]: https://doc.rust-lang.org/reference/macros-by-example.html#path-based-scope
1130    pub UNUSED_MACRO_RULES,
1131    Allow,
1132    "detects macro rules that were not used"
1133}
1134
1135#[doc = r" The `warnings` lint allows you to change the level of other"]
#[doc = r" lints which produce warnings."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(warnings)]"]
#[doc = r" struct non_standard_name;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" The `warnings` lint is a bit special; by changing its level, you"]
#[doc =
r" change every other warning that would produce a warning to whatever"]
#[doc =
r" value you'd like. As such, you won't ever trigger this lint in your"]
#[doc = r" code directly."]
pub static WARNINGS: &crate::Lint =
    &crate::Lint {
            name: "WARNINGS",
            default_level: crate::Warn,
            desc: "mass-change the level for lints which produce warnings",
            ..
        };declare_lint! {
1136    /// The `warnings` lint allows you to change the level of other
1137    /// lints which produce warnings.
1138    ///
1139    /// ### Example
1140    ///
1141    /// ```rust,compile_fail
1142    /// #![deny(warnings)]
1143    /// struct non_standard_name;
1144    /// ```
1145    ///
1146    /// {{produces}}
1147    ///
1148    /// ### Explanation
1149    ///
1150    /// The `warnings` lint is a bit special; by changing its level, you
1151    /// change every other warning that would produce a warning to whatever
1152    /// value you'd like. As such, you won't ever trigger this lint in your
1153    /// code directly.
1154    pub WARNINGS,
1155    Warn,
1156    "mass-change the level for lints which produce warnings"
1157}
1158
1159#[doc =
r" The `unused_features` lint detects unused or unknown features found in"]
#[doc = r" crate-level [`feature` attributes]."]
#[doc = r""]
#[doc =
r" [`feature` attributes]: https://doc.rust-lang.org/nightly/unstable-book/"]
pub static UNUSED_FEATURES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_FEATURES",
            default_level: crate::Warn,
            desc: "unused features found in crate-level `#[feature]` directives",
            ..
        };declare_lint! {
1160    /// The `unused_features` lint detects unused or unknown features found in
1161    /// crate-level [`feature` attributes].
1162    ///
1163    /// [`feature` attributes]: https://doc.rust-lang.org/nightly/unstable-book/
1164    pub UNUSED_FEATURES,
1165    Warn,
1166    "unused features found in crate-level `#[feature]` directives"
1167}
1168
1169#[doc = r" The `duplicate_features` lint detects duplicate features found in"]
#[doc = r" crate-level [`feature` attributes]."]
#[doc = r""]
#[doc = r" Note: This lint used to be a hard error (E0636)."]
#[doc = r""]
#[doc =
r" [`feature` attributes]: https://doc.rust-lang.org/nightly/unstable-book/"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" # #![allow(internal_features)]"]
#[doc = r" #![feature(rustc_attrs)]"]
#[doc = r" #![feature(rustc_attrs)]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Enabling a feature more than once is a no-op."]
#[doc = r" To avoid this warning, remove the second `feature()` attribute."]
pub static DUPLICATE_FEATURES: &crate::Lint =
    &crate::Lint {
            name: "DUPLICATE_FEATURES",
            default_level: crate::Deny,
            desc: "duplicate features found in crate-level `#[feature]` directives",
            ..
        };declare_lint! {
1170    /// The `duplicate_features` lint detects duplicate features found in
1171    /// crate-level [`feature` attributes].
1172    ///
1173    /// Note: This lint used to be a hard error (E0636).
1174    ///
1175    /// [`feature` attributes]: https://doc.rust-lang.org/nightly/unstable-book/
1176    ///
1177    /// ### Example
1178    ///
1179    /// ```rust,compile_fail
1180    /// # #![allow(internal_features)]
1181    /// #![feature(rustc_attrs)]
1182    /// #![feature(rustc_attrs)]
1183    /// ```
1184    ///
1185    /// {{produces}}
1186    ///
1187    /// ### Explanation
1188    ///
1189    /// Enabling a feature more than once is a no-op.
1190    /// To avoid this warning, remove the second `feature()` attribute.
1191    pub DUPLICATE_FEATURES,
1192    Deny,
1193    "duplicate features found in crate-level `#[feature]` directives"
1194}
1195
1196#[doc = r" The `stable_features` lint detects a [`feature` attribute] that"]
#[doc = r" has since been made stable."]
#[doc = r""]
#[doc =
r" [`feature` attribute]: https://doc.rust-lang.org/nightly/unstable-book/"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![feature(test_accepted_feature)]"]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" When a feature is stabilized, it is no longer necessary to include a"]
#[doc = r" `#![feature]` attribute for it. To fix, simply remove the"]
#[doc = r" `#![feature]` attribute."]
pub static STABLE_FEATURES: &crate::Lint =
    &crate::Lint {
            name: "STABLE_FEATURES",
            default_level: crate::Warn,
            desc: "stable features found in `#[feature]` directive",
            ..
        };declare_lint! {
1197    /// The `stable_features` lint detects a [`feature` attribute] that
1198    /// has since been made stable.
1199    ///
1200    /// [`feature` attribute]: https://doc.rust-lang.org/nightly/unstable-book/
1201    ///
1202    /// ### Example
1203    ///
1204    /// ```rust
1205    /// #![feature(test_accepted_feature)]
1206    /// fn main() {}
1207    /// ```
1208    ///
1209    /// {{produces}}
1210    ///
1211    /// ### Explanation
1212    ///
1213    /// When a feature is stabilized, it is no longer necessary to include a
1214    /// `#![feature]` attribute for it. To fix, simply remove the
1215    /// `#![feature]` attribute.
1216    pub STABLE_FEATURES,
1217    Warn,
1218    "stable features found in `#[feature]` directive"
1219}
1220
1221#[doc =
r" The `unknown_crate_types` lint detects an unknown crate type found in"]
#[doc = r" a [`crate_type` attribute]."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r#" #![crate_type="lol"]"#]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" An unknown value give to the `crate_type` attribute is almost"]
#[doc = r" certainly a mistake."]
#[doc = r""]
#[doc =
r" [`crate_type` attribute]: https://doc.rust-lang.org/reference/linkage.html"]
pub static UNKNOWN_CRATE_TYPES: &crate::Lint =
    &crate::Lint {
            name: "UNKNOWN_CRATE_TYPES",
            default_level: crate::Deny,
            desc: "unknown crate type found in `#[crate_type]` directive",
            crate_level_only: true,
            ..
        };declare_lint! {
1222    /// The `unknown_crate_types` lint detects an unknown crate type found in
1223    /// a [`crate_type` attribute].
1224    ///
1225    /// ### Example
1226    ///
1227    /// ```rust,compile_fail
1228    /// #![crate_type="lol"]
1229    /// fn main() {}
1230    /// ```
1231    ///
1232    /// {{produces}}
1233    ///
1234    /// ### Explanation
1235    ///
1236    /// An unknown value give to the `crate_type` attribute is almost
1237    /// certainly a mistake.
1238    ///
1239    /// [`crate_type` attribute]: https://doc.rust-lang.org/reference/linkage.html
1240    pub UNKNOWN_CRATE_TYPES,
1241    Deny,
1242    "unknown crate type found in `#[crate_type]` directive",
1243    crate_level_only
1244}
1245
1246#[doc =
r" The `trivial_casts` lint detects trivial casts which could be replaced"]
#[doc = r" with coercion, which may require a temporary variable."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(trivial_casts)]"]
#[doc = r" let x: &u32 = &42;"]
#[doc = r" let y = x as *const u32;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" A trivial cast is a cast `e as T` where `e` has type `U` and `U` is a"]
#[doc =
r" subtype of `T`. This type of cast is usually unnecessary, as it can be"]
#[doc = r" usually be inferred."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because there are situations, such as"#]
#[doc = r" with FFI interfaces or complex type aliases, where it triggers"]
#[doc = r" incorrectly, or in situations where it will be more difficult to"]
#[doc =
r" clearly express the intent. It may be possible that this will become a"]
#[doc =
r" warning in the future, possibly with an explicit syntax for coercions"]
#[doc = r" providing a convenient way to work around the current issues."]
#[doc =
r" See [RFC 401 (coercions)][rfc-401], [RFC 803 (type ascription)][rfc-803] and"]
#[doc =
r" [RFC 3307 (remove type ascription)][rfc-3307] for historical context."]
#[doc = r""]
#[doc = r" [rfc-401]: https://rust-lang.github.io/rfcs/0401-coercions.html"]
#[doc =
r" [rfc-803]: https://rust-lang.github.io/rfcs/0803-type-ascription.html"]
#[doc =
r" [rfc-3307]: https://rust-lang.github.io/rfcs/3307-de-rfc-type-ascription.html"]
pub static TRIVIAL_CASTS: &crate::Lint =
    &crate::Lint {
            name: "TRIVIAL_CASTS",
            default_level: crate::Allow,
            desc: "detects trivial casts which could be removed",
            ..
        };declare_lint! {
1247    /// The `trivial_casts` lint detects trivial casts which could be replaced
1248    /// with coercion, which may require a temporary variable.
1249    ///
1250    /// ### Example
1251    ///
1252    /// ```rust,compile_fail
1253    /// #![deny(trivial_casts)]
1254    /// let x: &u32 = &42;
1255    /// let y = x as *const u32;
1256    /// ```
1257    ///
1258    /// {{produces}}
1259    ///
1260    /// ### Explanation
1261    ///
1262    /// A trivial cast is a cast `e as T` where `e` has type `U` and `U` is a
1263    /// subtype of `T`. This type of cast is usually unnecessary, as it can be
1264    /// usually be inferred.
1265    ///
1266    /// This lint is "allow" by default because there are situations, such as
1267    /// with FFI interfaces or complex type aliases, where it triggers
1268    /// incorrectly, or in situations where it will be more difficult to
1269    /// clearly express the intent. It may be possible that this will become a
1270    /// warning in the future, possibly with an explicit syntax for coercions
1271    /// providing a convenient way to work around the current issues.
1272    /// See [RFC 401 (coercions)][rfc-401], [RFC 803 (type ascription)][rfc-803] and
1273    /// [RFC 3307 (remove type ascription)][rfc-3307] for historical context.
1274    ///
1275    /// [rfc-401]: https://rust-lang.github.io/rfcs/0401-coercions.html
1276    /// [rfc-803]: https://rust-lang.github.io/rfcs/0803-type-ascription.html
1277    /// [rfc-3307]: https://rust-lang.github.io/rfcs/3307-de-rfc-type-ascription.html
1278    pub TRIVIAL_CASTS,
1279    Allow,
1280    "detects trivial casts which could be removed"
1281}
1282
1283#[doc =
r" The `trivial_numeric_casts` lint detects trivial numeric casts of types"]
#[doc = r" which could be removed."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(trivial_numeric_casts)]"]
#[doc = r" let x = 42_i32 as i32;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" A trivial numeric cast is a cast of a numeric type to the same numeric"]
#[doc = r" type. This type of cast is usually unnecessary."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because there are situations, such as"#]
#[doc = r" with FFI interfaces or complex type aliases, where it triggers"]
#[doc = r" incorrectly, or in situations where it will be more difficult to"]
#[doc =
r" clearly express the intent. It may be possible that this will become a"]
#[doc =
r" warning in the future, possibly with an explicit syntax for coercions"]
#[doc = r" providing a convenient way to work around the current issues."]
#[doc =
r" See [RFC 401 (coercions)][rfc-401], [RFC 803 (type ascription)][rfc-803] and"]
#[doc =
r" [RFC 3307 (remove type ascription)][rfc-3307] for historical context."]
#[doc = r""]
#[doc = r" [rfc-401]: https://rust-lang.github.io/rfcs/0401-coercions.html"]
#[doc =
r" [rfc-803]: https://rust-lang.github.io/rfcs/0803-type-ascription.html"]
#[doc =
r" [rfc-3307]: https://rust-lang.github.io/rfcs/3307-de-rfc-type-ascription.html"]
pub static TRIVIAL_NUMERIC_CASTS: &crate::Lint =
    &crate::Lint {
            name: "TRIVIAL_NUMERIC_CASTS",
            default_level: crate::Allow,
            desc: "detects trivial casts of numeric types which could be removed",
            ..
        };declare_lint! {
1284    /// The `trivial_numeric_casts` lint detects trivial numeric casts of types
1285    /// which could be removed.
1286    ///
1287    /// ### Example
1288    ///
1289    /// ```rust,compile_fail
1290    /// #![deny(trivial_numeric_casts)]
1291    /// let x = 42_i32 as i32;
1292    /// ```
1293    ///
1294    /// {{produces}}
1295    ///
1296    /// ### Explanation
1297    ///
1298    /// A trivial numeric cast is a cast of a numeric type to the same numeric
1299    /// type. This type of cast is usually unnecessary.
1300    ///
1301    /// This lint is "allow" by default because there are situations, such as
1302    /// with FFI interfaces or complex type aliases, where it triggers
1303    /// incorrectly, or in situations where it will be more difficult to
1304    /// clearly express the intent. It may be possible that this will become a
1305    /// warning in the future, possibly with an explicit syntax for coercions
1306    /// providing a convenient way to work around the current issues.
1307    /// See [RFC 401 (coercions)][rfc-401], [RFC 803 (type ascription)][rfc-803] and
1308    /// [RFC 3307 (remove type ascription)][rfc-3307] for historical context.
1309    ///
1310    /// [rfc-401]: https://rust-lang.github.io/rfcs/0401-coercions.html
1311    /// [rfc-803]: https://rust-lang.github.io/rfcs/0803-type-ascription.html
1312    /// [rfc-3307]: https://rust-lang.github.io/rfcs/3307-de-rfc-type-ascription.html
1313    pub TRIVIAL_NUMERIC_CASTS,
1314    Allow,
1315    "detects trivial casts of numeric types which could be removed"
1316}
1317
1318#[doc =
r" The `exported_private_dependencies` lint detects private dependencies"]
#[doc = r" that are exposed in a public interface."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs-dependency)"]
#[doc = r" pub fn foo() -> Option<some_private_dependency::Thing> {"]
#[doc = r"     None"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" warning: type `bar::Thing` from private dependency 'bar' in public interface"]
#[doc = r"  --> src/lib.rs:3:1"]
#[doc = r"   |"]
#[doc = r" 3 | pub fn foo() -> Option<bar::Thing> {"]
#[doc = r"   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r"   |"]
#[doc = r"   = note: `#[warn(exported_private_dependencies)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r#" Dependencies can be marked as "private" to indicate that they are not"#]
#[doc =
r" exposed in the public interface of a crate. This can be used by Cargo"]
#[doc =
r" to independently resolve those dependencies because it can assume it"]
#[doc = r" does not need to unify them with other packages using that same"]
#[doc = r" dependency. This lint is an indication of a violation of that"]
#[doc = r" contract."]
#[doc = r""]
#[doc =
r" To fix this, avoid exposing the dependency in your public interface."]
#[doc = r" Or, switch the dependency to a public dependency."]
#[doc = r""]
#[doc =
r" Note that support for this is only available on the nightly channel."]
#[doc =
r" See [RFC 1977] for more details, as well as the [Cargo documentation]."]
#[doc = r""]
#[doc =
r" [RFC 1977]: https://rust-lang.github.io/rfcs/1977-public-private-dependencies.html"]
#[doc =
r" [Cargo documentation]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#public-dependency"]
pub static EXPORTED_PRIVATE_DEPENDENCIES: &crate::Lint =
    &crate::Lint {
            name: "EXPORTED_PRIVATE_DEPENDENCIES",
            default_level: crate::Warn,
            desc: "public interface leaks type from a private dependency",
            ..
        };declare_lint! {
1319    /// The `exported_private_dependencies` lint detects private dependencies
1320    /// that are exposed in a public interface.
1321    ///
1322    /// ### Example
1323    ///
1324    /// ```rust,ignore (needs-dependency)
1325    /// pub fn foo() -> Option<some_private_dependency::Thing> {
1326    ///     None
1327    /// }
1328    /// ```
1329    ///
1330    /// This will produce:
1331    ///
1332    /// ```text
1333    /// warning: type `bar::Thing` from private dependency 'bar' in public interface
1334    ///  --> src/lib.rs:3:1
1335    ///   |
1336    /// 3 | pub fn foo() -> Option<bar::Thing> {
1337    ///   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1338    ///   |
1339    ///   = note: `#[warn(exported_private_dependencies)]` on by default
1340    /// ```
1341    ///
1342    /// ### Explanation
1343    ///
1344    /// Dependencies can be marked as "private" to indicate that they are not
1345    /// exposed in the public interface of a crate. This can be used by Cargo
1346    /// to independently resolve those dependencies because it can assume it
1347    /// does not need to unify them with other packages using that same
1348    /// dependency. This lint is an indication of a violation of that
1349    /// contract.
1350    ///
1351    /// To fix this, avoid exposing the dependency in your public interface.
1352    /// Or, switch the dependency to a public dependency.
1353    ///
1354    /// Note that support for this is only available on the nightly channel.
1355    /// See [RFC 1977] for more details, as well as the [Cargo documentation].
1356    ///
1357    /// [RFC 1977]: https://rust-lang.github.io/rfcs/1977-public-private-dependencies.html
1358    /// [Cargo documentation]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#public-dependency
1359    pub EXPORTED_PRIVATE_DEPENDENCIES,
1360    Warn,
1361    "public interface leaks type from a private dependency"
1362}
1363
1364#[doc = r" The `pub_use_of_private_extern_crate` lint detects a specific"]
#[doc = r" situation of re-exporting a private `extern crate`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" extern crate core;"]
#[doc = r" pub use core as reexported_core;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" A public `use` declaration should not be used to publically re-export a"]
#[doc =
r" private `extern crate`. `pub extern crate` should be used instead."]
#[doc = r""]
#[doc = r" This was historically allowed, but is not the intended behavior"]
#[doc =
r" according to the visibility rules. This is a [future-incompatible]"]
#[doc = r" lint to transition this to a hard error in the future. See [issue"]
#[doc = r" #127909] for more details."]
#[doc = r""]
#[doc = r" [issue #127909]: https://github.com/rust-lang/rust/issues/127909"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static PUB_USE_OF_PRIVATE_EXTERN_CRATE: &crate::Lint =
    &crate::Lint {
            name: "PUB_USE_OF_PRIVATE_EXTERN_CRATE",
            default_level: crate::Deny,
            desc: "detect public re-exports of private extern crates",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 127909,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
1365    /// The `pub_use_of_private_extern_crate` lint detects a specific
1366    /// situation of re-exporting a private `extern crate`.
1367    ///
1368    /// ### Example
1369    ///
1370    /// ```rust,compile_fail
1371    /// extern crate core;
1372    /// pub use core as reexported_core;
1373    /// ```
1374    ///
1375    /// {{produces}}
1376    ///
1377    /// ### Explanation
1378    ///
1379    /// A public `use` declaration should not be used to publically re-export a
1380    /// private `extern crate`. `pub extern crate` should be used instead.
1381    ///
1382    /// This was historically allowed, but is not the intended behavior
1383    /// according to the visibility rules. This is a [future-incompatible]
1384    /// lint to transition this to a hard error in the future. See [issue
1385    /// #127909] for more details.
1386    ///
1387    /// [issue #127909]: https://github.com/rust-lang/rust/issues/127909
1388    /// [future-incompatible]: ../index.md#future-incompatible-lints
1389    pub PUB_USE_OF_PRIVATE_EXTERN_CRATE,
1390    Deny,
1391    "detect public re-exports of private extern crates",
1392    @future_incompatible = FutureIncompatibleInfo {
1393        reason: fcw!(FutureReleaseError #127909),
1394        report_in_deps: true,
1395    };
1396}
1397
1398#[doc =
r" The `invalid_type_param_default` lint detects type parameter defaults"]
#[doc = r" erroneously allowed in an invalid location."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" fn foo<T=i32>(t: T) {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Default type parameters were only intended to be allowed in certain"]
#[doc =
r" situations, but historically the compiler allowed them everywhere."]
#[doc = r" This is a [future-incompatible] lint to transition this to a hard"]
#[doc = r" error in the future. See [issue #36887] for more details."]
#[doc = r""]
#[doc = r" [issue #36887]: https://github.com/rust-lang/rust/issues/36887"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static INVALID_TYPE_PARAM_DEFAULT: &crate::Lint =
    &crate::Lint {
            name: "INVALID_TYPE_PARAM_DEFAULT",
            default_level: crate::Deny,
            desc: "type parameter default erroneously allowed in invalid location",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 36887,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
1399    /// The `invalid_type_param_default` lint detects type parameter defaults
1400    /// erroneously allowed in an invalid location.
1401    ///
1402    /// ### Example
1403    ///
1404    /// ```rust,compile_fail
1405    /// fn foo<T=i32>(t: T) {}
1406    /// ```
1407    ///
1408    /// {{produces}}
1409    ///
1410    /// ### Explanation
1411    ///
1412    /// Default type parameters were only intended to be allowed in certain
1413    /// situations, but historically the compiler allowed them everywhere.
1414    /// This is a [future-incompatible] lint to transition this to a hard
1415    /// error in the future. See [issue #36887] for more details.
1416    ///
1417    /// [issue #36887]: https://github.com/rust-lang/rust/issues/36887
1418    /// [future-incompatible]: ../index.md#future-incompatible-lints
1419    pub INVALID_TYPE_PARAM_DEFAULT,
1420    Deny,
1421    "type parameter default erroneously allowed in invalid location",
1422    @future_incompatible = FutureIncompatibleInfo {
1423        reason: fcw!(FutureReleaseError #36887),
1424        report_in_deps: true,
1425    };
1426}
1427
1428#[doc = r" The `renamed_and_removed_lints` lint detects lints that have been"]
#[doc = r" renamed or removed."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![deny(raw_pointer_derive)]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" To fix this, either remove the lint or use the new name. This can help"]
#[doc = r" avoid confusion about lints that are no longer valid, and help"]
#[doc = r" maintain consistency for renamed lints."]
pub static RENAMED_AND_REMOVED_LINTS: &crate::Lint =
    &crate::Lint {
            name: "RENAMED_AND_REMOVED_LINTS",
            default_level: crate::Warn,
            desc: "lints that have been renamed or removed",
            ..
        };declare_lint! {
1429    /// The `renamed_and_removed_lints` lint detects lints that have been
1430    /// renamed or removed.
1431    ///
1432    /// ### Example
1433    ///
1434    /// ```rust
1435    /// #![deny(raw_pointer_derive)]
1436    /// ```
1437    ///
1438    /// {{produces}}
1439    ///
1440    /// ### Explanation
1441    ///
1442    /// To fix this, either remove the lint or use the new name. This can help
1443    /// avoid confusion about lints that are no longer valid, and help
1444    /// maintain consistency for renamed lints.
1445    pub RENAMED_AND_REMOVED_LINTS,
1446    Warn,
1447    "lints that have been renamed or removed"
1448}
1449
1450#[doc =
r" The `const_item_mutation` lint detects attempts to mutate a `const`"]
#[doc = r" item."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" const FOO: [i32; 1] = [0];"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     FOO[0] = 1;"]
#[doc = r#"     // This will print "[0]"."#]
#[doc = r#"     println!("{:?}", FOO);"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Trying to directly mutate a `const` item is almost always a mistake."]
#[doc =
r" What is happening in the example above is that a temporary copy of the"]
#[doc =
r" `const` is mutated, but the original `const` is not. Each time you"]
#[doc =
r" refer to the `const` by name (such as `FOO` in the example above), a"]
#[doc = r" separate copy of the value is inlined at that location."]
#[doc = r""]
#[doc = r" This lint checks for writing directly to a field (`FOO.field ="]
#[doc = r" some_value`) or array entry (`FOO[0] = val`), or taking a mutable"]
#[doc = r" reference to the const item (`&mut FOO`), including through an"]
#[doc = r" autoderef (`FOO.some_mut_self_method()`)."]
#[doc = r""]
#[doc =
r" There are various alternatives depending on what you are trying to"]
#[doc = r" accomplish:"]
#[doc = r""]
#[doc = r" * First, always reconsider using mutable globals, as they can be"]
#[doc =
r"   difficult to use correctly, and can make the code more difficult to"]
#[doc = r"   use or understand."]
#[doc =
r" * If you are trying to perform a one-time initialization of a global:"]
#[doc =
r"     * If the value can be computed at compile-time, consider using"]
#[doc = r"       const-compatible values (see [Constant Evaluation])."]
#[doc =
r"     * For more complex single-initialization cases, consider using"]
#[doc = r"       [`std::sync::LazyLock`]."]
#[doc =
r" * If you truly need a mutable global, consider using a [`static`],"]
#[doc = r"   which has a variety of options:"]
#[doc = r"   * Simple data types can be directly defined and mutated with an"]
#[doc = r"     [`atomic`] type."]
#[doc =
r"   * More complex types can be placed in a synchronization primitive"]
#[doc =
r"     like a [`Mutex`], which can be initialized with one of the options"]
#[doc = r"     listed above."]
#[doc =
r"   * A [mutable `static`] is a low-level primitive, requiring unsafe."]
#[doc = r"     Typically This should be avoided in preference of something"]
#[doc = r"     higher-level like one of the above."]
#[doc = r""]
#[doc =
r" [Constant Evaluation]: https://doc.rust-lang.org/reference/const_eval.html"]
#[doc =
r" [`static`]: https://doc.rust-lang.org/reference/items/static-items.html"]
#[doc =
r" [mutable `static`]: https://doc.rust-lang.org/reference/items/static-items.html#mutable-statics"]
#[doc =
r" [`std::sync::LazyLock`]: https://doc.rust-lang.org/stable/std/sync/struct.LazyLock.html"]
#[doc = r" [`atomic`]: https://doc.rust-lang.org/std/sync/atomic/index.html"]
#[doc = r" [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html"]
pub static CONST_ITEM_MUTATION: &crate::Lint =
    &crate::Lint {
            name: "CONST_ITEM_MUTATION",
            default_level: crate::Warn,
            desc: "detects attempts to mutate a `const` item",
            ..
        };declare_lint! {
1451    /// The `const_item_mutation` lint detects attempts to mutate a `const`
1452    /// item.
1453    ///
1454    /// ### Example
1455    ///
1456    /// ```rust
1457    /// const FOO: [i32; 1] = [0];
1458    ///
1459    /// fn main() {
1460    ///     FOO[0] = 1;
1461    ///     // This will print "[0]".
1462    ///     println!("{:?}", FOO);
1463    /// }
1464    /// ```
1465    ///
1466    /// {{produces}}
1467    ///
1468    /// ### Explanation
1469    ///
1470    /// Trying to directly mutate a `const` item is almost always a mistake.
1471    /// What is happening in the example above is that a temporary copy of the
1472    /// `const` is mutated, but the original `const` is not. Each time you
1473    /// refer to the `const` by name (such as `FOO` in the example above), a
1474    /// separate copy of the value is inlined at that location.
1475    ///
1476    /// This lint checks for writing directly to a field (`FOO.field =
1477    /// some_value`) or array entry (`FOO[0] = val`), or taking a mutable
1478    /// reference to the const item (`&mut FOO`), including through an
1479    /// autoderef (`FOO.some_mut_self_method()`).
1480    ///
1481    /// There are various alternatives depending on what you are trying to
1482    /// accomplish:
1483    ///
1484    /// * First, always reconsider using mutable globals, as they can be
1485    ///   difficult to use correctly, and can make the code more difficult to
1486    ///   use or understand.
1487    /// * If you are trying to perform a one-time initialization of a global:
1488    ///     * If the value can be computed at compile-time, consider using
1489    ///       const-compatible values (see [Constant Evaluation]).
1490    ///     * For more complex single-initialization cases, consider using
1491    ///       [`std::sync::LazyLock`].
1492    /// * If you truly need a mutable global, consider using a [`static`],
1493    ///   which has a variety of options:
1494    ///   * Simple data types can be directly defined and mutated with an
1495    ///     [`atomic`] type.
1496    ///   * More complex types can be placed in a synchronization primitive
1497    ///     like a [`Mutex`], which can be initialized with one of the options
1498    ///     listed above.
1499    ///   * A [mutable `static`] is a low-level primitive, requiring unsafe.
1500    ///     Typically This should be avoided in preference of something
1501    ///     higher-level like one of the above.
1502    ///
1503    /// [Constant Evaluation]: https://doc.rust-lang.org/reference/const_eval.html
1504    /// [`static`]: https://doc.rust-lang.org/reference/items/static-items.html
1505    /// [mutable `static`]: https://doc.rust-lang.org/reference/items/static-items.html#mutable-statics
1506    /// [`std::sync::LazyLock`]: https://doc.rust-lang.org/stable/std/sync/struct.LazyLock.html
1507    /// [`atomic`]: https://doc.rust-lang.org/std/sync/atomic/index.html
1508    /// [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html
1509    pub CONST_ITEM_MUTATION,
1510    Warn,
1511    "detects attempts to mutate a `const` item",
1512}
1513
1514#[doc = r" The `patterns_in_fns_without_body` lint detects `mut` identifier"]
#[doc = r" patterns as a parameter in functions without a body."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" trait Trait {"]
#[doc = r"     fn foo(mut arg: u8);"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" To fix this, remove `mut` from the parameter in the trait definition;"]
#[doc =
r" it can be used in the implementation. That is, the following is OK:"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" trait Trait {"]
#[doc = r"     fn foo(arg: u8); // Removed `mut` here"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl Trait for i32 {"]
#[doc = r"     fn foo(mut arg: u8) { // `mut` here is OK"]
#[doc = r""]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" Trait definitions can define functions without a body to specify a"]
#[doc =
r" function that implementors must define. The parameter names in the"]
#[doc =
r" body-less functions are only allowed to be `_` or an [identifier] for"]
#[doc =
r" documentation purposes (only the type is relevant). Previous versions"]
#[doc =
r" of the compiler erroneously allowed [identifier patterns] with the"]
#[doc = r" `mut` keyword, but this was not intended to be allowed. This is a"]
#[doc =
r" [future-incompatible] lint to transition this to a hard error in the"]
#[doc = r" future. See [issue #35203] for more details."]
#[doc = r""]
#[doc =
r" [identifier]: https://doc.rust-lang.org/reference/identifiers.html"]
#[doc =
r" [identifier patterns]: https://doc.rust-lang.org/reference/patterns.html#identifier-patterns"]
#[doc = r" [issue #35203]: https://github.com/rust-lang/rust/issues/35203"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static PATTERNS_IN_FNS_WITHOUT_BODY: &crate::Lint =
    &crate::Lint {
            name: "PATTERNS_IN_FNS_WITHOUT_BODY",
            default_level: crate::Deny,
            desc: "patterns in functions without body were erroneously allowed",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 35203,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
1515    /// The `patterns_in_fns_without_body` lint detects `mut` identifier
1516    /// patterns as a parameter in functions without a body.
1517    ///
1518    /// ### Example
1519    ///
1520    /// ```rust,compile_fail
1521    /// trait Trait {
1522    ///     fn foo(mut arg: u8);
1523    /// }
1524    /// ```
1525    ///
1526    /// {{produces}}
1527    ///
1528    /// ### Explanation
1529    ///
1530    /// To fix this, remove `mut` from the parameter in the trait definition;
1531    /// it can be used in the implementation. That is, the following is OK:
1532    ///
1533    /// ```rust
1534    /// trait Trait {
1535    ///     fn foo(arg: u8); // Removed `mut` here
1536    /// }
1537    ///
1538    /// impl Trait for i32 {
1539    ///     fn foo(mut arg: u8) { // `mut` here is OK
1540    ///
1541    ///     }
1542    /// }
1543    /// ```
1544    ///
1545    /// Trait definitions can define functions without a body to specify a
1546    /// function that implementors must define. The parameter names in the
1547    /// body-less functions are only allowed to be `_` or an [identifier] for
1548    /// documentation purposes (only the type is relevant). Previous versions
1549    /// of the compiler erroneously allowed [identifier patterns] with the
1550    /// `mut` keyword, but this was not intended to be allowed. This is a
1551    /// [future-incompatible] lint to transition this to a hard error in the
1552    /// future. See [issue #35203] for more details.
1553    ///
1554    /// [identifier]: https://doc.rust-lang.org/reference/identifiers.html
1555    /// [identifier patterns]: https://doc.rust-lang.org/reference/patterns.html#identifier-patterns
1556    /// [issue #35203]: https://github.com/rust-lang/rust/issues/35203
1557    /// [future-incompatible]: ../index.md#future-incompatible-lints
1558    pub PATTERNS_IN_FNS_WITHOUT_BODY,
1559    Deny,
1560    "patterns in functions without body were erroneously allowed",
1561    @future_incompatible = FutureIncompatibleInfo {
1562        reason: fcw!(FutureReleaseError #35203),
1563    };
1564}
1565
1566#[doc = r" The `late_bound_lifetime_arguments` lint detects generic lifetime"]
#[doc = r" arguments in path segments with late bound lifetime parameters."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" struct S;"]
#[doc = r""]
#[doc = r" impl S {"]
#[doc = r"     fn late(self, _: &u8, _: &u8) {}"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     S.late::<'static>(&0, &0);"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" It is not clear how to provide arguments for early-bound lifetime"]
#[doc =
r" parameters if they are intermixed with late-bound parameters in the"]
#[doc =
r" same list. For now, providing any explicit arguments will trigger this"]
#[doc =
r" lint if late-bound parameters are present, so in the future a solution"]
#[doc =
r" can be adopted without hitting backward compatibility issues. This is"]
#[doc =
r" a [future-incompatible] lint to transition this to a hard error in the"]
#[doc =
r" future. See [issue #42868] for more details, along with a description"]
#[doc = r" of the difference between early and late-bound parameters."]
#[doc = r""]
#[doc = r" [issue #42868]: https://github.com/rust-lang/rust/issues/42868"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static LATE_BOUND_LIFETIME_ARGUMENTS: &crate::Lint =
    &crate::Lint {
            name: "LATE_BOUND_LIFETIME_ARGUMENTS",
            default_level: crate::Warn,
            desc: "detects generic lifetime arguments in path segments with late bound lifetime parameters",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 42868,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
1567    /// The `late_bound_lifetime_arguments` lint detects generic lifetime
1568    /// arguments in path segments with late bound lifetime parameters.
1569    ///
1570    /// ### Example
1571    ///
1572    /// ```rust
1573    /// struct S;
1574    ///
1575    /// impl S {
1576    ///     fn late(self, _: &u8, _: &u8) {}
1577    /// }
1578    ///
1579    /// fn main() {
1580    ///     S.late::<'static>(&0, &0);
1581    /// }
1582    /// ```
1583    ///
1584    /// {{produces}}
1585    ///
1586    /// ### Explanation
1587    ///
1588    /// It is not clear how to provide arguments for early-bound lifetime
1589    /// parameters if they are intermixed with late-bound parameters in the
1590    /// same list. For now, providing any explicit arguments will trigger this
1591    /// lint if late-bound parameters are present, so in the future a solution
1592    /// can be adopted without hitting backward compatibility issues. This is
1593    /// a [future-incompatible] lint to transition this to a hard error in the
1594    /// future. See [issue #42868] for more details, along with a description
1595    /// of the difference between early and late-bound parameters.
1596    ///
1597    /// [issue #42868]: https://github.com/rust-lang/rust/issues/42868
1598    /// [future-incompatible]: ../index.md#future-incompatible-lints
1599    pub LATE_BOUND_LIFETIME_ARGUMENTS,
1600    Warn,
1601    "detects generic lifetime arguments in path segments with late bound lifetime parameters",
1602    @future_incompatible = FutureIncompatibleInfo {
1603        reason: fcw!(FutureReleaseError #42868),
1604    };
1605}
1606
1607#[doc =
r" The `coherence_leak_check` lint detects conflicting implementations of"]
#[doc = r" a trait that are only distinguished by the old leak-check code."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" trait SomeTrait { }"]
#[doc = r" impl SomeTrait for for<'a> fn(&'a u8) { }"]
#[doc = r" impl<'a> SomeTrait for fn(&'a u8) { }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" In the past, the compiler would accept trait implementations for"]
#[doc =
r" identical functions that differed only in where the lifetime binder"]
#[doc =
r" appeared. Due to a change in the borrow checker implementation to fix"]
#[doc =
r" several bugs, this is no longer allowed. However, since this affects"]
#[doc =
r" existing code, this is a [future-incompatible] lint to transition this"]
#[doc = r" to a hard error in the future."]
#[doc = r""]
#[doc = r#" Code relying on this pattern should introduce "[newtypes]","#]
#[doc = r" like `struct Foo(for<'a> fn(&'a u8))`."]
#[doc = r""]
#[doc = r" See [issue #56105] for more details."]
#[doc = r""]
#[doc = r" [issue #56105]: https://github.com/rust-lang/rust/issues/56105"]
#[doc =
r" [newtypes]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#using-the-newtype-pattern-for-type-safety-and-abstraction"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static COHERENCE_LEAK_CHECK: &crate::Lint =
    &crate::Lint {
            name: "COHERENCE_LEAK_CHECK",
            default_level: crate::Warn,
            desc: "distinct impls distinguished only by the leak-check code",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::Custom("the behavior may change in a future release",
                        crate::ReleaseFcw { issue_number: 56105 }),
                    ..
                }),
            ..
        };declare_lint! {
1608    /// The `coherence_leak_check` lint detects conflicting implementations of
1609    /// a trait that are only distinguished by the old leak-check code.
1610    ///
1611    /// ### Example
1612    ///
1613    /// ```rust
1614    /// trait SomeTrait { }
1615    /// impl SomeTrait for for<'a> fn(&'a u8) { }
1616    /// impl<'a> SomeTrait for fn(&'a u8) { }
1617    /// ```
1618    ///
1619    /// {{produces}}
1620    ///
1621    /// ### Explanation
1622    ///
1623    /// In the past, the compiler would accept trait implementations for
1624    /// identical functions that differed only in where the lifetime binder
1625    /// appeared. Due to a change in the borrow checker implementation to fix
1626    /// several bugs, this is no longer allowed. However, since this affects
1627    /// existing code, this is a [future-incompatible] lint to transition this
1628    /// to a hard error in the future.
1629    ///
1630    /// Code relying on this pattern should introduce "[newtypes]",
1631    /// like `struct Foo(for<'a> fn(&'a u8))`.
1632    ///
1633    /// See [issue #56105] for more details.
1634    ///
1635    /// [issue #56105]: https://github.com/rust-lang/rust/issues/56105
1636    /// [newtypes]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#using-the-newtype-pattern-for-type-safety-and-abstraction
1637    /// [future-incompatible]: ../index.md#future-incompatible-lints
1638    pub COHERENCE_LEAK_CHECK,
1639    Warn,
1640    "distinct impls distinguished only by the leak-check code",
1641    @future_incompatible = FutureIncompatibleInfo {
1642        reason: fcw!("the behavior may change in a future release" #56105),
1643    };
1644}
1645
1646#[doc = r" The `deprecated` lint detects use of deprecated items."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #[deprecated]"]
#[doc = r" fn foo() {}"]
#[doc = r""]
#[doc = r" fn bar() {"]
#[doc = r"     foo();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r#" Items may be marked "deprecated" with the [`deprecated` attribute] to"#]
#[doc =
r" indicate that they should no longer be used. Usually the attribute"]
#[doc = r" should include a note on what to use instead, or check the"]
#[doc = r" documentation."]
#[doc = r""]
#[doc =
r" [`deprecated` attribute]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-deprecated-attribute"]
pub static DEPRECATED: &crate::Lint =
    &crate::Lint {
            name: "DEPRECATED",
            default_level: crate::Warn,
            desc: "detects use of deprecated items",
            report_in_external_macro: true,
            ..
        };declare_lint! {
1647    /// The `deprecated` lint detects use of deprecated items.
1648    ///
1649    /// ### Example
1650    ///
1651    /// ```rust
1652    /// #[deprecated]
1653    /// fn foo() {}
1654    ///
1655    /// fn bar() {
1656    ///     foo();
1657    /// }
1658    /// ```
1659    ///
1660    /// {{produces}}
1661    ///
1662    /// ### Explanation
1663    ///
1664    /// Items may be marked "deprecated" with the [`deprecated` attribute] to
1665    /// indicate that they should no longer be used. Usually the attribute
1666    /// should include a note on what to use instead, or check the
1667    /// documentation.
1668    ///
1669    /// [`deprecated` attribute]: https://doc.rust-lang.org/reference/attributes/diagnostics.html#the-deprecated-attribute
1670    pub DEPRECATED,
1671    Warn,
1672    "detects use of deprecated items",
1673    report_in_external_macro
1674}
1675
1676#[doc =
r" The `unused_unsafe` lint detects unnecessary use of an `unsafe` block."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" unsafe {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" If nothing within the block requires `unsafe`, then remove the"]
#[doc =
r" `unsafe` marker because it is not required and may cause confusion."]
pub static UNUSED_UNSAFE: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_UNSAFE",
            default_level: crate::Warn,
            desc: "unnecessary use of an `unsafe` block",
            ..
        };declare_lint! {
1677    /// The `unused_unsafe` lint detects unnecessary use of an `unsafe` block.
1678    ///
1679    /// ### Example
1680    ///
1681    /// ```rust
1682    /// unsafe {}
1683    /// ```
1684    ///
1685    /// {{produces}}
1686    ///
1687    /// ### Explanation
1688    ///
1689    /// If nothing within the block requires `unsafe`, then remove the
1690    /// `unsafe` marker because it is not required and may cause confusion.
1691    pub UNUSED_UNSAFE,
1692    Warn,
1693    "unnecessary use of an `unsafe` block"
1694}
1695
1696#[doc =
r" The `unused_mut` lint detects mut variables which don't need to be"]
#[doc = r" mutable."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" let mut x = 5;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" The preferred style is to only mark variables as `mut` if it is"]
#[doc = r" required."]
pub static UNUSED_MUT: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_MUT",
            default_level: crate::Warn,
            desc: "detect mut variables which don't need to be mutable",
            ..
        };declare_lint! {
1697    /// The `unused_mut` lint detects mut variables which don't need to be
1698    /// mutable.
1699    ///
1700    /// ### Example
1701    ///
1702    /// ```rust
1703    /// let mut x = 5;
1704    /// ```
1705    ///
1706    /// {{produces}}
1707    ///
1708    /// ### Explanation
1709    ///
1710    /// The preferred style is to only mark variables as `mut` if it is
1711    /// required.
1712    pub UNUSED_MUT,
1713    Warn,
1714    "detect mut variables which don't need to be mutable"
1715}
1716
1717#[doc = r" The `rust_2024_incompatible_pat` lint"]
#[doc =
r" detects patterns whose meaning will change in the Rust 2024 edition."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2021"]
#[doc = r" #![warn(rust_2024_incompatible_pat)]"]
#[doc = r""]
#[doc = r" if let Some(&a) = &Some(&0u8) {"]
#[doc = r"     let _: u8 = a;"]
#[doc = r" }"]
#[doc = r" if let Some(mut _a) = &mut Some(0u8) {"]
#[doc = r"     _a = 7u8;"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In Rust 2024 and above, the `mut` keyword does not reset the pattern binding mode,"]
#[doc =
r" and nor do `&` or `&mut` patterns. The lint will suggest code that"]
#[doc = r" has the same meaning in all editions."]
pub static RUST_2024_INCOMPATIBLE_PAT: &crate::Lint =
    &crate::Lint {
            name: "RUST_2024_INCOMPATIBLE_PAT",
            default_level: crate::Allow,
            desc: "detects patterns whose meaning will change in Rust 2024",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionSemanticsChange(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "match-ergonomics",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
1718    /// The `rust_2024_incompatible_pat` lint
1719    /// detects patterns whose meaning will change in the Rust 2024 edition.
1720    ///
1721    /// ### Example
1722    ///
1723    /// ```rust,edition2021
1724    /// #![warn(rust_2024_incompatible_pat)]
1725    ///
1726    /// if let Some(&a) = &Some(&0u8) {
1727    ///     let _: u8 = a;
1728    /// }
1729    /// if let Some(mut _a) = &mut Some(0u8) {
1730    ///     _a = 7u8;
1731    /// }
1732    /// ```
1733    ///
1734    /// {{produces}}
1735    ///
1736    /// ### Explanation
1737    ///
1738    /// In Rust 2024 and above, the `mut` keyword does not reset the pattern binding mode,
1739    /// and nor do `&` or `&mut` patterns. The lint will suggest code that
1740    /// has the same meaning in all editions.
1741    pub RUST_2024_INCOMPATIBLE_PAT,
1742    Allow,
1743    "detects patterns whose meaning will change in Rust 2024",
1744    @future_incompatible = FutureIncompatibleInfo {
1745        reason: fcw!(EditionSemanticsChange 2024 "match-ergonomics"),
1746    };
1747}
1748
1749#[doc = r" The `unconditional_recursion` lint detects functions that cannot"]
#[doc = r" return without calling themselves."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" fn foo() {"]
#[doc = r"     foo();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is usually a mistake to have a recursive call that does not have"]
#[doc =
r" some condition to cause it to terminate. If you really intend to have"]
#[doc = r" an infinite loop, using a `loop` expression is recommended."]
pub static UNCONDITIONAL_RECURSION: &crate::Lint =
    &crate::Lint {
            name: "UNCONDITIONAL_RECURSION",
            default_level: crate::Warn,
            desc: "functions that cannot return without calling themselves",
            ..
        };declare_lint! {
1750    /// The `unconditional_recursion` lint detects functions that cannot
1751    /// return without calling themselves.
1752    ///
1753    /// ### Example
1754    ///
1755    /// ```rust
1756    /// fn foo() {
1757    ///     foo();
1758    /// }
1759    /// ```
1760    ///
1761    /// {{produces}}
1762    ///
1763    /// ### Explanation
1764    ///
1765    /// It is usually a mistake to have a recursive call that does not have
1766    /// some condition to cause it to terminate. If you really intend to have
1767    /// an infinite loop, using a `loop` expression is recommended.
1768    pub UNCONDITIONAL_RECURSION,
1769    Warn,
1770    "functions that cannot return without calling themselves"
1771}
1772
1773#[doc =
r" The `single_use_lifetimes` lint detects lifetimes that are only used"]
#[doc = r" once."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(single_use_lifetimes)]"]
#[doc = r""]
#[doc = r" fn foo<'a>(x: &'a u32) {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Specifying an explicit lifetime like `'a` in a function or `impl`"]
#[doc =
r" should only be used to link together two things. Otherwise, you should"]
#[doc =
r" just use `'_` to indicate that the lifetime is not linked to anything,"]
#[doc = r" or elide the lifetime altogether if possible."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because it was introduced at a time"#]
#[doc =
r" when `'_` and elided lifetimes were first being introduced, and this"]
#[doc =
r" lint would be too noisy. Also, there are some known false positives"]
#[doc =
r" that it produces. See [RFC 2115] for historical context, and [issue"]
#[doc = r" #44752] for more details."]
#[doc = r""]
#[doc =
r" [RFC 2115]: https://rust-lang.github.io/rfcs/2115-argument-lifetimes.html"]
#[doc = r" [issue #44752]: https://github.com/rust-lang/rust/issues/44752"]
pub static SINGLE_USE_LIFETIMES: &crate::Lint =
    &crate::Lint {
            name: "SINGLE_USE_LIFETIMES",
            default_level: crate::Allow,
            desc: "detects lifetime parameters that are only used once",
            ..
        };declare_lint! {
1774    /// The `single_use_lifetimes` lint detects lifetimes that are only used
1775    /// once.
1776    ///
1777    /// ### Example
1778    ///
1779    /// ```rust,compile_fail
1780    /// #![deny(single_use_lifetimes)]
1781    ///
1782    /// fn foo<'a>(x: &'a u32) {}
1783    /// ```
1784    ///
1785    /// {{produces}}
1786    ///
1787    /// ### Explanation
1788    ///
1789    /// Specifying an explicit lifetime like `'a` in a function or `impl`
1790    /// should only be used to link together two things. Otherwise, you should
1791    /// just use `'_` to indicate that the lifetime is not linked to anything,
1792    /// or elide the lifetime altogether if possible.
1793    ///
1794    /// This lint is "allow" by default because it was introduced at a time
1795    /// when `'_` and elided lifetimes were first being introduced, and this
1796    /// lint would be too noisy. Also, there are some known false positives
1797    /// that it produces. See [RFC 2115] for historical context, and [issue
1798    /// #44752] for more details.
1799    ///
1800    /// [RFC 2115]: https://rust-lang.github.io/rfcs/2115-argument-lifetimes.html
1801    /// [issue #44752]: https://github.com/rust-lang/rust/issues/44752
1802    pub SINGLE_USE_LIFETIMES,
1803    Allow,
1804    "detects lifetime parameters that are only used once"
1805}
1806
1807#[doc =
r" The `unused_lifetimes` lint detects lifetime parameters that are never"]
#[doc = r" used."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #[deny(unused_lifetimes)]"]
#[doc = r""]
#[doc = r" pub fn foo<'a>() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused lifetime parameters may signal a mistake or unfinished code."]
#[doc = r" Consider removing the parameter."]
pub static UNUSED_LIFETIMES: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_LIFETIMES",
            default_level: crate::Allow,
            desc: "detects lifetime parameters that are never used",
            ..
        };declare_lint! {
1808    /// The `unused_lifetimes` lint detects lifetime parameters that are never
1809    /// used.
1810    ///
1811    /// ### Example
1812    ///
1813    /// ```rust,compile_fail
1814    /// #[deny(unused_lifetimes)]
1815    ///
1816    /// pub fn foo<'a>() {}
1817    /// ```
1818    ///
1819    /// {{produces}}
1820    ///
1821    /// ### Explanation
1822    ///
1823    /// Unused lifetime parameters may signal a mistake or unfinished code.
1824    /// Consider removing the parameter.
1825    pub UNUSED_LIFETIMES,
1826    Allow,
1827    "detects lifetime parameters that are never used"
1828}
1829
1830#[doc =
r" The `redundant_lifetimes` lint detects lifetime parameters that are"]
#[doc = r" redundant because they are equal to another named lifetime."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #[deny(redundant_lifetimes)]"]
#[doc = r""]
#[doc =
r" // `'a = 'static`, so all usages of `'a` can be replaced with `'static`"]
#[doc = r" pub fn bar<'a: 'static>() {}"]
#[doc = r""]
#[doc = r" // `'a = 'b`, so all usages of `'b` can be replaced with `'a`"]
#[doc = r" pub fn bar<'a: 'b, 'b: 'a>() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused lifetime parameters may signal a mistake or unfinished code."]
#[doc = r" Consider removing the parameter."]
pub static REDUNDANT_LIFETIMES: &crate::Lint =
    &crate::Lint {
            name: "REDUNDANT_LIFETIMES",
            default_level: crate::Allow,
            desc: "detects lifetime parameters that are redundant because they are equal to some other named lifetime",
            ..
        };declare_lint! {
1831    /// The `redundant_lifetimes` lint detects lifetime parameters that are
1832    /// redundant because they are equal to another named lifetime.
1833    ///
1834    /// ### Example
1835    ///
1836    /// ```rust,compile_fail
1837    /// #[deny(redundant_lifetimes)]
1838    ///
1839    /// // `'a = 'static`, so all usages of `'a` can be replaced with `'static`
1840    /// pub fn bar<'a: 'static>() {}
1841    ///
1842    /// // `'a = 'b`, so all usages of `'b` can be replaced with `'a`
1843    /// pub fn bar<'a: 'b, 'b: 'a>() {}
1844    /// ```
1845    ///
1846    /// {{produces}}
1847    ///
1848    /// ### Explanation
1849    ///
1850    /// Unused lifetime parameters may signal a mistake or unfinished code.
1851    /// Consider removing the parameter.
1852    pub REDUNDANT_LIFETIMES,
1853    Allow,
1854    "detects lifetime parameters that are redundant because they are equal to some other named lifetime"
1855}
1856
1857#[doc = r" The `tyvar_behind_raw_pointer` lint detects raw pointer to an"]
#[doc = r" inference variable."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2015"]
#[doc = r" // edition 2015"]
#[doc = r" let data = std::ptr::null();"]
#[doc = r" let _ = &data as *const *const ();"]
#[doc = r""]
#[doc = r" if data.is_null() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This kind of inference was previously allowed, but with the future"]
#[doc =
r" arrival of [arbitrary self types], this can introduce ambiguity. To"]
#[doc = r" resolve this, use an explicit type instead of relying on type"]
#[doc = r" inference."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a hard"]
#[doc =
r" error in the 2018 edition. See [issue #46906] for more details. This"]
#[doc = r#" is currently a hard-error on the 2018 edition, and is "warn" by"#]
#[doc = r" default in the 2015 edition."]
#[doc = r""]
#[doc =
r" [arbitrary self types]: https://github.com/rust-lang/rust/issues/44874"]
#[doc = r" [issue #46906]: https://github.com/rust-lang/rust/issues/46906"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static TYVAR_BEHIND_RAW_POINTER: &crate::Lint =
    &crate::Lint {
            name: "TYVAR_BEHIND_RAW_POINTER",
            default_level: crate::Warn,
            desc: "raw pointer to an inference variable",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2018,
                            page_slug: "tyvar-behind-raw-pointer",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
1858    /// The `tyvar_behind_raw_pointer` lint detects raw pointer to an
1859    /// inference variable.
1860    ///
1861    /// ### Example
1862    ///
1863    /// ```rust,edition2015
1864    /// // edition 2015
1865    /// let data = std::ptr::null();
1866    /// let _ = &data as *const *const ();
1867    ///
1868    /// if data.is_null() {}
1869    /// ```
1870    ///
1871    /// {{produces}}
1872    ///
1873    /// ### Explanation
1874    ///
1875    /// This kind of inference was previously allowed, but with the future
1876    /// arrival of [arbitrary self types], this can introduce ambiguity. To
1877    /// resolve this, use an explicit type instead of relying on type
1878    /// inference.
1879    ///
1880    /// This is a [future-incompatible] lint to transition this to a hard
1881    /// error in the 2018 edition. See [issue #46906] for more details. This
1882    /// is currently a hard-error on the 2018 edition, and is "warn" by
1883    /// default in the 2015 edition.
1884    ///
1885    /// [arbitrary self types]: https://github.com/rust-lang/rust/issues/44874
1886    /// [issue #46906]: https://github.com/rust-lang/rust/issues/46906
1887    /// [future-incompatible]: ../index.md#future-incompatible-lints
1888    pub TYVAR_BEHIND_RAW_POINTER,
1889    Warn,
1890    "raw pointer to an inference variable",
1891    @future_incompatible = FutureIncompatibleInfo {
1892        reason: fcw!(EditionError 2018 "tyvar-behind-raw-pointer"),
1893    };
1894}
1895
1896#[doc = r" The `elided_lifetimes_in_paths` lint detects the use of hidden"]
#[doc = r" lifetime parameters."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(elided_lifetimes_in_paths)]"]
#[doc = r" #![deny(warnings)]"]
#[doc = r" struct Foo<'a> {"]
#[doc = r"     x: &'a u32"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn foo(x: &Foo) {"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Elided lifetime parameters can make it difficult to see at a glance"]
#[doc = r" that borrowing is occurring. This lint ensures that lifetime"]
#[doc = r" parameters are always explicitly stated, even if it is the `'_`"]
#[doc = r" [placeholder lifetime]."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because it has some known issues, and"#]
#[doc = r" may require a significant transition for old code."]
#[doc = r""]
#[doc =
r" [placeholder lifetime]: https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions"]
pub static ELIDED_LIFETIMES_IN_PATHS: &crate::Lint =
    &crate::Lint {
            name: "ELIDED_LIFETIMES_IN_PATHS",
            default_level: crate::Allow,
            desc: "hidden lifetime parameters in types are deprecated",
            ..
        };declare_lint! {
1897    /// The `elided_lifetimes_in_paths` lint detects the use of hidden
1898    /// lifetime parameters.
1899    ///
1900    /// ### Example
1901    ///
1902    /// ```rust,compile_fail
1903    /// #![deny(elided_lifetimes_in_paths)]
1904    /// #![deny(warnings)]
1905    /// struct Foo<'a> {
1906    ///     x: &'a u32
1907    /// }
1908    ///
1909    /// fn foo(x: &Foo) {
1910    /// }
1911    /// ```
1912    ///
1913    /// {{produces}}
1914    ///
1915    /// ### Explanation
1916    ///
1917    /// Elided lifetime parameters can make it difficult to see at a glance
1918    /// that borrowing is occurring. This lint ensures that lifetime
1919    /// parameters are always explicitly stated, even if it is the `'_`
1920    /// [placeholder lifetime].
1921    ///
1922    /// This lint is "allow" by default because it has some known issues, and
1923    /// may require a significant transition for old code.
1924    ///
1925    /// [placeholder lifetime]: https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions
1926    pub ELIDED_LIFETIMES_IN_PATHS,
1927    Allow,
1928    "hidden lifetime parameters in types are deprecated"
1929}
1930
1931#[doc =
r" The `bare_trait_objects` lint suggests using `dyn Trait` for trait"]
#[doc = r" objects."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2018"]
#[doc = r" trait Trait { }"]
#[doc = r""]
#[doc = r" fn takes_trait_object(_: Box<Trait>) {"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Without the `dyn` indicator, it can be ambiguous or confusing when"]
#[doc =
r" reading code as to whether or not you are looking at a trait object."]
#[doc =
r" The `dyn` keyword makes it explicit, and adds a symmetry to contrast"]
#[doc = r" with [`impl Trait`]."]
#[doc = r""]
#[doc =
r" [`impl Trait`]: https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters"]
pub static BARE_TRAIT_OBJECTS: &crate::Lint =
    &crate::Lint {
            name: "BARE_TRAIT_OBJECTS",
            default_level: crate::Warn,
            desc: "suggest using `dyn Trait` for trait objects",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2021,
                            page_slug: "warnings-promoted-to-error",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
1932    /// The `bare_trait_objects` lint suggests using `dyn Trait` for trait
1933    /// objects.
1934    ///
1935    /// ### Example
1936    ///
1937    /// ```rust,edition2018
1938    /// trait Trait { }
1939    ///
1940    /// fn takes_trait_object(_: Box<Trait>) {
1941    /// }
1942    /// ```
1943    ///
1944    /// {{produces}}
1945    ///
1946    /// ### Explanation
1947    ///
1948    /// Without the `dyn` indicator, it can be ambiguous or confusing when
1949    /// reading code as to whether or not you are looking at a trait object.
1950    /// The `dyn` keyword makes it explicit, and adds a symmetry to contrast
1951    /// with [`impl Trait`].
1952    ///
1953    /// [`impl Trait`]: https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
1954    pub BARE_TRAIT_OBJECTS,
1955    Warn,
1956    "suggest using `dyn Trait` for trait objects",
1957    @future_incompatible = FutureIncompatibleInfo {
1958        reason: fcw!(EditionError 2021 "warnings-promoted-to-error"),
1959    };
1960}
1961
1962#[doc = r" The `absolute_paths_not_starting_with_crate` lint detects fully"]
#[doc = r" qualified paths that start with a module name instead of `crate`,"]
#[doc = r" `self`, or an extern crate name"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2015,compile_fail"]
#[doc = r" #![deny(absolute_paths_not_starting_with_crate)]"]
#[doc = r""]
#[doc = r" mod foo {"]
#[doc = r"     pub fn bar() {}"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     ::foo::bar();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Rust [editions] allow the language to evolve without breaking"]
#[doc =
r" backwards compatibility. This lint catches code that uses absolute"]
#[doc =
r" paths in the style of the 2015 edition. In the 2015 edition, absolute"]
#[doc =
r" paths (those starting with `::`) refer to either the crate root or an"]
#[doc =
r" external crate. In the 2018 edition it was changed so that they only"]
#[doc =
r" refer to external crates. The path prefix `crate::` should be used"]
#[doc = r" instead to reference items from the crate root."]
#[doc = r""]
#[doc = r" If you switch the compiler from the 2015 to 2018 edition without"]
#[doc =
r" updating the code, then it will fail to compile if the old style paths"]
#[doc = r" are used. You can manually change the paths to use the `crate::`"]
#[doc = r" prefix to transition to the 2018 edition."]
#[doc = r""]
#[doc =
r#" This lint solves the problem automatically. It is "allow" by default"#]
#[doc =
r" because the code is perfectly valid in the 2015 edition. The [`cargo"]
#[doc =
r#" fix`] tool with the `--edition` flag will switch this lint to "warn""#]
#[doc = r" and automatically apply the suggested fix from the compiler. This"]
#[doc =
r" provides a completely automated way to update old code to the 2018"]
#[doc = r" edition."]
#[doc = r""]
#[doc = r" [editions]: https://doc.rust-lang.org/edition-guide/"]
#[doc =
r" [`cargo fix`]: https://doc.rust-lang.org/cargo/commands/cargo-fix.html"]
pub static ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE: &crate::Lint =
    &crate::Lint {
            name: "ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE",
            default_level: crate::Allow,
            desc: "fully qualified paths that start with a module name \
     instead of `crate`, `self`, or an extern crate name",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2018,
                            page_slug: "path-changes",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
1963    /// The `absolute_paths_not_starting_with_crate` lint detects fully
1964    /// qualified paths that start with a module name instead of `crate`,
1965    /// `self`, or an extern crate name
1966    ///
1967    /// ### Example
1968    ///
1969    /// ```rust,edition2015,compile_fail
1970    /// #![deny(absolute_paths_not_starting_with_crate)]
1971    ///
1972    /// mod foo {
1973    ///     pub fn bar() {}
1974    /// }
1975    ///
1976    /// fn main() {
1977    ///     ::foo::bar();
1978    /// }
1979    /// ```
1980    ///
1981    /// {{produces}}
1982    ///
1983    /// ### Explanation
1984    ///
1985    /// Rust [editions] allow the language to evolve without breaking
1986    /// backwards compatibility. This lint catches code that uses absolute
1987    /// paths in the style of the 2015 edition. In the 2015 edition, absolute
1988    /// paths (those starting with `::`) refer to either the crate root or an
1989    /// external crate. In the 2018 edition it was changed so that they only
1990    /// refer to external crates. The path prefix `crate::` should be used
1991    /// instead to reference items from the crate root.
1992    ///
1993    /// If you switch the compiler from the 2015 to 2018 edition without
1994    /// updating the code, then it will fail to compile if the old style paths
1995    /// are used. You can manually change the paths to use the `crate::`
1996    /// prefix to transition to the 2018 edition.
1997    ///
1998    /// This lint solves the problem automatically. It is "allow" by default
1999    /// because the code is perfectly valid in the 2015 edition. The [`cargo
2000    /// fix`] tool with the `--edition` flag will switch this lint to "warn"
2001    /// and automatically apply the suggested fix from the compiler. This
2002    /// provides a completely automated way to update old code to the 2018
2003    /// edition.
2004    ///
2005    /// [editions]: https://doc.rust-lang.org/edition-guide/
2006    /// [`cargo fix`]: https://doc.rust-lang.org/cargo/commands/cargo-fix.html
2007    pub ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
2008    Allow,
2009    "fully qualified paths that start with a module name \
2010     instead of `crate`, `self`, or an extern crate name",
2011     @future_incompatible = FutureIncompatibleInfo {
2012         reason: fcw!(EditionError 2018 "path-changes"),
2013     };
2014}
2015
2016#[doc =
r" The `unstable_name_collisions` lint detects that you have used a name"]
#[doc = r" that the standard library plans to add in the future."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" trait MyIterator : Iterator {"]
#[doc =
r"     // is_partitioned is an unstable method that already exists on the Iterator trait"]
#[doc = r"     fn is_partitioned<P>(self, predicate: P) -> bool"]
#[doc = r"     where"]
#[doc = r"         Self: Sized,"]
#[doc = r"         P: FnMut(Self::Item) -> bool,"]
#[doc = r"     {true}"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl<T: ?Sized> MyIterator for T where T: Iterator { }"]
#[doc = r""]
#[doc = r" let x = vec![1, 2, 3];"]
#[doc = r" let _ = x.iter().is_partitioned(|_| true);"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" When new methods are added to traits in the standard library, they are"]
#[doc =
r#" usually added in an "unstable" form which is only available on the"#]
#[doc = r" [nightly channel] with a [`feature` attribute]. If there is any"]
#[doc =
r" preexisting code which extends a trait to have a method with the same"]
#[doc =
r" name, then the names will collide. In the future, when the method is"]
#[doc =
r" stabilized, this will cause an error due to the ambiguity. This lint"]
#[doc =
r" is an early-warning to let you know that there may be a collision in"]
#[doc = r" the future. This can be avoided by adding type annotations to"]
#[doc = r" disambiguate which trait method you intend to call, such as"]
#[doc =
r" `MyIterator::is_partitioned(my_iter, my_predicate)` or renaming or removing the method."]
#[doc = r""]
#[doc =
r" [nightly channel]: https://doc.rust-lang.org/book/appendix-07-nightly-rust.html"]
#[doc =
r" [`feature` attribute]: https://doc.rust-lang.org/nightly/unstable-book/"]
pub static UNSTABLE_NAME_COLLISIONS: &crate::Lint =
    &crate::Lint {
            name: "UNSTABLE_NAME_COLLISIONS",
            default_level: crate::Warn,
            desc: "detects name collision with an existing but unstable method",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::Custom("once this associated item is added to the standard library, \
             the ambiguity may cause an error or change in behavior!",
                        crate::ReleaseFcw { issue_number: 48919 }),
                    ..
                }),
            ..
        };declare_lint! {
2017    /// The `unstable_name_collisions` lint detects that you have used a name
2018    /// that the standard library plans to add in the future.
2019    ///
2020    /// ### Example
2021    ///
2022    /// ```rust
2023    /// trait MyIterator : Iterator {
2024    ///     // is_partitioned is an unstable method that already exists on the Iterator trait
2025    ///     fn is_partitioned<P>(self, predicate: P) -> bool
2026    ///     where
2027    ///         Self: Sized,
2028    ///         P: FnMut(Self::Item) -> bool,
2029    ///     {true}
2030    /// }
2031    ///
2032    /// impl<T: ?Sized> MyIterator for T where T: Iterator { }
2033    ///
2034    /// let x = vec![1, 2, 3];
2035    /// let _ = x.iter().is_partitioned(|_| true);
2036    /// ```
2037    ///
2038    /// {{produces}}
2039    ///
2040    /// ### Explanation
2041    ///
2042    /// When new methods are added to traits in the standard library, they are
2043    /// usually added in an "unstable" form which is only available on the
2044    /// [nightly channel] with a [`feature` attribute]. If there is any
2045    /// preexisting code which extends a trait to have a method with the same
2046    /// name, then the names will collide. In the future, when the method is
2047    /// stabilized, this will cause an error due to the ambiguity. This lint
2048    /// is an early-warning to let you know that there may be a collision in
2049    /// the future. This can be avoided by adding type annotations to
2050    /// disambiguate which trait method you intend to call, such as
2051    /// `MyIterator::is_partitioned(my_iter, my_predicate)` or renaming or removing the method.
2052    ///
2053    /// [nightly channel]: https://doc.rust-lang.org/book/appendix-07-nightly-rust.html
2054    /// [`feature` attribute]: https://doc.rust-lang.org/nightly/unstable-book/
2055    pub UNSTABLE_NAME_COLLISIONS,
2056    Warn,
2057    "detects name collision with an existing but unstable method",
2058    @future_incompatible = FutureIncompatibleInfo {
2059        reason: fcw!(
2060            "once this associated item is added to the standard library, \
2061             the ambiguity may cause an error or change in behavior!"
2062             #48919
2063        ),
2064        // Note: this item represents future incompatibility of all unstable functions in the
2065        //       standard library, and thus should never be removed or changed to an error.
2066    };
2067}
2068
2069#[doc =
r" The `irrefutable_let_patterns` lint detects [irrefutable patterns]"]
#[doc = r" in [`if let`]s, [`while let`]s, and `if let` guards."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" if let _ = 123 {"]
#[doc = r#"     println!("always runs!");"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" There usually isn't a reason to have an irrefutable pattern in an"]
#[doc =
r" `if let` or `while let` statement, because the pattern will always match"]
#[doc =
r" successfully. A [`let`] or [`loop`] statement will suffice. However,"]
#[doc =
r" when generating code with a macro, forbidding irrefutable patterns"]
#[doc = r" would require awkward workarounds in situations where the macro"]
#[doc = r" doesn't know if the pattern is refutable or not. This lint allows"]
#[doc =
r" macros to accept this form, while alerting for a possibly incorrect"]
#[doc = r" use in normal code."]
#[doc = r""]
#[doc = r" See [RFC 2086] for more details."]
#[doc = r""]
#[doc =
r" [irrefutable patterns]: https://doc.rust-lang.org/reference/patterns.html#refutability"]
#[doc =
r" [`if let`]: https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions"]
#[doc =
r" [`while let`]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-pattern-loops"]
#[doc =
r" [`let`]: https://doc.rust-lang.org/reference/statements.html#let-statements"]
#[doc =
r" [`loop`]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#infinite-loops"]
#[doc =
r" [RFC 2086]: https://rust-lang.github.io/rfcs/2086-allow-if-let-irrefutables.html"]
pub static IRREFUTABLE_LET_PATTERNS: &crate::Lint =
    &crate::Lint {
            name: "IRREFUTABLE_LET_PATTERNS",
            default_level: crate::Warn,
            desc: "detects irrefutable patterns in `if let` and `while let` statements",
            ..
        };declare_lint! {
2070    /// The `irrefutable_let_patterns` lint detects [irrefutable patterns]
2071    /// in [`if let`]s, [`while let`]s, and `if let` guards.
2072    ///
2073    /// ### Example
2074    ///
2075    /// ```rust
2076    /// if let _ = 123 {
2077    ///     println!("always runs!");
2078    /// }
2079    /// ```
2080    ///
2081    /// {{produces}}
2082    ///
2083    /// ### Explanation
2084    ///
2085    /// There usually isn't a reason to have an irrefutable pattern in an
2086    /// `if let` or `while let` statement, because the pattern will always match
2087    /// successfully. A [`let`] or [`loop`] statement will suffice. However,
2088    /// when generating code with a macro, forbidding irrefutable patterns
2089    /// would require awkward workarounds in situations where the macro
2090    /// doesn't know if the pattern is refutable or not. This lint allows
2091    /// macros to accept this form, while alerting for a possibly incorrect
2092    /// use in normal code.
2093    ///
2094    /// See [RFC 2086] for more details.
2095    ///
2096    /// [irrefutable patterns]: https://doc.rust-lang.org/reference/patterns.html#refutability
2097    /// [`if let`]: https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions
2098    /// [`while let`]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-pattern-loops
2099    /// [`let`]: https://doc.rust-lang.org/reference/statements.html#let-statements
2100    /// [`loop`]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#infinite-loops
2101    /// [RFC 2086]: https://rust-lang.github.io/rfcs/2086-allow-if-let-irrefutables.html
2102    pub IRREFUTABLE_LET_PATTERNS,
2103    Warn,
2104    "detects irrefutable patterns in `if let` and `while let` statements"
2105}
2106
2107#[doc = r" The `unused_labels` lint detects [labels] that are never used."]
#[doc = r""]
#[doc =
r" [labels]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#loop-labels"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,no_run"]
#[doc = r" 'unused_label: loop {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unused labels may signal a mistake or unfinished code. To silence the"]
#[doc =
r" warning for the individual label, prefix it with an underscore such as"]
#[doc = r" `'_my_label:`."]
pub static UNUSED_LABELS: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_LABELS",
            default_level: crate::Warn,
            desc: "detects labels that are never used",
            ..
        };declare_lint! {
2108    /// The `unused_labels` lint detects [labels] that are never used.
2109    ///
2110    /// [labels]: https://doc.rust-lang.org/reference/expressions/loop-expr.html#loop-labels
2111    ///
2112    /// ### Example
2113    ///
2114    /// ```rust,no_run
2115    /// 'unused_label: loop {}
2116    /// ```
2117    ///
2118    /// {{produces}}
2119    ///
2120    /// ### Explanation
2121    ///
2122    /// Unused labels may signal a mistake or unfinished code. To silence the
2123    /// warning for the individual label, prefix it with an underscore such as
2124    /// `'_my_label:`.
2125    pub UNUSED_LABELS,
2126    Warn,
2127    "detects labels that are never used"
2128}
2129
2130#[doc =
r" The `proc_macro_derive_resolution_fallback` lint detects proc macro"]
#[doc = r" derives using inaccessible names from parent modules."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (proc-macro)"]
#[doc = r" // foo.rs"]
#[doc = r#" #![crate_type = "proc-macro"]"#]
#[doc = r""]
#[doc = r" extern crate proc_macro;"]
#[doc = r""]
#[doc = r" use proc_macro::*;"]
#[doc = r""]
#[doc = r" #[proc_macro_derive(Foo)]"]
#[doc = r" pub fn foo1(a: TokenStream) -> TokenStream {"]
#[doc = r"     drop(a);"]
#[doc =
r#"     "mod __bar { static mut BAR: Option<Something> = None; }".parse().unwrap()"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs-dependency)"]
#[doc = r" // bar.rs"]
#[doc = r" #[macro_use]"]
#[doc = r" extern crate foo;"]
#[doc = r""]
#[doc = r" struct Something;"]
#[doc = r""]
#[doc = r" #[derive(Foo)]"]
#[doc = r" struct Another;"]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: cannot find type `Something` in this scope"]
#[doc = r"  --> src/main.rs:8:10"]
#[doc = r"   |"]
#[doc = r" 8 | #[derive(Foo)]"]
#[doc =
r"   |          ^^^ names from parent modules are not accessible without an explicit import"]
#[doc = r"   |"]
#[doc =
r"   = note: `#[warn(proc_macro_derive_resolution_fallback)]` on by default"]
#[doc =
r"   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"   = note: for more information, see issue #50504 <https://github.com/rust-lang/rust/issues/50504>"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" If a proc-macro generates a module, the compiler unintentionally"]
#[doc = r" allowed items in that module to refer to items in the crate root"]
#[doc = r" without importing them. This is a [future-incompatible] lint to"]
#[doc =
r" transition this to a hard error in the future. See [issue #50504] for"]
#[doc = r" more details."]
#[doc = r""]
#[doc = r" [issue #50504]: https://github.com/rust-lang/rust/issues/50504"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static PROC_MACRO_DERIVE_RESOLUTION_FALLBACK: &crate::Lint =
    &crate::Lint {
            name: "PROC_MACRO_DERIVE_RESOLUTION_FALLBACK",
            default_level: crate::Deny,
            desc: "detects proc macro derives using inaccessible names from parent modules",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 83583,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
2131    /// The `proc_macro_derive_resolution_fallback` lint detects proc macro
2132    /// derives using inaccessible names from parent modules.
2133    ///
2134    /// ### Example
2135    ///
2136    /// ```rust,ignore (proc-macro)
2137    /// // foo.rs
2138    /// #![crate_type = "proc-macro"]
2139    ///
2140    /// extern crate proc_macro;
2141    ///
2142    /// use proc_macro::*;
2143    ///
2144    /// #[proc_macro_derive(Foo)]
2145    /// pub fn foo1(a: TokenStream) -> TokenStream {
2146    ///     drop(a);
2147    ///     "mod __bar { static mut BAR: Option<Something> = None; }".parse().unwrap()
2148    /// }
2149    /// ```
2150    ///
2151    /// ```rust,ignore (needs-dependency)
2152    /// // bar.rs
2153    /// #[macro_use]
2154    /// extern crate foo;
2155    ///
2156    /// struct Something;
2157    ///
2158    /// #[derive(Foo)]
2159    /// struct Another;
2160    ///
2161    /// fn main() {}
2162    /// ```
2163    ///
2164    /// This will produce:
2165    ///
2166    /// ```text
2167    /// warning: cannot find type `Something` in this scope
2168    ///  --> src/main.rs:8:10
2169    ///   |
2170    /// 8 | #[derive(Foo)]
2171    ///   |          ^^^ names from parent modules are not accessible without an explicit import
2172    ///   |
2173    ///   = note: `#[warn(proc_macro_derive_resolution_fallback)]` on by default
2174    ///   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
2175    ///   = note: for more information, see issue #50504 <https://github.com/rust-lang/rust/issues/50504>
2176    /// ```
2177    ///
2178    /// ### Explanation
2179    ///
2180    /// If a proc-macro generates a module, the compiler unintentionally
2181    /// allowed items in that module to refer to items in the crate root
2182    /// without importing them. This is a [future-incompatible] lint to
2183    /// transition this to a hard error in the future. See [issue #50504] for
2184    /// more details.
2185    ///
2186    /// [issue #50504]: https://github.com/rust-lang/rust/issues/50504
2187    /// [future-incompatible]: ../index.md#future-incompatible-lints
2188    pub PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
2189    Deny,
2190    "detects proc macro derives using inaccessible names from parent modules",
2191    @future_incompatible = FutureIncompatibleInfo {
2192        reason: fcw!(FutureReleaseError #83583),
2193        report_in_deps: true,
2194    };
2195}
2196
2197#[doc =
r" The `macro_use_extern_crate` lint detects the use of the [`macro_use` attribute]."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs extern crate)"]
#[doc = r" #![deny(macro_use_extern_crate)]"]
#[doc = r""]
#[doc = r" #[macro_use]"]
#[doc = r" extern crate serde_json;"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     let _ = json!{{}};"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" error: applying the `#[macro_use]` attribute to an `extern crate` item is deprecated"]
#[doc = r"  --> src/main.rs:3:1"]
#[doc = r"   |"]
#[doc = r" 3 | #[macro_use]"]
#[doc = r"   | ^^^^^^^^^^^^"]
#[doc = r"   |"]
#[doc =
r"   = help: remove it and import macros at use sites with a `use` item instead"]
#[doc = r" note: the lint level is defined here"]
#[doc = r"  --> src/main.rs:1:9"]
#[doc = r"   |"]
#[doc = r" 1 | #![deny(macro_use_extern_crate)]"]
#[doc = r"   |         ^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" The [`macro_use` attribute] on an [`extern crate`] item causes"]
#[doc =
r" macros in that external crate to be brought into the prelude of the"]
#[doc =
r" crate, making the macros in scope everywhere. As part of the efforts"]
#[doc =
r" to simplify handling of dependencies in the [2018 edition], the use of"]
#[doc =
r" `extern crate` is being phased out. To bring macros from extern crates"]
#[doc = r" into scope, it is recommended to use a [`use` import]."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default because this is a stylistic choice"#]
#[doc =
r" that has not been settled, see [issue #52043] for more information."]
#[doc = r""]
#[doc =
r" [`macro_use` attribute]: https://doc.rust-lang.org/reference/macros-by-example.html#the-macro_use-attribute"]
#[doc =
r" [`use` import]: https://doc.rust-lang.org/reference/items/use-declarations.html"]
#[doc = r" [issue #52043]: https://github.com/rust-lang/rust/issues/52043"]
pub static MACRO_USE_EXTERN_CRATE: &crate::Lint =
    &crate::Lint {
            name: "MACRO_USE_EXTERN_CRATE",
            default_level: crate::Allow,
            desc: "the `#[macro_use]` attribute is now deprecated in favor of using macros \
     via the module system",
            ..
        };declare_lint! {
2198    /// The `macro_use_extern_crate` lint detects the use of the [`macro_use` attribute].
2199    ///
2200    /// ### Example
2201    ///
2202    /// ```rust,ignore (needs extern crate)
2203    /// #![deny(macro_use_extern_crate)]
2204    ///
2205    /// #[macro_use]
2206    /// extern crate serde_json;
2207    ///
2208    /// fn main() {
2209    ///     let _ = json!{{}};
2210    /// }
2211    /// ```
2212    ///
2213    /// This will produce:
2214    ///
2215    /// ```text
2216    /// error: applying the `#[macro_use]` attribute to an `extern crate` item is deprecated
2217    ///  --> src/main.rs:3:1
2218    ///   |
2219    /// 3 | #[macro_use]
2220    ///   | ^^^^^^^^^^^^
2221    ///   |
2222    ///   = help: remove it and import macros at use sites with a `use` item instead
2223    /// note: the lint level is defined here
2224    ///  --> src/main.rs:1:9
2225    ///   |
2226    /// 1 | #![deny(macro_use_extern_crate)]
2227    ///   |         ^^^^^^^^^^^^^^^^^^^^^^
2228    /// ```
2229    ///
2230    /// ### Explanation
2231    ///
2232    /// The [`macro_use` attribute] on an [`extern crate`] item causes
2233    /// macros in that external crate to be brought into the prelude of the
2234    /// crate, making the macros in scope everywhere. As part of the efforts
2235    /// to simplify handling of dependencies in the [2018 edition], the use of
2236    /// `extern crate` is being phased out. To bring macros from extern crates
2237    /// into scope, it is recommended to use a [`use` import].
2238    ///
2239    /// This lint is "allow" by default because this is a stylistic choice
2240    /// that has not been settled, see [issue #52043] for more information.
2241    ///
2242    /// [`macro_use` attribute]: https://doc.rust-lang.org/reference/macros-by-example.html#the-macro_use-attribute
2243    /// [`use` import]: https://doc.rust-lang.org/reference/items/use-declarations.html
2244    /// [issue #52043]: https://github.com/rust-lang/rust/issues/52043
2245    pub MACRO_USE_EXTERN_CRATE,
2246    Allow,
2247    "the `#[macro_use]` attribute is now deprecated in favor of using macros \
2248     via the module system"
2249}
2250
2251#[doc =
r" The `macro_expanded_macro_exports_accessed_by_absolute_paths` lint"]
#[doc =
r" detects macro-expanded [`macro_export`] macros from the current crate"]
#[doc = r" that cannot be referred to by absolute paths."]
#[doc = r""]
#[doc =
r" [`macro_export`]: https://doc.rust-lang.org/reference/macros-by-example.html#path-based-scope"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" macro_rules! define_exported {"]
#[doc = r"     () => {"]
#[doc = r"         #[macro_export]"]
#[doc = r"         macro_rules! exported {"]
#[doc = r"             () => {};"]
#[doc = r"         }"]
#[doc = r"     };"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" define_exported!();"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     crate::exported!();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" The intent is that all macros marked with the `#[macro_export]`"]
#[doc =
r" attribute are made available in the root of the crate. However, when a"]
#[doc =
r" `macro_rules!` definition is generated by another macro, the macro"]
#[doc = r" expansion is unable to uphold this rule. This is a"]
#[doc =
r" [future-incompatible] lint to transition this to a hard error in the"]
#[doc = r" future. See [issue #53495] for more details."]
#[doc = r""]
#[doc = r" [issue #53495]: https://github.com/rust-lang/rust/issues/53495"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS:
    &crate::Lint =
    &crate::Lint {
            name: "MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS",
            default_level: crate::Deny,
            desc: "macro-expanded `macro_export` macros from the current crate \
     cannot be referred to by absolute paths",
            crate_level_only: true,
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 52234,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
2252    /// The `macro_expanded_macro_exports_accessed_by_absolute_paths` lint
2253    /// detects macro-expanded [`macro_export`] macros from the current crate
2254    /// that cannot be referred to by absolute paths.
2255    ///
2256    /// [`macro_export`]: https://doc.rust-lang.org/reference/macros-by-example.html#path-based-scope
2257    ///
2258    /// ### Example
2259    ///
2260    /// ```rust,compile_fail
2261    /// macro_rules! define_exported {
2262    ///     () => {
2263    ///         #[macro_export]
2264    ///         macro_rules! exported {
2265    ///             () => {};
2266    ///         }
2267    ///     };
2268    /// }
2269    ///
2270    /// define_exported!();
2271    ///
2272    /// fn main() {
2273    ///     crate::exported!();
2274    /// }
2275    /// ```
2276    ///
2277    /// {{produces}}
2278    ///
2279    /// ### Explanation
2280    ///
2281    /// The intent is that all macros marked with the `#[macro_export]`
2282    /// attribute are made available in the root of the crate. However, when a
2283    /// `macro_rules!` definition is generated by another macro, the macro
2284    /// expansion is unable to uphold this rule. This is a
2285    /// [future-incompatible] lint to transition this to a hard error in the
2286    /// future. See [issue #53495] for more details.
2287    ///
2288    /// [issue #53495]: https://github.com/rust-lang/rust/issues/53495
2289    /// [future-incompatible]: ../index.md#future-incompatible-lints
2290    pub MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
2291    Deny,
2292    "macro-expanded `macro_export` macros from the current crate \
2293     cannot be referred to by absolute paths",
2294    @future_incompatible = FutureIncompatibleInfo {
2295        reason: fcw!(FutureReleaseError #52234),
2296        report_in_deps: true,
2297    };
2298    crate_level_only
2299}
2300
2301#[doc = r" The `explicit_outlives_requirements` lint detects unnecessary"]
#[doc = r" lifetime bounds that can be inferred."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" # #![allow(unused)]"]
#[doc = r" #![deny(explicit_outlives_requirements)]"]
#[doc = r" #![deny(warnings)]"]
#[doc = r""]
#[doc = r" struct SharedRef<'a, T>"]
#[doc = r" where"]
#[doc = r"     T: 'a,"]
#[doc = r" {"]
#[doc = r"     data: &'a T,"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" If a struct, enum or union contains a reference, such as `&'a T`,"]
#[doc = r" the compiler requires that `T` outlives the lifetime `'a`."]
#[doc =
r" This historically required writing an explicit lifetime bound to indicate this requirement."]
#[doc =
r" However, this can be overly explicit, causing clutter and unnecessary complexity."]
#[doc =
r" The language was changed to automatically infer some classes of lifetime bounds"]
#[doc = r" if they are not specified."]
#[doc =
r" Specifically, if a struct, enum or union contains a reference, directly or indirectly,"]
#[doc =
r" to `T` with lifetime `'x` and `'x` refers to a lifetime parameter,"]
#[doc = r" then it will infer that `T: 'x` is a requirement."]
#[doc = r""]
#[doc = r" See [RFC 2093] for more details."]
#[doc = r""]
#[doc = r" > [!NOTE]"]
#[doc =
r" > This lint intentionally doesn't get emitted for explicit outlives-bounds on type"]
#[doc =
r" > parameters that aren't bounded by `Sized` (unless they're higher-ranked) since unlike"]
#[doc =
r" > implicit outlives-bounds these may affect the implicit lifetime bound of trait object"]
#[doc =
r" > types that are passed as arguments to the overarching struct, enum or union."]
#[doc = r" >"]
#[doc =
r" > Rephrased, they participate in [trait object lifetime defaulting][TOLD]."]
#[doc = r" >"]
#[doc =
r" > Consider the following piece of code where removing bound `T: 'a` would lead to a lifetime"]
#[doc = r" > error in function `scope`:"]
#[doc = r" >"]
#[doc = r" > ```rust,no_run"]
#[doc = r" > struct Ref<'a, T: ?Sized + 'a>(&'a T);"]
#[doc = r" >"]
#[doc = r" > fn scope() {"]
#[doc = r" >     let buf = String::new();"]
#[doc = r" >     let str = buf.as_str();"]
#[doc = r" >     render(Ref(&str));"]
#[doc = r" > }"]
#[doc = r" >"]
#[doc = r" > fn render(_: Ref<dyn std::fmt::Display>) {}"]
#[doc = r" > ```"]
#[doc = r" >"]
#[doc =
r" > Due to the explicit outlives-bound the function `render` above is equivalent to:"]
#[doc = r" >"]
#[doc = r" > ```rust,ignore (incomplete)"]
#[doc = r" > fn render<'r>(_: Ref<'r, dyn std::fmt::Display + 'r>) {}"]
#[doc = r" > ```"]
#[doc = r" >"]
#[doc =
r" > If it wasn't for that explicit bound then the function would mean the following instead:"]
#[doc = r" >"]
#[doc = r" > ```rust,ignore (incomplete)"]
#[doc = r" > fn render<'r>(_: Ref<'r, dyn std::fmt::Display + 'static>) {}"]
#[doc = r" > ```"]
#[doc = r""]
#[doc =
r" [RFC 2093]: https://rust-lang.github.io/rfcs/2093-infer-outlives.html"]
#[doc =
r" [TOLD]: https://doc.rust-lang.org/reference/lifetime-elision.html#default-trait-object-lifetimes"]
pub static EXPLICIT_OUTLIVES_REQUIREMENTS: &crate::Lint =
    &crate::Lint {
            name: "EXPLICIT_OUTLIVES_REQUIREMENTS",
            default_level: crate::Allow,
            desc: "outlives requirements can be inferred",
            ..
        };declare_lint! {
2302    /// The `explicit_outlives_requirements` lint detects unnecessary
2303    /// lifetime bounds that can be inferred.
2304    ///
2305    /// ### Example
2306    ///
2307    /// ```rust,compile_fail
2308    /// # #![allow(unused)]
2309    /// #![deny(explicit_outlives_requirements)]
2310    /// #![deny(warnings)]
2311    ///
2312    /// struct SharedRef<'a, T>
2313    /// where
2314    ///     T: 'a,
2315    /// {
2316    ///     data: &'a T,
2317    /// }
2318    /// ```
2319    ///
2320    /// {{produces}}
2321    ///
2322    /// ### Explanation
2323    ///
2324    /// If a struct, enum or union contains a reference, such as `&'a T`,
2325    /// the compiler requires that `T` outlives the lifetime `'a`.
2326    /// This historically required writing an explicit lifetime bound to indicate this requirement.
2327    /// However, this can be overly explicit, causing clutter and unnecessary complexity.
2328    /// The language was changed to automatically infer some classes of lifetime bounds
2329    /// if they are not specified.
2330    /// Specifically, if a struct, enum or union contains a reference, directly or indirectly,
2331    /// to `T` with lifetime `'x` and `'x` refers to a lifetime parameter,
2332    /// then it will infer that `T: 'x` is a requirement.
2333    ///
2334    /// See [RFC 2093] for more details.
2335    ///
2336    /// > [!NOTE]
2337    /// > This lint intentionally doesn't get emitted for explicit outlives-bounds on type
2338    /// > parameters that aren't bounded by `Sized` (unless they're higher-ranked) since unlike
2339    /// > implicit outlives-bounds these may affect the implicit lifetime bound of trait object
2340    /// > types that are passed as arguments to the overarching struct, enum or union.
2341    /// >
2342    /// > Rephrased, they participate in [trait object lifetime defaulting][TOLD].
2343    /// >
2344    /// > Consider the following piece of code where removing bound `T: 'a` would lead to a lifetime
2345    /// > error in function `scope`:
2346    /// >
2347    /// > ```rust,no_run
2348    /// > struct Ref<'a, T: ?Sized + 'a>(&'a T);
2349    /// >
2350    /// > fn scope() {
2351    /// >     let buf = String::new();
2352    /// >     let str = buf.as_str();
2353    /// >     render(Ref(&str));
2354    /// > }
2355    /// >
2356    /// > fn render(_: Ref<dyn std::fmt::Display>) {}
2357    /// > ```
2358    /// >
2359    /// > Due to the explicit outlives-bound the function `render` above is equivalent to:
2360    /// >
2361    /// > ```rust,ignore (incomplete)
2362    /// > fn render<'r>(_: Ref<'r, dyn std::fmt::Display + 'r>) {}
2363    /// > ```
2364    /// >
2365    /// > If it wasn't for that explicit bound then the function would mean the following instead:
2366    /// >
2367    /// > ```rust,ignore (incomplete)
2368    /// > fn render<'r>(_: Ref<'r, dyn std::fmt::Display + 'static>) {}
2369    /// > ```
2370    ///
2371    /// [RFC 2093]: https://rust-lang.github.io/rfcs/2093-infer-outlives.html
2372    /// [TOLD]: https://doc.rust-lang.org/reference/lifetime-elision.html#default-trait-object-lifetimes
2373    pub EXPLICIT_OUTLIVES_REQUIREMENTS,
2374    Allow,
2375    "outlives requirements can be inferred"
2376}
2377
2378#[doc =
r" The `deprecated_in_future` lint is internal to rustc and should not be"]
#[doc = r" used by user code."]
#[doc = r""]
#[doc =
r" This lint is only enabled in the standard library. It works with the"]
#[doc =
r" use of `#[deprecated]` with a `since` field of a version in the future."]
#[doc =
r" This allows something to be marked as deprecated in a future version,"]
#[doc =
r" and then this lint will ensure that the item is no longer used in the"]
#[doc =
r" standard library. See the [stability documentation] for more details."]
#[doc = r""]
#[doc =
r" [stability documentation]: https://rustc-dev-guide.rust-lang.org/stability.html#deprecated"]
pub static DEPRECATED_IN_FUTURE: &crate::Lint =
    &crate::Lint {
            name: "DEPRECATED_IN_FUTURE",
            default_level: crate::Allow,
            desc: "detects use of items that will be deprecated in a future version",
            report_in_external_macro: true,
            ..
        };declare_lint! {
2379    /// The `deprecated_in_future` lint is internal to rustc and should not be
2380    /// used by user code.
2381    ///
2382    /// This lint is only enabled in the standard library. It works with the
2383    /// use of `#[deprecated]` with a `since` field of a version in the future.
2384    /// This allows something to be marked as deprecated in a future version,
2385    /// and then this lint will ensure that the item is no longer used in the
2386    /// standard library. See the [stability documentation] for more details.
2387    ///
2388    /// [stability documentation]: https://rustc-dev-guide.rust-lang.org/stability.html#deprecated
2389    pub DEPRECATED_IN_FUTURE,
2390    Allow,
2391    "detects use of items that will be deprecated in a future version",
2392    report_in_external_macro
2393}
2394
2395#[doc = r" The `ambiguous_associated_items` lint detects ambiguity between"]
#[doc = r" [associated items] and [enum variants]."]
#[doc = r""]
#[doc =
r" [associated items]: https://doc.rust-lang.org/reference/items/associated-items.html"]
#[doc =
r" [enum variants]: https://doc.rust-lang.org/reference/items/enumerations.html"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" enum E {"]
#[doc = r"     V"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" trait Tr {"]
#[doc = r"     type V;"]
#[doc = r"     fn foo() -> Self::V;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl Tr for E {"]
#[doc = r"     type V = u8;"]
#[doc =
r"     // `Self::V` is ambiguous because it may refer to the associated type or"]
#[doc = r"     // the enum variant."]
#[doc = r"     fn foo() -> Self::V { 0 }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Previous versions of Rust did not allow accessing enum variants"]
#[doc =
r" through [type aliases]. When this ability was added (see [RFC 2338]), this"]
#[doc = r" introduced some situations where it can be ambiguous what a type"]
#[doc = r" was referring to."]
#[doc = r""]
#[doc =
r" To fix this ambiguity, you should use a [qualified path] to explicitly"]
#[doc = r" state which type to use. For example, in the above example the"]
#[doc = r" function can be written as `fn f() -> <Self as Tr>::V { 0 }` to"]
#[doc = r" specifically refer to the associated type."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a hard"]
#[doc = r" error in the future. See [issue #57644] for more details."]
#[doc = r""]
#[doc = r" [issue #57644]: https://github.com/rust-lang/rust/issues/57644"]
#[doc =
r" [type aliases]: https://doc.rust-lang.org/reference/items/type-aliases.html#type-aliases"]
#[doc =
r" [RFC 2338]: https://rust-lang.github.io/rfcs/2338-type-alias-enum-variants.html"]
#[doc =
r" [qualified path]: https://doc.rust-lang.org/reference/paths.html#qualified-paths"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static AMBIGUOUS_ASSOCIATED_ITEMS: &crate::Lint =
    &crate::Lint {
            name: "AMBIGUOUS_ASSOCIATED_ITEMS",
            default_level: crate::Deny,
            desc: "ambiguous associated items",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 57644,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
2396    /// The `ambiguous_associated_items` lint detects ambiguity between
2397    /// [associated items] and [enum variants].
2398    ///
2399    /// [associated items]: https://doc.rust-lang.org/reference/items/associated-items.html
2400    /// [enum variants]: https://doc.rust-lang.org/reference/items/enumerations.html
2401    ///
2402    /// ### Example
2403    ///
2404    /// ```rust,compile_fail
2405    /// enum E {
2406    ///     V
2407    /// }
2408    ///
2409    /// trait Tr {
2410    ///     type V;
2411    ///     fn foo() -> Self::V;
2412    /// }
2413    ///
2414    /// impl Tr for E {
2415    ///     type V = u8;
2416    ///     // `Self::V` is ambiguous because it may refer to the associated type or
2417    ///     // the enum variant.
2418    ///     fn foo() -> Self::V { 0 }
2419    /// }
2420    /// ```
2421    ///
2422    /// {{produces}}
2423    ///
2424    /// ### Explanation
2425    ///
2426    /// Previous versions of Rust did not allow accessing enum variants
2427    /// through [type aliases]. When this ability was added (see [RFC 2338]), this
2428    /// introduced some situations where it can be ambiguous what a type
2429    /// was referring to.
2430    ///
2431    /// To fix this ambiguity, you should use a [qualified path] to explicitly
2432    /// state which type to use. For example, in the above example the
2433    /// function can be written as `fn f() -> <Self as Tr>::V { 0 }` to
2434    /// specifically refer to the associated type.
2435    ///
2436    /// This is a [future-incompatible] lint to transition this to a hard
2437    /// error in the future. See [issue #57644] for more details.
2438    ///
2439    /// [issue #57644]: https://github.com/rust-lang/rust/issues/57644
2440    /// [type aliases]: https://doc.rust-lang.org/reference/items/type-aliases.html#type-aliases
2441    /// [RFC 2338]: https://rust-lang.github.io/rfcs/2338-type-alias-enum-variants.html
2442    /// [qualified path]: https://doc.rust-lang.org/reference/paths.html#qualified-paths
2443    /// [future-incompatible]: ../index.md#future-incompatible-lints
2444    pub AMBIGUOUS_ASSOCIATED_ITEMS,
2445    Deny,
2446    "ambiguous associated items",
2447    @future_incompatible = FutureIncompatibleInfo {
2448        reason: fcw!(FutureReleaseError #57644),
2449    };
2450}
2451
2452#[doc = r" The `inline_no_sanitize` lint detects incompatible use of"]
#[doc =
r#" [`#[inline(always)]`][inline] and [`#[sanitize(xyz = "off")]`][sanitize]."#]
#[doc = r""]
#[doc =
r" [inline]: https://doc.rust-lang.org/reference/attributes/codegen.html#the-inline-attribute"]
#[doc =
r" [sanitize]: https://doc.rust-lang.org/nightly/unstable-book/language-features/no-sanitize.html"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![feature(sanitize)]"]
#[doc = r""]
#[doc = r" #[inline(always)]"]
#[doc = r#" #[sanitize(address = "off")]"#]
#[doc = r" fn x() {}"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     x()"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The use of the [`#[inline(always)]`][inline] attribute prevents the"]
#[doc =
r#" the [`#[sanitize(xyz = "off")]`][sanitize] attribute from working."#]
#[doc = r" Consider temporarily removing `inline` attribute."]
pub static INLINE_NO_SANITIZE: &crate::Lint =
    &crate::Lint {
            name: "INLINE_NO_SANITIZE",
            default_level: crate::Warn,
            desc: r#"detects incompatible use of `#[inline(always)]` and `#[sanitize(... = "off")]`"#,
            ..
        };declare_lint! {
2453    /// The `inline_no_sanitize` lint detects incompatible use of
2454    /// [`#[inline(always)]`][inline] and [`#[sanitize(xyz = "off")]`][sanitize].
2455    ///
2456    /// [inline]: https://doc.rust-lang.org/reference/attributes/codegen.html#the-inline-attribute
2457    /// [sanitize]: https://doc.rust-lang.org/nightly/unstable-book/language-features/no-sanitize.html
2458    ///
2459    /// ### Example
2460    ///
2461    /// ```rust
2462    /// #![feature(sanitize)]
2463    ///
2464    /// #[inline(always)]
2465    /// #[sanitize(address = "off")]
2466    /// fn x() {}
2467    ///
2468    /// fn main() {
2469    ///     x()
2470    /// }
2471    /// ```
2472    ///
2473    /// {{produces}}
2474    ///
2475    /// ### Explanation
2476    ///
2477    /// The use of the [`#[inline(always)]`][inline] attribute prevents the
2478    /// the [`#[sanitize(xyz = "off")]`][sanitize] attribute from working.
2479    /// Consider temporarily removing `inline` attribute.
2480    pub INLINE_NO_SANITIZE,
2481    Warn,
2482    r#"detects incompatible use of `#[inline(always)]` and `#[sanitize(... = "off")]`"#,
2483}
2484
2485#[doc = r" The `rtsan_nonblocking_async` lint detects incompatible use of"]
#[doc =
r#" [`#[sanitize(realtime = "nonblocking")]`][sanitize] on async functions."#]
#[doc = r""]
#[doc =
r" [sanitize]: https://doc.rust-lang.org/nightly/unstable-book/language-features/no-sanitize.html"]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,no_run"]
#[doc = r" #![feature(sanitize)]"]
#[doc = r""]
#[doc = r#" #[sanitize(realtime = "nonblocking")]"#]
#[doc = r" async fn x() {}"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     x();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The sanitizer only considers the async function body nonblocking. The executor, which runs on"]
#[doc =
r" every `.await` point can run non-realtime code, without the sanitizer catching it."]
pub static RTSAN_NONBLOCKING_ASYNC: &crate::Lint =
    &crate::Lint {
            name: "RTSAN_NONBLOCKING_ASYNC",
            default_level: crate::Warn,
            desc: r#"detects incompatible uses of `#[sanitize(realtime = "nonblocking")]` on async functions"#,
            ..
        };declare_lint! {
2486    /// The `rtsan_nonblocking_async` lint detects incompatible use of
2487    /// [`#[sanitize(realtime = "nonblocking")]`][sanitize] on async functions.
2488    ///
2489    /// [sanitize]: https://doc.rust-lang.org/nightly/unstable-book/language-features/no-sanitize.html
2490    /// ### Example
2491    ///
2492    /// ```rust,no_run
2493    /// #![feature(sanitize)]
2494    ///
2495    /// #[sanitize(realtime = "nonblocking")]
2496    /// async fn x() {}
2497    ///
2498    /// fn main() {
2499    ///     x();
2500    /// }
2501    /// ```
2502    ///
2503    /// {{produces}}
2504    ///
2505    /// ### Explanation
2506    ///
2507    /// The sanitizer only considers the async function body nonblocking. The executor, which runs on
2508    /// every `.await` point can run non-realtime code, without the sanitizer catching it.
2509    pub RTSAN_NONBLOCKING_ASYNC,
2510    Warn,
2511    r#"detects incompatible uses of `#[sanitize(realtime = "nonblocking")]` on async functions"#,
2512}
2513
2514#[doc =
r" The `asm_sub_register` lint detects using only a subset of a register"]
#[doc = r" for inline asm inputs."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (fails on non-x86_64)"]
#[doc = r#" #[cfg(target_arch="x86_64")]"#]
#[doc = r" use std::arch::asm;"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r#"     #[cfg(target_arch="x86_64")]"#]
#[doc = r"     unsafe {"]
#[doc = r#"         asm!("mov {0}, {0}", in(reg) 0i16);"#]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: formatting may not be suitable for sub-register argument"]
#[doc = r"  --> src/main.rs:7:19"]
#[doc = r"   |"]
#[doc = r#" 7 |         asm!("mov {0}, {0}", in(reg) 0i16);"#]
#[doc = r"   |                   ^^^  ^^^           ---- for this argument"]
#[doc = r"   |"]
#[doc = r"   = note: `#[warn(asm_sub_register)]` on by default"]
#[doc =
r"   = help: use the `x` modifier to have the register formatted as `ax`"]
#[doc =
r"   = help: or use the `r` modifier to keep the default formatting of `rax`"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Registers on some architectures can use different names to refer to a"]
#[doc =
r" subset of the register. By default, the compiler will use the name for"]
#[doc =
r" the full register size. To explicitly use a subset of the register,"]
#[doc = r" you can override the default by using a modifier on the template"]
#[doc =
r" string operand to specify when subregister to use. This lint is issued"]
#[doc = r" if you pass in a value with a smaller data type than the default"]
#[doc =
r" register size, to alert you of possibly using the incorrect width. To"]
#[doc = r" fix this, add the suggested modifier to the template, or cast the"]
#[doc = r" value to the correct size."]
#[doc = r""]
#[doc =
r" See [register template modifiers] in the reference for more details."]
#[doc = r""]
#[doc =
r" [register template modifiers]: https://doc.rust-lang.org/nightly/reference/inline-assembly.html#template-modifiers"]
pub static ASM_SUB_REGISTER: &crate::Lint =
    &crate::Lint {
            name: "ASM_SUB_REGISTER",
            default_level: crate::Warn,
            desc: "using only a subset of a register for inline asm inputs",
            ..
        };declare_lint! {
2515    /// The `asm_sub_register` lint detects using only a subset of a register
2516    /// for inline asm inputs.
2517    ///
2518    /// ### Example
2519    ///
2520    /// ```rust,ignore (fails on non-x86_64)
2521    /// #[cfg(target_arch="x86_64")]
2522    /// use std::arch::asm;
2523    ///
2524    /// fn main() {
2525    ///     #[cfg(target_arch="x86_64")]
2526    ///     unsafe {
2527    ///         asm!("mov {0}, {0}", in(reg) 0i16);
2528    ///     }
2529    /// }
2530    /// ```
2531    ///
2532    /// This will produce:
2533    ///
2534    /// ```text
2535    /// warning: formatting may not be suitable for sub-register argument
2536    ///  --> src/main.rs:7:19
2537    ///   |
2538    /// 7 |         asm!("mov {0}, {0}", in(reg) 0i16);
2539    ///   |                   ^^^  ^^^           ---- for this argument
2540    ///   |
2541    ///   = note: `#[warn(asm_sub_register)]` on by default
2542    ///   = help: use the `x` modifier to have the register formatted as `ax`
2543    ///   = help: or use the `r` modifier to keep the default formatting of `rax`
2544    /// ```
2545    ///
2546    /// ### Explanation
2547    ///
2548    /// Registers on some architectures can use different names to refer to a
2549    /// subset of the register. By default, the compiler will use the name for
2550    /// the full register size. To explicitly use a subset of the register,
2551    /// you can override the default by using a modifier on the template
2552    /// string operand to specify when subregister to use. This lint is issued
2553    /// if you pass in a value with a smaller data type than the default
2554    /// register size, to alert you of possibly using the incorrect width. To
2555    /// fix this, add the suggested modifier to the template, or cast the
2556    /// value to the correct size.
2557    ///
2558    /// See [register template modifiers] in the reference for more details.
2559    ///
2560    /// [register template modifiers]: https://doc.rust-lang.org/nightly/reference/inline-assembly.html#template-modifiers
2561    pub ASM_SUB_REGISTER,
2562    Warn,
2563    "using only a subset of a register for inline asm inputs",
2564}
2565
2566#[doc =
r" The `bad_asm_style` lint detects the use of the `.intel_syntax` and"]
#[doc = r" `.att_syntax` directives."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (fails on non-x86_64)"]
#[doc = r#" #[cfg(target_arch="x86_64")]"#]
#[doc = r" use std::arch::asm;"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r#"     #[cfg(target_arch="x86_64")]"#]
#[doc = r"     unsafe {"]
#[doc = r"         asm!("]
#[doc = r#"             ".att_syntax","#]
#[doc = r#"             "movq %{0}, %{0}", in(reg) 0usize"#]
#[doc = r"         );"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" warning: avoid using `.att_syntax`, prefer using `options(att_syntax)` instead"]
#[doc = r"  --> src/main.rs:8:14"]
#[doc = r"   |"]
#[doc = r#" 8 |             ".att_syntax","#]
#[doc = r"   |              ^^^^^^^^^^^"]
#[doc = r"   |"]
#[doc = r"   = note: `#[warn(bad_asm_style)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" On x86, `asm!` uses the intel assembly syntax by default. While this"]
#[doc =
r" can be switched using assembler directives like `.att_syntax`, using the"]
#[doc =
r" `att_syntax` option is recommended instead because it will also properly"]
#[doc = r" prefix register placeholders with `%` as required by AT&T syntax."]
pub static BAD_ASM_STYLE: &crate::Lint =
    &crate::Lint {
            name: "BAD_ASM_STYLE",
            default_level: crate::Warn,
            desc: "incorrect use of inline assembly",
            ..
        };declare_lint! {
2567    /// The `bad_asm_style` lint detects the use of the `.intel_syntax` and
2568    /// `.att_syntax` directives.
2569    ///
2570    /// ### Example
2571    ///
2572    /// ```rust,ignore (fails on non-x86_64)
2573    /// #[cfg(target_arch="x86_64")]
2574    /// use std::arch::asm;
2575    ///
2576    /// fn main() {
2577    ///     #[cfg(target_arch="x86_64")]
2578    ///     unsafe {
2579    ///         asm!(
2580    ///             ".att_syntax",
2581    ///             "movq %{0}, %{0}", in(reg) 0usize
2582    ///         );
2583    ///     }
2584    /// }
2585    /// ```
2586    ///
2587    /// This will produce:
2588    ///
2589    /// ```text
2590    /// warning: avoid using `.att_syntax`, prefer using `options(att_syntax)` instead
2591    ///  --> src/main.rs:8:14
2592    ///   |
2593    /// 8 |             ".att_syntax",
2594    ///   |              ^^^^^^^^^^^
2595    ///   |
2596    ///   = note: `#[warn(bad_asm_style)]` on by default
2597    /// ```
2598    ///
2599    /// ### Explanation
2600    ///
2601    /// On x86, `asm!` uses the intel assembly syntax by default. While this
2602    /// can be switched using assembler directives like `.att_syntax`, using the
2603    /// `att_syntax` option is recommended instead because it will also properly
2604    /// prefix register placeholders with `%` as required by AT&T syntax.
2605    pub BAD_ASM_STYLE,
2606    Warn,
2607    "incorrect use of inline assembly",
2608}
2609
2610#[doc =
r" The `unsafe_op_in_unsafe_fn` lint detects unsafe operations in unsafe"]
#[doc = r" functions without an explicit unsafe block."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(unsafe_op_in_unsafe_fn)]"]
#[doc = r""]
#[doc = r" unsafe fn foo() {}"]
#[doc = r""]
#[doc = r" unsafe fn bar() {"]
#[doc = r"     foo();"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Currently, an [`unsafe fn`] allows any [unsafe] operation within its"]
#[doc =
r" body. However, this can increase the surface area of code that needs"]
#[doc =
r" to be scrutinized for proper behavior. The [`unsafe` block] provides a"]
#[doc =
r" convenient way to make it clear exactly which parts of the code are"]
#[doc =
r" performing unsafe operations. In the future, it is desired to change"]
#[doc =
r" it so that unsafe operations cannot be performed in an `unsafe fn`"]
#[doc = r" without an `unsafe` block."]
#[doc = r""]
#[doc = r" The fix to this is to wrap the unsafe code in an `unsafe` block."]
#[doc = r""]
#[doc =
r#" This lint is "allow" by default on editions up to 2021, from 2024 it is"#]
#[doc = r#" "warn" by default; the plan for increasing severity further is"#]
#[doc =
r" still being considered. See [RFC #2585] and [issue #71668] for more"]
#[doc = r" details."]
#[doc = r""]
#[doc =
r" [`unsafe fn`]: https://doc.rust-lang.org/reference/unsafe-functions.html"]
#[doc =
r" [`unsafe` block]: https://doc.rust-lang.org/reference/expressions/block-expr.html#unsafe-blocks"]
#[doc = r" [unsafe]: https://doc.rust-lang.org/reference/unsafety.html"]
#[doc =
r" [RFC #2585]: https://rust-lang.github.io/rfcs/2585-unsafe-block-in-unsafe-fn.html"]
#[doc = r" [issue #71668]: https://github.com/rust-lang/rust/issues/71668"]
pub static UNSAFE_OP_IN_UNSAFE_FN: &crate::Lint =
    &crate::Lint {
            name: "UNSAFE_OP_IN_UNSAFE_FN",
            default_level: crate::Allow,
            desc: "unsafe operations in unsafe functions without an explicit unsafe block are deprecated",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "unsafe-op-in-unsafe-fn",
                        }),
                    explain_reason: false,
                    ..
                }),
            edition_lint_opts: Some((::rustc_span::edition::Edition::Edition2024,
                    crate::Warn)),
            ..
        };declare_lint! {
2611    /// The `unsafe_op_in_unsafe_fn` lint detects unsafe operations in unsafe
2612    /// functions without an explicit unsafe block.
2613    ///
2614    /// ### Example
2615    ///
2616    /// ```rust,compile_fail
2617    /// #![deny(unsafe_op_in_unsafe_fn)]
2618    ///
2619    /// unsafe fn foo() {}
2620    ///
2621    /// unsafe fn bar() {
2622    ///     foo();
2623    /// }
2624    ///
2625    /// fn main() {}
2626    /// ```
2627    ///
2628    /// {{produces}}
2629    ///
2630    /// ### Explanation
2631    ///
2632    /// Currently, an [`unsafe fn`] allows any [unsafe] operation within its
2633    /// body. However, this can increase the surface area of code that needs
2634    /// to be scrutinized for proper behavior. The [`unsafe` block] provides a
2635    /// convenient way to make it clear exactly which parts of the code are
2636    /// performing unsafe operations. In the future, it is desired to change
2637    /// it so that unsafe operations cannot be performed in an `unsafe fn`
2638    /// without an `unsafe` block.
2639    ///
2640    /// The fix to this is to wrap the unsafe code in an `unsafe` block.
2641    ///
2642    /// This lint is "allow" by default on editions up to 2021, from 2024 it is
2643    /// "warn" by default; the plan for increasing severity further is
2644    /// still being considered. See [RFC #2585] and [issue #71668] for more
2645    /// details.
2646    ///
2647    /// [`unsafe fn`]: https://doc.rust-lang.org/reference/unsafe-functions.html
2648    /// [`unsafe` block]: https://doc.rust-lang.org/reference/expressions/block-expr.html#unsafe-blocks
2649    /// [unsafe]: https://doc.rust-lang.org/reference/unsafety.html
2650    /// [RFC #2585]: https://rust-lang.github.io/rfcs/2585-unsafe-block-in-unsafe-fn.html
2651    /// [issue #71668]: https://github.com/rust-lang/rust/issues/71668
2652    pub UNSAFE_OP_IN_UNSAFE_FN,
2653    Allow,
2654    "unsafe operations in unsafe functions without an explicit unsafe block are deprecated",
2655    @future_incompatible = FutureIncompatibleInfo {
2656        reason: fcw!(EditionError 2024 "unsafe-op-in-unsafe-fn"),
2657        explain_reason: false
2658    };
2659    @edition Edition2024 => Warn;
2660}
2661
2662#[doc =
r" The `const_evaluatable_unchecked` lint detects a generic constant used"]
#[doc = r" in a type."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" const fn foo<T>() -> usize {"]
#[doc =
r"     if size_of::<*mut T>() < 8 { // size of *mut T does not depend on T"]
#[doc = r"         4"]
#[doc = r"     } else {"]
#[doc = r"         8"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn test<T>() {"]
#[doc = r"     let _ = [0; foo::<T>()];"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In the 1.43 release, some uses of generic parameters in array repeat"]
#[doc =
r" expressions were accidentally allowed. This is a [future-incompatible]"]
#[doc = r" lint to transition this to a hard error in the future. See [issue"]
#[doc = r" #76200] for a more detailed description and possible fixes."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
#[doc = r" [issue #76200]: https://github.com/rust-lang/rust/issues/76200"]
pub static CONST_EVALUATABLE_UNCHECKED: &crate::Lint =
    &crate::Lint {
            name: "CONST_EVALUATABLE_UNCHECKED",
            default_level: crate::Warn,
            desc: "detects a generic constant is used in a type without a emitting a warning",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 76200,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
2663    /// The `const_evaluatable_unchecked` lint detects a generic constant used
2664    /// in a type.
2665    ///
2666    /// ### Example
2667    ///
2668    /// ```rust
2669    /// const fn foo<T>() -> usize {
2670    ///     if size_of::<*mut T>() < 8 { // size of *mut T does not depend on T
2671    ///         4
2672    ///     } else {
2673    ///         8
2674    ///     }
2675    /// }
2676    ///
2677    /// fn test<T>() {
2678    ///     let _ = [0; foo::<T>()];
2679    /// }
2680    /// ```
2681    ///
2682    /// {{produces}}
2683    ///
2684    /// ### Explanation
2685    ///
2686    /// In the 1.43 release, some uses of generic parameters in array repeat
2687    /// expressions were accidentally allowed. This is a [future-incompatible]
2688    /// lint to transition this to a hard error in the future. See [issue
2689    /// #76200] for a more detailed description and possible fixes.
2690    ///
2691    /// [future-incompatible]: ../index.md#future-incompatible-lints
2692    /// [issue #76200]: https://github.com/rust-lang/rust/issues/76200
2693    pub CONST_EVALUATABLE_UNCHECKED,
2694    Warn,
2695    "detects a generic constant is used in a type without a emitting a warning",
2696    @future_incompatible = FutureIncompatibleInfo {
2697        reason: fcw!(FutureReleaseError #76200),
2698    };
2699}
2700
2701#[doc =
r" The `function_item_references` lint detects function references that are"]
#[doc = r" formatted with [`fmt::Pointer`] or transmuted."]
#[doc = r""]
#[doc =
r" [`fmt::Pointer`]: https://doc.rust-lang.org/std/fmt/trait.Pointer.html"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" fn foo() { }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r#"     println!("{:p}", &foo);"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Taking a reference to a function may be mistaken as a way to obtain a"]
#[doc = r" pointer to that function. This can give unexpected results when"]
#[doc =
r" formatting the reference as a pointer or transmuting it. This lint is"]
#[doc =
r" issued when function references are formatted as pointers, passed as"]
#[doc = r" arguments bound by [`fmt::Pointer`] or transmuted."]
pub static FUNCTION_ITEM_REFERENCES: &crate::Lint =
    &crate::Lint {
            name: "FUNCTION_ITEM_REFERENCES",
            default_level: crate::Warn,
            desc: "suggest casting to a function pointer when attempting to take references to function items",
            ..
        };declare_lint! {
2702    /// The `function_item_references` lint detects function references that are
2703    /// formatted with [`fmt::Pointer`] or transmuted.
2704    ///
2705    /// [`fmt::Pointer`]: https://doc.rust-lang.org/std/fmt/trait.Pointer.html
2706    ///
2707    /// ### Example
2708    ///
2709    /// ```rust
2710    /// fn foo() { }
2711    ///
2712    /// fn main() {
2713    ///     println!("{:p}", &foo);
2714    /// }
2715    /// ```
2716    ///
2717    /// {{produces}}
2718    ///
2719    /// ### Explanation
2720    ///
2721    /// Taking a reference to a function may be mistaken as a way to obtain a
2722    /// pointer to that function. This can give unexpected results when
2723    /// formatting the reference as a pointer or transmuting it. This lint is
2724    /// issued when function references are formatted as pointers, passed as
2725    /// arguments bound by [`fmt::Pointer`] or transmuted.
2726    pub FUNCTION_ITEM_REFERENCES,
2727    Warn,
2728    "suggest casting to a function pointer when attempting to take references to function items",
2729}
2730
2731#[doc = r" The `uninhabited_static` lint detects uninhabited statics."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" enum Void {}"]
#[doc = r" unsafe extern {"]
#[doc = r"     static EXTERN: Void;"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Statics with an uninhabited type can never be initialized, so they are impossible to define."]
#[doc =
r" However, this can be side-stepped with an `extern static`, leading to problems later in the"]
#[doc =
r" compiler which assumes that there are no initialized uninhabited places (such as locals or"]
#[doc = r" statics). This was accidentally allowed, but is being phased out."]
pub static UNINHABITED_STATIC: &crate::Lint =
    &crate::Lint {
            name: "UNINHABITED_STATIC",
            default_level: crate::Deny,
            desc: "uninhabited static",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 74840,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
2732    /// The `uninhabited_static` lint detects uninhabited statics.
2733    ///
2734    /// ### Example
2735    ///
2736    /// ```rust,compile_fail
2737    /// enum Void {}
2738    /// unsafe extern {
2739    ///     static EXTERN: Void;
2740    /// }
2741    /// ```
2742    ///
2743    /// {{produces}}
2744    ///
2745    /// ### Explanation
2746    ///
2747    /// Statics with an uninhabited type can never be initialized, so they are impossible to define.
2748    /// However, this can be side-stepped with an `extern static`, leading to problems later in the
2749    /// compiler which assumes that there are no initialized uninhabited places (such as locals or
2750    /// statics). This was accidentally allowed, but is being phased out.
2751    pub UNINHABITED_STATIC,
2752    Deny,
2753    "uninhabited static",
2754    @future_incompatible = FutureIncompatibleInfo {
2755        reason: fcw!(FutureReleaseError #74840),
2756        report_in_deps: true,
2757    };
2758}
2759
2760#[doc =
r" The `unnameable_test_items` lint detects [`#[test]`][test] functions"]
#[doc =
r" that are not able to be run by the test harness because they are in a"]
#[doc = r" position where they are not nameable."]
#[doc = r""]
#[doc =
r" [test]: https://doc.rust-lang.org/reference/attributes/testing.html#the-test-attribute"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,test"]
#[doc = r" fn main() {"]
#[doc = r"     #[test]"]
#[doc = r"     fn foo() {"]
#[doc = r"         // This test will not fail because it does not run."]
#[doc = r"         assert_eq!(1, 2);"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In order for the test harness to run a test, the test function must be"]
#[doc =
r" located in a position where it can be accessed from the crate root."]
#[doc =
r" This generally means it must be defined in a module, and not anywhere"]
#[doc =
r" else such as inside another function. The compiler previously allowed"]
#[doc =
r" this without an error, so a lint was added as an alert that a test is"]
#[doc =
r" not being used. Whether or not this should be allowed has not yet been"]
#[doc = r" decided, see [RFC 2471] and [issue #36629]."]
#[doc = r""]
#[doc =
r" [RFC 2471]: https://github.com/rust-lang/rfcs/pull/2471#issuecomment-397414443"]
#[doc = r" [issue #36629]: https://github.com/rust-lang/rust/issues/36629"]
pub static UNNAMEABLE_TEST_ITEMS: &crate::Lint =
    &crate::Lint {
            name: "UNNAMEABLE_TEST_ITEMS",
            default_level: crate::Warn,
            desc: "detects an item that cannot be named being marked as `#[test_case]`",
            report_in_external_macro: true,
            ..
        };declare_lint! {
2761    /// The `unnameable_test_items` lint detects [`#[test]`][test] functions
2762    /// that are not able to be run by the test harness because they are in a
2763    /// position where they are not nameable.
2764    ///
2765    /// [test]: https://doc.rust-lang.org/reference/attributes/testing.html#the-test-attribute
2766    ///
2767    /// ### Example
2768    ///
2769    /// ```rust,test
2770    /// fn main() {
2771    ///     #[test]
2772    ///     fn foo() {
2773    ///         // This test will not fail because it does not run.
2774    ///         assert_eq!(1, 2);
2775    ///     }
2776    /// }
2777    /// ```
2778    ///
2779    /// {{produces}}
2780    ///
2781    /// ### Explanation
2782    ///
2783    /// In order for the test harness to run a test, the test function must be
2784    /// located in a position where it can be accessed from the crate root.
2785    /// This generally means it must be defined in a module, and not anywhere
2786    /// else such as inside another function. The compiler previously allowed
2787    /// this without an error, so a lint was added as an alert that a test is
2788    /// not being used. Whether or not this should be allowed has not yet been
2789    /// decided, see [RFC 2471] and [issue #36629].
2790    ///
2791    /// [RFC 2471]: https://github.com/rust-lang/rfcs/pull/2471#issuecomment-397414443
2792    /// [issue #36629]: https://github.com/rust-lang/rust/issues/36629
2793    pub UNNAMEABLE_TEST_ITEMS,
2794    Warn,
2795    "detects an item that cannot be named being marked as `#[test_case]`",
2796    report_in_external_macro
2797}
2798
2799#[doc =
r" The `useless_deprecated` lint detects deprecation attributes with no effect."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" struct X;"]
#[doc = r""]
#[doc = r#" #[deprecated = "message"]"#]
#[doc = r" impl Default for X {"]
#[doc = r"     fn default() -> Self {"]
#[doc = r"         X"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Deprecation attributes have no effect on trait implementations."]
pub static USELESS_DEPRECATED: &crate::Lint =
    &crate::Lint {
            name: "USELESS_DEPRECATED",
            default_level: crate::Deny,
            desc: "detects deprecation attributes with no effect",
            ..
        };declare_lint! {
2800    /// The `useless_deprecated` lint detects deprecation attributes with no effect.
2801    ///
2802    /// ### Example
2803    ///
2804    /// ```rust,compile_fail
2805    /// struct X;
2806    ///
2807    /// #[deprecated = "message"]
2808    /// impl Default for X {
2809    ///     fn default() -> Self {
2810    ///         X
2811    ///     }
2812    /// }
2813    /// ```
2814    ///
2815    /// {{produces}}
2816    ///
2817    /// ### Explanation
2818    ///
2819    /// Deprecation attributes have no effect on trait implementations.
2820    pub USELESS_DEPRECATED,
2821    Deny,
2822    "detects deprecation attributes with no effect",
2823}
2824
2825#[doc = r" The `ineffective_unstable_reexports` lint detects `#[unstable]`"]
#[doc = r" attributes on re-exports where the attribute does not make the"]
#[doc = r" re-exported path unstable."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![feature(staged_api)]"]
#[doc = r#" #![stable(feature = "test", since = "1.0.0")]"#]
#[doc = r""]
#[doc = r#" #[stable(feature = "test", since = "1.0.0")]"#]
#[doc = r" pub struct S;"]
#[doc = r""]
#[doc = r#" #[unstable(feature = "reexport", issue = "none")]"#]
#[doc = r" pub use self::S as T;"]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" `#[unstable]` on a re-export does not make a stable path unstable"]
#[doc =
r" re-exports inside unstable modules are already on an unstable path"]
pub static INEFFECTIVE_UNSTABLE_REEXPORTS: &crate::Lint =
    &crate::Lint {
            name: "INEFFECTIVE_UNSTABLE_REEXPORTS",
            default_level: crate::Deny,
            desc: "detects ineffective `#[unstable]` attributes on re-exports",
            feature_gate: Some(rustc_span::sym::staged_api),
            ..
        };declare_lint! {
2826    /// The `ineffective_unstable_reexports` lint detects `#[unstable]`
2827    /// attributes on re-exports where the attribute does not make the
2828    /// re-exported path unstable.
2829    ///
2830    /// ### Example
2831    ///
2832    /// ```rust,compile_fail
2833    /// #![feature(staged_api)]
2834    /// #![stable(feature = "test", since = "1.0.0")]
2835    ///
2836    /// #[stable(feature = "test", since = "1.0.0")]
2837    /// pub struct S;
2838    ///
2839    /// #[unstable(feature = "reexport", issue = "none")]
2840    /// pub use self::S as T;
2841    ///
2842    /// fn main() {}
2843    /// ```
2844    ///
2845    /// {{produces}}
2846    ///
2847    /// ### Explanation
2848    ///
2849    /// `#[unstable]` on a re-export does not make a stable path unstable
2850    /// re-exports inside unstable modules are already on an unstable path
2851    pub INEFFECTIVE_UNSTABLE_REEXPORTS,
2852    Deny,
2853    "detects ineffective `#[unstable]` attributes on re-exports",
2854    @feature_gate = staged_api;
2855}
2856
2857#[doc =
r" The `ineffective_unstable_trait_impl` lint detects `#[unstable]` attributes which are not used."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![feature(staged_api)]"]
#[doc = r""]
#[doc = r" #[derive(Clone)]"]
#[doc = r#" #[stable(feature = "x", since = "1")]"#]
#[doc = r" struct S {}"]
#[doc = r""]
#[doc = r#" #[unstable(feature = "y", issue = "none")]"#]
#[doc = r" impl Copy for S {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" `staged_api` does not currently support using a stability attribute on `impl` blocks."]
#[doc =
r" `impl`s are always stable if both the type and trait are stable, and always unstable otherwise."]
pub static INEFFECTIVE_UNSTABLE_TRAIT_IMPL: &crate::Lint =
    &crate::Lint {
            name: "INEFFECTIVE_UNSTABLE_TRAIT_IMPL",
            default_level: crate::Deny,
            desc: "detects `#[unstable]` on stable trait implementations for stable types",
            ..
        };declare_lint! {
2858    /// The `ineffective_unstable_trait_impl` lint detects `#[unstable]` attributes which are not used.
2859    ///
2860    /// ### Example
2861    ///
2862    /// ```rust,compile_fail
2863    /// #![feature(staged_api)]
2864    ///
2865    /// #[derive(Clone)]
2866    /// #[stable(feature = "x", since = "1")]
2867    /// struct S {}
2868    ///
2869    /// #[unstable(feature = "y", issue = "none")]
2870    /// impl Copy for S {}
2871    /// ```
2872    ///
2873    /// {{produces}}
2874    ///
2875    /// ### Explanation
2876    ///
2877    /// `staged_api` does not currently support using a stability attribute on `impl` blocks.
2878    /// `impl`s are always stable if both the type and trait are stable, and always unstable otherwise.
2879    pub INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
2880    Deny,
2881    "detects `#[unstable]` on stable trait implementations for stable types"
2882}
2883
2884#[doc =
r" The `self_constructor_from_outer_item` lint detects cases where the `Self` constructor"]
#[doc =
r" was silently allowed due to a bug in the resolver, and which may produce surprising"]
#[doc = r" and unintended behavior."]
#[doc = r""]
#[doc =
r" Using a `Self` type alias from an outer item was never intended, but was silently allowed."]
#[doc =
r" This is deprecated -- and is a hard error when the `Self` type alias references generics"]
#[doc = r" that are not in scope."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(self_constructor_from_outer_item)]"]
#[doc = r""]
#[doc = r" struct S0(usize);"]
#[doc = r""]
#[doc = r" impl S0 {"]
#[doc = r"     fn foo() {"]
#[doc = r"         const C: S0 = Self(0);"]
#[doc = r"         fn bar() -> S0 {"]
#[doc = r"             Self(0)"]
#[doc = r"         }"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The `Self` type alias should not be reachable because nested items are not associated with"]
#[doc = r" the scope of the parameters from the parent item."]
pub static SELF_CONSTRUCTOR_FROM_OUTER_ITEM: &crate::Lint =
    &crate::Lint {
            name: "SELF_CONSTRUCTOR_FROM_OUTER_ITEM",
            default_level: crate::Warn,
            desc: "detect unsupported use of `Self` from outer item",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 124186,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
2885    /// The `self_constructor_from_outer_item` lint detects cases where the `Self` constructor
2886    /// was silently allowed due to a bug in the resolver, and which may produce surprising
2887    /// and unintended behavior.
2888    ///
2889    /// Using a `Self` type alias from an outer item was never intended, but was silently allowed.
2890    /// This is deprecated -- and is a hard error when the `Self` type alias references generics
2891    /// that are not in scope.
2892    ///
2893    /// ### Example
2894    ///
2895    /// ```rust,compile_fail
2896    /// #![deny(self_constructor_from_outer_item)]
2897    ///
2898    /// struct S0(usize);
2899    ///
2900    /// impl S0 {
2901    ///     fn foo() {
2902    ///         const C: S0 = Self(0);
2903    ///         fn bar() -> S0 {
2904    ///             Self(0)
2905    ///         }
2906    ///     }
2907    /// }
2908    /// ```
2909    ///
2910    /// {{produces}}
2911    ///
2912    /// ### Explanation
2913    ///
2914    /// The `Self` type alias should not be reachable because nested items are not associated with
2915    /// the scope of the parameters from the parent item.
2916    pub SELF_CONSTRUCTOR_FROM_OUTER_ITEM,
2917    Warn,
2918    "detect unsupported use of `Self` from outer item",
2919    @future_incompatible = FutureIncompatibleInfo {
2920        reason: fcw!(FutureReleaseError #124186),
2921    };
2922}
2923
2924#[doc =
r" The `semicolon_in_expressions_from_macros` lint detects trailing semicolons"]
#[doc = r" in macro bodies when the macro is invoked in expression position."]
#[doc = r" This was previous accepted, but is being phased out."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(semicolon_in_expressions_from_macros)]"]
#[doc = r" macro_rules! foo {"]
#[doc = r"     () => { true; }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     let val = match true {"]
#[doc = r"         true => false,"]
#[doc = r"         _ => foo!()"]
#[doc = r"     };"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Previous, Rust ignored trailing semicolon in a macro"]
#[doc = r" body when a macro was invoked in expression position."]
#[doc = r" However, this makes the treatment of semicolons in the language"]
#[doc = r" inconsistent, and could lead to unexpected runtime behavior"]
#[doc = r" in some circumstances (e.g. if the macro author expects"]
#[doc = r" a value to be dropped)."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this"]
#[doc =
r" to a hard error in the future. See [issue #79813] for more details."]
#[doc = r""]
#[doc = r" [issue #79813]: https://github.com/rust-lang/rust/issues/79813"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static SEMICOLON_IN_EXPRESSIONS_FROM_MACROS: &crate::Lint =
    &crate::Lint {
            name: "SEMICOLON_IN_EXPRESSIONS_FROM_MACROS",
            default_level: crate::Deny,
            desc: "trailing semicolon in macro body used as expression",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 79813,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
2925    /// The `semicolon_in_expressions_from_macros` lint detects trailing semicolons
2926    /// in macro bodies when the macro is invoked in expression position.
2927    /// This was previous accepted, but is being phased out.
2928    ///
2929    /// ### Example
2930    ///
2931    /// ```rust,compile_fail
2932    /// #![deny(semicolon_in_expressions_from_macros)]
2933    /// macro_rules! foo {
2934    ///     () => { true; }
2935    /// }
2936    ///
2937    /// fn main() {
2938    ///     let val = match true {
2939    ///         true => false,
2940    ///         _ => foo!()
2941    ///     };
2942    /// }
2943    /// ```
2944    ///
2945    /// {{produces}}
2946    ///
2947    /// ### Explanation
2948    ///
2949    /// Previous, Rust ignored trailing semicolon in a macro
2950    /// body when a macro was invoked in expression position.
2951    /// However, this makes the treatment of semicolons in the language
2952    /// inconsistent, and could lead to unexpected runtime behavior
2953    /// in some circumstances (e.g. if the macro author expects
2954    /// a value to be dropped).
2955    ///
2956    /// This is a [future-incompatible] lint to transition this
2957    /// to a hard error in the future. See [issue #79813] for more details.
2958    ///
2959    /// [issue #79813]: https://github.com/rust-lang/rust/issues/79813
2960    /// [future-incompatible]: ../index.md#future-incompatible-lints
2961    pub SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
2962    Deny,
2963    "trailing semicolon in macro body used as expression",
2964    @future_incompatible = FutureIncompatibleInfo {
2965        reason: fcw!(FutureReleaseError #79813),
2966        report_in_deps: true,
2967    };
2968}
2969
2970#[doc =
r" The `semicolon_in_expressions_from_non_local_macros` lint detects trailing semicolons in"]
#[doc =
r" macro bodies when the macro is invoked in expression position. This was previously accepted,"]
#[doc =
r" but is being phased out. This is similar to the `semicolon_in_expressions_from_macros` lint,"]
#[doc = r" but applies to macros expanded from a different crate."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs separate file)"]
#[doc = r" fn main() {"]
#[doc = r"     let val = match true {"]
#[doc = r"         true => false,"]
#[doc = r"         _ => example_separate_crate::foo!()"]
#[doc = r"     };"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" where the crate `example-separate-crate` contains:"]
#[doc = r""]
#[doc = r" ```rust,ignore (must be compiled as separate crate)"]
#[doc = r" #[macro_export]"]
#[doc = r" macro_rules! foo {"]
#[doc = r"     () => { true; }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" produces:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: trailing semicolon in macro used in expression position"]
#[doc = r"  --> src/main.rs:4:14"]
#[doc = r"   |"]
#[doc = r" 4 |         _ => example_separate_crate::foo!()"]
#[doc = r"   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r"   |"]
#[doc =
r"   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"   = note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>"]
#[doc =
r"   = note: `#[warn(semicolon_in_expressions_from_non_local_macros)]` (part of `#[warn(future_incompatible)]`) on by default"]
#[doc =
r"   = note: this warning originates in the macro `example_separate_crate::foo` (in Nightly builds, run with -Z macro-backtrace for more info)"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Previous, Rust ignored trailing semicolon in a macro"]
#[doc = r" body when a macro was invoked in expression position."]
#[doc = r" However, this makes the treatment of semicolons in the language"]
#[doc = r" inconsistent, and could lead to unexpected runtime behavior"]
#[doc = r" in some circumstances (e.g. if the macro author expects"]
#[doc = r" a value to be dropped)."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this"]
#[doc =
r" to a hard error in the future. See [issue #79813] for more details."]
#[doc = r""]
#[doc = r" [issue #79813]: https://github.com/rust-lang/rust/issues/79813"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static SEMICOLON_IN_EXPRESSIONS_FROM_NON_LOCAL_MACROS: &crate::Lint =
    &crate::Lint {
            name: "SEMICOLON_IN_EXPRESSIONS_FROM_NON_LOCAL_MACROS",
            default_level: crate::Warn,
            desc: "trailing semicolon in macro body used as expression",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 79813,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
2971    /// The `semicolon_in_expressions_from_non_local_macros` lint detects trailing semicolons in
2972    /// macro bodies when the macro is invoked in expression position. This was previously accepted,
2973    /// but is being phased out. This is similar to the `semicolon_in_expressions_from_macros` lint,
2974    /// but applies to macros expanded from a different crate.
2975    ///
2976    /// ### Example
2977    ///
2978    /// ```rust,ignore (needs separate file)
2979    /// fn main() {
2980    ///     let val = match true {
2981    ///         true => false,
2982    ///         _ => example_separate_crate::foo!()
2983    ///     };
2984    /// }
2985    /// ```
2986    ///
2987    /// where the crate `example-separate-crate` contains:
2988    ///
2989    /// ```rust,ignore (must be compiled as separate crate)
2990    /// #[macro_export]
2991    /// macro_rules! foo {
2992    ///     () => { true; }
2993    /// }
2994    /// ```
2995    ///
2996    /// produces:
2997    ///
2998    /// ```text
2999    /// warning: trailing semicolon in macro used in expression position
3000    ///  --> src/main.rs:4:14
3001    ///   |
3002    /// 4 |         _ => example_separate_crate::foo!()
3003    ///   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3004    ///   |
3005    ///   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
3006    ///   = note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
3007    ///   = note: `#[warn(semicolon_in_expressions_from_non_local_macros)]` (part of `#[warn(future_incompatible)]`) on by default
3008    ///   = note: this warning originates in the macro `example_separate_crate::foo` (in Nightly builds, run with -Z macro-backtrace for more info)
3009    /// ```
3010    ///
3011    /// ### Explanation
3012    ///
3013    /// Previous, Rust ignored trailing semicolon in a macro
3014    /// body when a macro was invoked in expression position.
3015    /// However, this makes the treatment of semicolons in the language
3016    /// inconsistent, and could lead to unexpected runtime behavior
3017    /// in some circumstances (e.g. if the macro author expects
3018    /// a value to be dropped).
3019    ///
3020    /// This is a [future-incompatible] lint to transition this
3021    /// to a hard error in the future. See [issue #79813] for more details.
3022    ///
3023    /// [issue #79813]: https://github.com/rust-lang/rust/issues/79813
3024    /// [future-incompatible]: ../index.md#future-incompatible-lints
3025    pub SEMICOLON_IN_EXPRESSIONS_FROM_NON_LOCAL_MACROS,
3026    Warn,
3027    "trailing semicolon in macro body used as expression",
3028    @future_incompatible = FutureIncompatibleInfo {
3029        reason: fcw!(FutureReleaseError #79813),
3030        report_in_deps: false,
3031    };
3032}
3033
3034#[doc = r" The `legacy_derive_helpers` lint detects derive helper attributes"]
#[doc = r" that are used before they are introduced."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs extern crate)"]
#[doc = r#" #[serde(rename_all = "camelCase")]"#]
#[doc = r" #[derive(Deserialize)]"]
#[doc = r" struct S { /* fields */ }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" produces:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: derive helper attribute is used before it is introduced"]
#[doc = r"   --> $DIR/legacy-derive-helpers.rs:1:3"]
#[doc = r"    |"]
#[doc = r#"  1 | #[serde(rename_all = "camelCase")]"#]
#[doc = r"    |   ^^^^^"]
#[doc = r" ..."]
#[doc = r"  2 | #[derive(Deserialize)]"]
#[doc = r"    |          ----------- the attribute is introduced here"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Attributes like this work for historical reasons, but attribute expansion works in"]
#[doc =
r#" left-to-right order in general, so, to resolve `#[serde]`, compiler has to try to "look"#]
#[doc =
r#" into the future" at not yet expanded part of the item , but such attempts are not always"#]
#[doc = r" reliable."]
#[doc = r""]
#[doc =
r" To fix the warning place the helper attribute after its corresponding derive."]
#[doc = r" ```rust,ignore (needs extern crate)"]
#[doc = r" #[derive(Deserialize)]"]
#[doc = r#" #[serde(rename_all = "camelCase")]"#]
#[doc = r" struct S { /* fields */ }"]
#[doc = r" ```"]
pub static LEGACY_DERIVE_HELPERS: &crate::Lint =
    &crate::Lint {
            name: "LEGACY_DERIVE_HELPERS",
            default_level: crate::Deny,
            desc: "detects derive helper attributes that are used before they are introduced",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 79202,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
3035    /// The `legacy_derive_helpers` lint detects derive helper attributes
3036    /// that are used before they are introduced.
3037    ///
3038    /// ### Example
3039    ///
3040    /// ```rust,ignore (needs extern crate)
3041    /// #[serde(rename_all = "camelCase")]
3042    /// #[derive(Deserialize)]
3043    /// struct S { /* fields */ }
3044    /// ```
3045    ///
3046    /// produces:
3047    ///
3048    /// ```text
3049    /// warning: derive helper attribute is used before it is introduced
3050    ///   --> $DIR/legacy-derive-helpers.rs:1:3
3051    ///    |
3052    ///  1 | #[serde(rename_all = "camelCase")]
3053    ///    |   ^^^^^
3054    /// ...
3055    ///  2 | #[derive(Deserialize)]
3056    ///    |          ----------- the attribute is introduced here
3057    /// ```
3058    ///
3059    /// ### Explanation
3060    ///
3061    /// Attributes like this work for historical reasons, but attribute expansion works in
3062    /// left-to-right order in general, so, to resolve `#[serde]`, compiler has to try to "look
3063    /// into the future" at not yet expanded part of the item , but such attempts are not always
3064    /// reliable.
3065    ///
3066    /// To fix the warning place the helper attribute after its corresponding derive.
3067    /// ```rust,ignore (needs extern crate)
3068    /// #[derive(Deserialize)]
3069    /// #[serde(rename_all = "camelCase")]
3070    /// struct S { /* fields */ }
3071    /// ```
3072    pub LEGACY_DERIVE_HELPERS,
3073    Deny,
3074    "detects derive helper attributes that are used before they are introduced",
3075    @future_incompatible = FutureIncompatibleInfo {
3076        reason: fcw!(FutureReleaseError #79202),
3077        report_in_deps: true,
3078    };
3079}
3080
3081#[doc = r" The `large_assignments` lint detects when objects of large"]
#[doc = r" types are being moved around."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (can crash on some platforms)"]
#[doc = r" let x = [0; 50000];"]
#[doc = r" let y = x;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" produces:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: moving a large value"]
#[doc = r"   --> $DIR/move-large.rs:1:3"]
#[doc = r"   let y = x;"]
#[doc = r"           - Copied large value here"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" When using a large type in a plain assignment or in a function"]
#[doc = r" argument, idiomatic code can be inefficient."]
#[doc = r" Ideally appropriate optimizations would resolve this, but such"]
#[doc = r" optimizations are only done in a best-effort manner."]
#[doc =
r" This lint will trigger on all sites of large moves and thus allow the"]
#[doc = r" user to resolve them in code."]
pub static LARGE_ASSIGNMENTS: &crate::Lint =
    &crate::Lint {
            name: "LARGE_ASSIGNMENTS",
            default_level: crate::Warn,
            desc: "detects large moves or copies",
            ..
        };declare_lint! {
3082    /// The `large_assignments` lint detects when objects of large
3083    /// types are being moved around.
3084    ///
3085    /// ### Example
3086    ///
3087    /// ```rust,ignore (can crash on some platforms)
3088    /// let x = [0; 50000];
3089    /// let y = x;
3090    /// ```
3091    ///
3092    /// produces:
3093    ///
3094    /// ```text
3095    /// warning: moving a large value
3096    ///   --> $DIR/move-large.rs:1:3
3097    ///   let y = x;
3098    ///           - Copied large value here
3099    /// ```
3100    ///
3101    /// ### Explanation
3102    ///
3103    /// When using a large type in a plain assignment or in a function
3104    /// argument, idiomatic code can be inefficient.
3105    /// Ideally appropriate optimizations would resolve this, but such
3106    /// optimizations are only done in a best-effort manner.
3107    /// This lint will trigger on all sites of large moves and thus allow the
3108    /// user to resolve them in code.
3109    pub LARGE_ASSIGNMENTS,
3110    Warn,
3111    "detects large moves or copies",
3112}
3113
3114#[doc =
r" The `unexpected_cfgs` lint detects unexpected conditional compilation conditions."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" rustc --check-cfg 'cfg()'"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs command line option)"]
#[doc = r" #[cfg(widnows)]"]
#[doc = r" fn foo() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: unexpected `cfg` condition name: `widnows`"]
#[doc = r"  --> lint_example.rs:1:7"]
#[doc = r"   |"]
#[doc = r" 1 | #[cfg(widnows)]"]
#[doc = r"   |       ^^^^^^^"]
#[doc = r"   |"]
#[doc = r"   = note: `#[warn(unexpected_cfgs)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This lint is only active when [`--check-cfg`][check-cfg] arguments are being"]
#[doc =
r" passed to the compiler and triggers whenever an unexpected condition name or value is"]
#[doc = r" used."]
#[doc = r""]
#[doc =
r" See the [Checking Conditional Configurations][check-cfg] section for more"]
#[doc = r" details."]
#[doc = r""]
#[doc =
r" See the [Cargo Specifics][unexpected_cfgs_lint_config] section for configuring this lint in"]
#[doc = r" `Cargo.toml`."]
#[doc = r""]
#[doc =
r" [check-cfg]: https://doc.rust-lang.org/nightly/rustc/check-cfg.html"]
#[doc =
r" [unexpected_cfgs_lint_config]: https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html#check-cfg-in-lintsrust-table"]
pub static UNEXPECTED_CFGS: &crate::Lint =
    &crate::Lint {
            name: "UNEXPECTED_CFGS",
            default_level: crate::Warn,
            desc: "detects unexpected names and values in `#[cfg]` conditions",
            report_in_external_macro: true,
            ..
        };declare_lint! {
3115    /// The `unexpected_cfgs` lint detects unexpected conditional compilation conditions.
3116    ///
3117    /// ### Example
3118    ///
3119    /// ```text
3120    /// rustc --check-cfg 'cfg()'
3121    /// ```
3122    ///
3123    /// ```rust,ignore (needs command line option)
3124    /// #[cfg(widnows)]
3125    /// fn foo() {}
3126    /// ```
3127    ///
3128    /// This will produce:
3129    ///
3130    /// ```text
3131    /// warning: unexpected `cfg` condition name: `widnows`
3132    ///  --> lint_example.rs:1:7
3133    ///   |
3134    /// 1 | #[cfg(widnows)]
3135    ///   |       ^^^^^^^
3136    ///   |
3137    ///   = note: `#[warn(unexpected_cfgs)]` on by default
3138    /// ```
3139    ///
3140    /// ### Explanation
3141    ///
3142    /// This lint is only active when [`--check-cfg`][check-cfg] arguments are being
3143    /// passed to the compiler and triggers whenever an unexpected condition name or value is
3144    /// used.
3145    ///
3146    /// See the [Checking Conditional Configurations][check-cfg] section for more
3147    /// details.
3148    ///
3149    /// See the [Cargo Specifics][unexpected_cfgs_lint_config] section for configuring this lint in
3150    /// `Cargo.toml`.
3151    ///
3152    /// [check-cfg]: https://doc.rust-lang.org/nightly/rustc/check-cfg.html
3153    /// [unexpected_cfgs_lint_config]: https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html#check-cfg-in-lintsrust-table
3154    pub UNEXPECTED_CFGS,
3155    Warn,
3156    "detects unexpected names and values in `#[cfg]` conditions",
3157    report_in_external_macro
3158}
3159
3160#[doc =
r" The `explicit_builtin_cfgs_in_flags` lint detects builtin cfgs set via the `--cfg` flag."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" rustc --cfg unix"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs command line option)"]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" error: unexpected `--cfg unix` flag"]
#[doc = r"   |"]
#[doc =
r"   = note: config `unix` is only supposed to be controlled by `--target`"]
#[doc =
r"   = note: manually setting a built-in cfg can and does create incoherent behaviors"]
#[doc = r"   = note: `#[deny(explicit_builtin_cfgs_in_flags)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Setting builtin cfgs can and does produce incoherent behavior, it's better to the use"]
#[doc =
r" the appropriate `rustc` flag that controls the config. For example setting the `windows`"]
#[doc = r" cfg but on Linux based target."]
pub static EXPLICIT_BUILTIN_CFGS_IN_FLAGS: &crate::Lint =
    &crate::Lint {
            name: "EXPLICIT_BUILTIN_CFGS_IN_FLAGS",
            default_level: crate::Deny,
            desc: "detects builtin cfgs set via the `--cfg`",
            ..
        };declare_lint! {
3161    /// The `explicit_builtin_cfgs_in_flags` lint detects builtin cfgs set via the `--cfg` flag.
3162    ///
3163    /// ### Example
3164    ///
3165    /// ```text
3166    /// rustc --cfg unix
3167    /// ```
3168    ///
3169    /// ```rust,ignore (needs command line option)
3170    /// fn main() {}
3171    /// ```
3172    ///
3173    /// This will produce:
3174    ///
3175    /// ```text
3176    /// error: unexpected `--cfg unix` flag
3177    ///   |
3178    ///   = note: config `unix` is only supposed to be controlled by `--target`
3179    ///   = note: manually setting a built-in cfg can and does create incoherent behaviors
3180    ///   = note: `#[deny(explicit_builtin_cfgs_in_flags)]` on by default
3181    /// ```
3182    ///
3183    /// ### Explanation
3184    ///
3185    /// Setting builtin cfgs can and does produce incoherent behavior, it's better to the use
3186    /// the appropriate `rustc` flag that controls the config. For example setting the `windows`
3187    /// cfg but on Linux based target.
3188    pub EXPLICIT_BUILTIN_CFGS_IN_FLAGS,
3189    Deny,
3190    "detects builtin cfgs set via the `--cfg`"
3191}
3192
3193#[doc =
r" The `unstable_syntax_pre_expansion` lint detects the use of unstable"]
#[doc = r" syntax that is discarded during attribute expansion."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r#" #[cfg(feature = "nightly")]"#]
#[doc = r" macro foo() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The input to active attributes such as `#[cfg]` or procedural macro"]
#[doc =
r" attributes is required to be valid syntax. Previously, the compiler only"]
#[doc =
r" gated the use of unstable syntax features after resolving `#[cfg]` gates"]
#[doc = r" and expanding procedural macros."]
#[doc = r""]
#[doc =
r" To avoid relying on unstable syntax, move the use of unstable syntax"]
#[doc =
r" into a position where the compiler does not parse the syntax, such as a"]
#[doc = r" functionlike macro."]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" # #![deny(unstable_syntax_pre_expansion)]"]
#[doc = r""]
#[doc = r" macro_rules! identity {"]
#[doc = r"    ( $($tokens:tt)* ) => { $($tokens)* }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r#" #[cfg(feature = "nightly")]"#]
#[doc = r" identity! {"]
#[doc = r"    macro foo() {}"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this"]
#[doc =
r" to a hard error in the future. See [issue #154045] for more details."]
#[doc = r""]
#[doc = r" [issue #154045]: https://github.com/rust-lang/rust/issues/154045"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static UNSTABLE_SYNTAX_PRE_EXPANSION: &crate::Lint =
    &crate::Lint {
            name: "UNSTABLE_SYNTAX_PRE_EXPANSION",
            default_level: crate::Warn,
            desc: "unstable syntax can change at any point in the future, causing a hard error!",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 154045,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
3194    /// The `unstable_syntax_pre_expansion` lint detects the use of unstable
3195    /// syntax that is discarded during attribute expansion.
3196    ///
3197    /// ### Example
3198    ///
3199    /// ```rust
3200    /// #[cfg(feature = "nightly")]
3201    /// macro foo() {}
3202    /// ```
3203    ///
3204    /// {{produces}}
3205    ///
3206    /// ### Explanation
3207    ///
3208    /// The input to active attributes such as `#[cfg]` or procedural macro
3209    /// attributes is required to be valid syntax. Previously, the compiler only
3210    /// gated the use of unstable syntax features after resolving `#[cfg]` gates
3211    /// and expanding procedural macros.
3212    ///
3213    /// To avoid relying on unstable syntax, move the use of unstable syntax
3214    /// into a position where the compiler does not parse the syntax, such as a
3215    /// functionlike macro.
3216    ///
3217    /// ```rust
3218    /// # #![deny(unstable_syntax_pre_expansion)]
3219    ///
3220    /// macro_rules! identity {
3221    ///    ( $($tokens:tt)* ) => { $($tokens)* }
3222    /// }
3223    ///
3224    /// #[cfg(feature = "nightly")]
3225    /// identity! {
3226    ///    macro foo() {}
3227    /// }
3228    /// ```
3229    ///
3230    /// This is a [future-incompatible] lint to transition this
3231    /// to a hard error in the future. See [issue #154045] for more details.
3232    ///
3233    /// [issue #154045]: https://github.com/rust-lang/rust/issues/154045
3234    /// [future-incompatible]: ../index.md#future-incompatible-lints
3235    pub UNSTABLE_SYNTAX_PRE_EXPANSION,
3236    Warn,
3237    "unstable syntax can change at any point in the future, causing a hard error!",
3238    @future_incompatible = FutureIncompatibleInfo {
3239        reason: fcw!(FutureReleaseError #154045),
3240    };
3241}
3242
3243#[doc =
r" The `ambiguous_glob_reexports` lint detects cases where names re-exported via globs"]
#[doc =
r" collide. Downstream users trying to use the same name re-exported from multiple globs"]
#[doc =
r" will receive a warning pointing out redefinition of the same name."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(ambiguous_glob_reexports)]"]
#[doc = r" pub mod foo {"]
#[doc = r"     pub type X = u8;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" pub mod bar {"]
#[doc = r"     pub type Y = u8;"]
#[doc = r"     pub type X = u8;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" pub use foo::*;"]
#[doc = r" pub use bar::*;"]
#[doc = r""]
#[doc = r""]
#[doc = r" pub fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This was previously accepted but it could silently break a crate's downstream users code."]
#[doc =
r" For example, if `foo::*` and `bar::*` were re-exported before `bar::X` was added to the"]
#[doc =
r" re-exports, down stream users could use `this_crate::X` without problems. However, adding"]
#[doc =
r" `bar::X` would cause compilation errors in downstream crates because `X` is defined"]
#[doc = r" multiple times in the same namespace of `this_crate`."]
pub static AMBIGUOUS_GLOB_REEXPORTS: &crate::Lint =
    &crate::Lint {
            name: "AMBIGUOUS_GLOB_REEXPORTS",
            default_level: crate::Warn,
            desc: "ambiguous glob re-exports",
            ..
        };declare_lint! {
3244    /// The `ambiguous_glob_reexports` lint detects cases where names re-exported via globs
3245    /// collide. Downstream users trying to use the same name re-exported from multiple globs
3246    /// will receive a warning pointing out redefinition of the same name.
3247    ///
3248    /// ### Example
3249    ///
3250    /// ```rust,compile_fail
3251    /// #![deny(ambiguous_glob_reexports)]
3252    /// pub mod foo {
3253    ///     pub type X = u8;
3254    /// }
3255    ///
3256    /// pub mod bar {
3257    ///     pub type Y = u8;
3258    ///     pub type X = u8;
3259    /// }
3260    ///
3261    /// pub use foo::*;
3262    /// pub use bar::*;
3263    ///
3264    ///
3265    /// pub fn main() {}
3266    /// ```
3267    ///
3268    /// {{produces}}
3269    ///
3270    /// ### Explanation
3271    ///
3272    /// This was previously accepted but it could silently break a crate's downstream users code.
3273    /// For example, if `foo::*` and `bar::*` were re-exported before `bar::X` was added to the
3274    /// re-exports, down stream users could use `this_crate::X` without problems. However, adding
3275    /// `bar::X` would cause compilation errors in downstream crates because `X` is defined
3276    /// multiple times in the same namespace of `this_crate`.
3277    pub AMBIGUOUS_GLOB_REEXPORTS,
3278    Warn,
3279    "ambiguous glob re-exports",
3280}
3281
3282#[doc =
r" The `hidden_glob_reexports` lint detects cases where glob re-export items are shadowed by"]
#[doc = r" private items."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(hidden_glob_reexports)]"]
#[doc = r""]
#[doc = r" pub mod upstream {"]
#[doc = r"     mod inner { pub struct Foo {}; pub struct Bar {}; }"]
#[doc = r"     pub use self::inner::*;"]
#[doc = r"     struct Foo {} // private item shadows `inner::Foo`"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" // mod downstream {"]
#[doc = r" //     fn test() {"]
#[doc = r" //         let _ = crate::upstream::Foo; // inaccessible"]
#[doc = r" //     }"]
#[doc = r" // }"]
#[doc = r""]
#[doc = r" pub fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This was previously accepted without any errors or warnings but it could silently break a"]
#[doc =
r" crate's downstream user code. If the `struct Foo` was added, `dep::inner::Foo` would"]
#[doc =
r#" silently become inaccessible and trigger a "`struct `Foo` is private`" visibility error at"#]
#[doc = r" the downstream use site."]
pub static HIDDEN_GLOB_REEXPORTS: &crate::Lint =
    &crate::Lint {
            name: "HIDDEN_GLOB_REEXPORTS",
            default_level: crate::Warn,
            desc: "name introduced by a private item shadows a name introduced by a public glob re-export",
            ..
        };declare_lint! {
3283    /// The `hidden_glob_reexports` lint detects cases where glob re-export items are shadowed by
3284    /// private items.
3285    ///
3286    /// ### Example
3287    ///
3288    /// ```rust,compile_fail
3289    /// #![deny(hidden_glob_reexports)]
3290    ///
3291    /// pub mod upstream {
3292    ///     mod inner { pub struct Foo {}; pub struct Bar {}; }
3293    ///     pub use self::inner::*;
3294    ///     struct Foo {} // private item shadows `inner::Foo`
3295    /// }
3296    ///
3297    /// // mod downstream {
3298    /// //     fn test() {
3299    /// //         let _ = crate::upstream::Foo; // inaccessible
3300    /// //     }
3301    /// // }
3302    ///
3303    /// pub fn main() {}
3304    /// ```
3305    ///
3306    /// {{produces}}
3307    ///
3308    /// ### Explanation
3309    ///
3310    /// This was previously accepted without any errors or warnings but it could silently break a
3311    /// crate's downstream user code. If the `struct Foo` was added, `dep::inner::Foo` would
3312    /// silently become inaccessible and trigger a "`struct `Foo` is private`" visibility error at
3313    /// the downstream use site.
3314    pub HIDDEN_GLOB_REEXPORTS,
3315    Warn,
3316    "name introduced by a private item shadows a name introduced by a public glob re-export",
3317}
3318
3319#[doc = r" The `long_running_const_eval` lint is emitted when const"]
#[doc = r" eval is running for a long time to ensure rustc terminates"]
#[doc = r" even if you accidentally wrote an infinite loop."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" const FOO: () = loop {};"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Loops allow const evaluation to compute arbitrary code, but may also"]
#[doc = r" cause infinite loops or just very long running computations."]
#[doc = r" Users can enable long running computations by allowing the lint"]
#[doc = r" on individual constants or for entire crates."]
#[doc = r""]
#[doc = r" ### Unconditional warnings"]
#[doc = r""]
#[doc =
r" Note that regardless of whether the lint is allowed or set to warn,"]
#[doc =
r" the compiler will issue warnings if constant evaluation runs significantly"]
#[doc =
r" longer than this lint's limit. These warnings are also shown to downstream"]
#[doc =
r" users from crates.io or similar registries. If you are above the lint's limit,"]
#[doc = r" both you and downstream users might be exposed to these warnings."]
#[doc =
r" They might also appear on compiler updates, as the compiler makes minor changes"]
#[doc =
r" about how complexity is measured: staying below the limit ensures that there"]
#[doc =
r" is enough room, and given that the lint is disabled for people who use your"]
#[doc =
r" dependency it means you will be the only one to get the warning and can put"]
#[doc = r" out an update in your own time."]
pub static LONG_RUNNING_CONST_EVAL: &crate::Lint =
    &crate::Lint {
            name: "LONG_RUNNING_CONST_EVAL",
            default_level: crate::Deny,
            desc: "detects long const eval operations",
            report_in_external_macro: true,
            ..
        };declare_lint! {
3320    /// The `long_running_const_eval` lint is emitted when const
3321    /// eval is running for a long time to ensure rustc terminates
3322    /// even if you accidentally wrote an infinite loop.
3323    ///
3324    /// ### Example
3325    ///
3326    /// ```rust,compile_fail
3327    /// const FOO: () = loop {};
3328    /// ```
3329    ///
3330    /// {{produces}}
3331    ///
3332    /// ### Explanation
3333    ///
3334    /// Loops allow const evaluation to compute arbitrary code, but may also
3335    /// cause infinite loops or just very long running computations.
3336    /// Users can enable long running computations by allowing the lint
3337    /// on individual constants or for entire crates.
3338    ///
3339    /// ### Unconditional warnings
3340    ///
3341    /// Note that regardless of whether the lint is allowed or set to warn,
3342    /// the compiler will issue warnings if constant evaluation runs significantly
3343    /// longer than this lint's limit. These warnings are also shown to downstream
3344    /// users from crates.io or similar registries. If you are above the lint's limit,
3345    /// both you and downstream users might be exposed to these warnings.
3346    /// They might also appear on compiler updates, as the compiler makes minor changes
3347    /// about how complexity is measured: staying below the limit ensures that there
3348    /// is enough room, and given that the lint is disabled for people who use your
3349    /// dependency it means you will be the only one to get the warning and can put
3350    /// out an update in your own time.
3351    pub LONG_RUNNING_CONST_EVAL,
3352    Deny,
3353    "detects long const eval operations",
3354    report_in_external_macro
3355}
3356
3357#[doc = r" The `unused_associated_type_bounds` lint is emitted when an"]
#[doc =
r" associated type bound is added to a trait object, but the associated"]
#[doc =
r" type has a `where Self: Sized` bound, and is thus unavailable on the"]
#[doc = r" trait object anyway."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" trait Foo {"]
#[doc = r"     type Bar where Self: Sized;"]
#[doc = r" }"]
#[doc = r" type Mop = dyn Foo<Bar = ()>;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Just like methods with `Self: Sized` bounds are unavailable on trait"]
#[doc = r" objects, associated types can be removed from the trait object."]
pub static UNUSED_ASSOCIATED_TYPE_BOUNDS: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_ASSOCIATED_TYPE_BOUNDS",
            default_level: crate::Warn,
            desc: "detects unused `Foo = Bar` bounds in `dyn Trait<Foo = Bar>`",
            ..
        };declare_lint! {
3358    /// The `unused_associated_type_bounds` lint is emitted when an
3359    /// associated type bound is added to a trait object, but the associated
3360    /// type has a `where Self: Sized` bound, and is thus unavailable on the
3361    /// trait object anyway.
3362    ///
3363    /// ### Example
3364    ///
3365    /// ```rust
3366    /// trait Foo {
3367    ///     type Bar where Self: Sized;
3368    /// }
3369    /// type Mop = dyn Foo<Bar = ()>;
3370    /// ```
3371    ///
3372    /// {{produces}}
3373    ///
3374    /// ### Explanation
3375    ///
3376    /// Just like methods with `Self: Sized` bounds are unavailable on trait
3377    /// objects, associated types can be removed from the trait object.
3378    pub UNUSED_ASSOCIATED_TYPE_BOUNDS,
3379    Warn,
3380    "detects unused `Foo = Bar` bounds in `dyn Trait<Foo = Bar>`"
3381}
3382
3383#[doc =
r" The `unused_doc_comments` lint detects doc comments that aren't used"]
#[doc = r" by `rustdoc`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" /// docs for x"]
#[doc = r" let x = 12;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" `rustdoc` does not use doc comments in all positions, and so the doc"]
#[doc =
r" comment will be ignored. Try changing it to a normal comment with `//`"]
#[doc = r" to avoid the warning."]
pub static UNUSED_DOC_COMMENTS: &crate::Lint =
    &crate::Lint {
            name: "UNUSED_DOC_COMMENTS",
            default_level: crate::Warn,
            desc: "detects doc comments that aren't used by rustdoc",
            ..
        };declare_lint! {
3384    /// The `unused_doc_comments` lint detects doc comments that aren't used
3385    /// by `rustdoc`.
3386    ///
3387    /// ### Example
3388    ///
3389    /// ```rust
3390    /// /// docs for x
3391    /// let x = 12;
3392    /// ```
3393    ///
3394    /// {{produces}}
3395    ///
3396    /// ### Explanation
3397    ///
3398    /// `rustdoc` does not use doc comments in all positions, and so the doc
3399    /// comment will be ignored. Try changing it to a normal comment with `//`
3400    /// to avoid the warning.
3401    pub UNUSED_DOC_COMMENTS,
3402    Warn,
3403    "detects doc comments that aren't used by rustdoc"
3404}
3405
3406#[doc =
r" The `rust_2021_incompatible_closure_captures` lint detects variables that aren't completely"]
#[doc =
r" captured in Rust 2021, such that the `Drop` order of their fields may differ between"]
#[doc = r" Rust 2018 and 2021."]
#[doc = r""]
#[doc =
r" It can also detect when a variable implements a trait like `Send`, but one of its fields does not,"]
#[doc =
r" and the field is captured by a closure and used with the assumption that said field implements"]
#[doc = r" the same trait as the root variable."]
#[doc = r""]
#[doc = r" ### Example of drop reorder"]
#[doc = r""]
#[doc = r" ```rust,edition2018,compile_fail"]
#[doc = r" #![deny(rust_2021_incompatible_closure_captures)]"]
#[doc = r" # #![allow(unused)]"]
#[doc = r""]
#[doc = r" struct FancyInteger(i32);"]
#[doc = r""]
#[doc = r" impl Drop for FancyInteger {"]
#[doc = r"     fn drop(&mut self) {"]
#[doc = r#"         println!("Just dropped {}", self.0);"#]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" struct Point { x: FancyInteger, y: FancyInteger }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"   let p = Point { x: FancyInteger(10), y: FancyInteger(20) };"]
#[doc = r""]
#[doc = r"   let c = || {"]
#[doc = r"      let x = p.x;"]
#[doc = r"   };"]
#[doc = r""]
#[doc = r"   c();"]
#[doc = r""]
#[doc = r"   // ... More code ..."]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In the above example, `p.y` will be dropped at the end of `f` instead of"]
#[doc = r" with `c` in Rust 2021."]
#[doc = r""]
#[doc = r" ### Example of auto-trait"]
#[doc = r""]
#[doc = r" ```rust,edition2018,compile_fail"]
#[doc = r" #![deny(rust_2021_incompatible_closure_captures)]"]
#[doc = r" use std::thread;"]
#[doc = r""]
#[doc = r" struct Pointer(*mut i32);"]
#[doc = r" unsafe impl Send for Pointer {}"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     let mut f = 10;"]
#[doc = r"     let fptr = Pointer(&mut f as *mut i32);"]
#[doc = r"     thread::spawn(move || unsafe {"]
#[doc = r"         *fptr.0 = 20;"]
#[doc = r"     });"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" In the above example, only `fptr.0` is captured in Rust 2021."]
#[doc = r" The field is of type `*mut i32`, which doesn't implement `Send`,"]
#[doc =
r" making the code invalid as the field cannot be sent between threads safely."]
pub static RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES: &crate::Lint =
    &crate::Lint {
            name: "RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES",
            default_level: crate::Allow,
            desc: "detects closures affected by Rust 2021 changes",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionSemanticsChange(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2021,
                            page_slug: "disjoint-capture-in-closures",
                        }),
                    explain_reason: false,
                    ..
                }),
            ..
        };declare_lint! {
3407    /// The `rust_2021_incompatible_closure_captures` lint detects variables that aren't completely
3408    /// captured in Rust 2021, such that the `Drop` order of their fields may differ between
3409    /// Rust 2018 and 2021.
3410    ///
3411    /// It can also detect when a variable implements a trait like `Send`, but one of its fields does not,
3412    /// and the field is captured by a closure and used with the assumption that said field implements
3413    /// the same trait as the root variable.
3414    ///
3415    /// ### Example of drop reorder
3416    ///
3417    /// ```rust,edition2018,compile_fail
3418    /// #![deny(rust_2021_incompatible_closure_captures)]
3419    /// # #![allow(unused)]
3420    ///
3421    /// struct FancyInteger(i32);
3422    ///
3423    /// impl Drop for FancyInteger {
3424    ///     fn drop(&mut self) {
3425    ///         println!("Just dropped {}", self.0);
3426    ///     }
3427    /// }
3428    ///
3429    /// struct Point { x: FancyInteger, y: FancyInteger }
3430    ///
3431    /// fn main() {
3432    ///   let p = Point { x: FancyInteger(10), y: FancyInteger(20) };
3433    ///
3434    ///   let c = || {
3435    ///      let x = p.x;
3436    ///   };
3437    ///
3438    ///   c();
3439    ///
3440    ///   // ... More code ...
3441    /// }
3442    /// ```
3443    ///
3444    /// {{produces}}
3445    ///
3446    /// ### Explanation
3447    ///
3448    /// In the above example, `p.y` will be dropped at the end of `f` instead of
3449    /// with `c` in Rust 2021.
3450    ///
3451    /// ### Example of auto-trait
3452    ///
3453    /// ```rust,edition2018,compile_fail
3454    /// #![deny(rust_2021_incompatible_closure_captures)]
3455    /// use std::thread;
3456    ///
3457    /// struct Pointer(*mut i32);
3458    /// unsafe impl Send for Pointer {}
3459    ///
3460    /// fn main() {
3461    ///     let mut f = 10;
3462    ///     let fptr = Pointer(&mut f as *mut i32);
3463    ///     thread::spawn(move || unsafe {
3464    ///         *fptr.0 = 20;
3465    ///     });
3466    /// }
3467    /// ```
3468    ///
3469    /// {{produces}}
3470    ///
3471    /// ### Explanation
3472    ///
3473    /// In the above example, only `fptr.0` is captured in Rust 2021.
3474    /// The field is of type `*mut i32`, which doesn't implement `Send`,
3475    /// making the code invalid as the field cannot be sent between threads safely.
3476    pub RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
3477    Allow,
3478    "detects closures affected by Rust 2021 changes",
3479    @future_incompatible = FutureIncompatibleInfo {
3480        reason: fcw!(EditionSemanticsChange 2021 "disjoint-capture-in-closures"),
3481        explain_reason: false,
3482    };
3483}
3484
3485pub struct UnusedDocComment;
#[automatically_derived]impl ::core::marker::Copy for UnusedDocComment { }
#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for UnusedDocComment {
}
#[automatically_derived]impl ::core::clone::Clone for UnusedDocComment {
    #[inline]
    #[rustc_trivial_field_reads]
    fn clone(&self) -> Self { *self }
}
impl crate::LintPass for UnusedDocComment {
    fn name(&self) -> &'static str { "UnusedDocComment" }
    fn get_lints(&self) -> crate::LintVec {
        ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
                [UNUSED_DOC_COMMENTS]))
    }
}
impl UnusedDocComment {
    #[allow(unused)]
    pub fn lint_vec() -> crate::LintVec {
        ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
                [UNUSED_DOC_COMMENTS]))
    }
}declare_lint_pass!(UnusedDocComment => [UNUSED_DOC_COMMENTS]);
3486
3487#[doc =
r" The `missing_abi` lint detects cases where the ABI is omitted from"]
#[doc = r" `extern` declarations."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(missing_abi)]"]
#[doc = r""]
#[doc = r" extern fn foo() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" For historic reasons, Rust implicitly selects `C` as the default ABI for"]
#[doc =
r" `extern` declarations. [Other ABIs] like `C-unwind` and `system` have"]
#[doc =
r" been added since then, and especially with their addition seeing the ABI"]
#[doc = r" easily makes code review easier."]
#[doc = r""]
#[doc =
r" [Other ABIs]: https://doc.rust-lang.org/reference/items/external-blocks.html#abi"]
pub static MISSING_ABI: &crate::Lint =
    &crate::Lint {
            name: "MISSING_ABI",
            default_level: crate::Warn,
            desc: "No declared ABI for extern declaration",
            ..
        };declare_lint! {
3488    /// The `missing_abi` lint detects cases where the ABI is omitted from
3489    /// `extern` declarations.
3490    ///
3491    /// ### Example
3492    ///
3493    /// ```rust,compile_fail
3494    /// #![deny(missing_abi)]
3495    ///
3496    /// extern fn foo() {}
3497    /// ```
3498    ///
3499    /// {{produces}}
3500    ///
3501    /// ### Explanation
3502    ///
3503    /// For historic reasons, Rust implicitly selects `C` as the default ABI for
3504    /// `extern` declarations. [Other ABIs] like `C-unwind` and `system` have
3505    /// been added since then, and especially with their addition seeing the ABI
3506    /// easily makes code review easier.
3507    ///
3508    /// [Other ABIs]: https://doc.rust-lang.org/reference/items/external-blocks.html#abi
3509    pub MISSING_ABI,
3510    Warn,
3511    "No declared ABI for extern declaration"
3512}
3513
3514#[doc =
r" The `invalid_doc_attributes` lint detects when the `#[doc(...)]` is"]
#[doc = r" misused."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(warnings)]"]
#[doc = r""]
#[doc = r" pub mod submodule {"]
#[doc = r"     #![doc(test(no_crate_inject))]"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Previously, incorrect usage of the `#[doc(..)]` attribute was not"]
#[doc =
r" being validated. Usually these should be rejected as a hard error,"]
#[doc = r" but this lint was introduced to avoid breaking any existing"]
#[doc = r" crates which included them."]
pub static INVALID_DOC_ATTRIBUTES: &crate::Lint =
    &crate::Lint {
            name: "INVALID_DOC_ATTRIBUTES",
            default_level: crate::Warn,
            desc: "detects invalid `#[doc(...)]` attributes",
            ..
        };declare_lint! {
3515    /// The `invalid_doc_attributes` lint detects when the `#[doc(...)]` is
3516    /// misused.
3517    ///
3518    /// ### Example
3519    ///
3520    /// ```rust,compile_fail
3521    /// #![deny(warnings)]
3522    ///
3523    /// pub mod submodule {
3524    ///     #![doc(test(no_crate_inject))]
3525    /// }
3526    /// ```
3527    ///
3528    /// {{produces}}
3529    ///
3530    /// ### Explanation
3531    ///
3532    /// Previously, incorrect usage of the `#[doc(..)]` attribute was not
3533    /// being validated. Usually these should be rejected as a hard error,
3534    /// but this lint was introduced to avoid breaking any existing
3535    /// crates which included them.
3536    pub INVALID_DOC_ATTRIBUTES,
3537    Warn,
3538    "detects invalid `#[doc(...)]` attributes",
3539}
3540
3541#[doc =
r" The `rust_2021_incompatible_or_patterns` lint detects usage of old versions of or-patterns."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2018,compile_fail"]
#[doc = r" #![deny(rust_2021_incompatible_or_patterns)]"]
#[doc = r""]
#[doc = r" macro_rules! match_any {"]
#[doc =
r"     ( $expr:expr , $( $( $pat:pat )|+ => $expr_arm:expr ),+ ) => {"]
#[doc = r"         match $expr {"]
#[doc = r"             $("]
#[doc = r"                 $( $pat => $expr_arm, )+"]
#[doc = r"             )+"]
#[doc = r"         }"]
#[doc = r"     };"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     let result: Result<i64, i32> = Err(42);"]
#[doc =
r"     let int: i64 = match_any!(result, Ok(i) | Err(i) => i.into());"]
#[doc = r"     assert_eq!(int, 42);"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In Rust 2021, the `pat` matcher will match additional patterns, which include the `|` character."]
pub static RUST_2021_INCOMPATIBLE_OR_PATTERNS: &crate::Lint =
    &crate::Lint {
            name: "RUST_2021_INCOMPATIBLE_OR_PATTERNS",
            default_level: crate::Allow,
            desc: "detects usage of old versions of or-patterns",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2021,
                            page_slug: "or-patterns-macro-rules",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
3542    /// The `rust_2021_incompatible_or_patterns` lint detects usage of old versions of or-patterns.
3543    ///
3544    /// ### Example
3545    ///
3546    /// ```rust,edition2018,compile_fail
3547    /// #![deny(rust_2021_incompatible_or_patterns)]
3548    ///
3549    /// macro_rules! match_any {
3550    ///     ( $expr:expr , $( $( $pat:pat )|+ => $expr_arm:expr ),+ ) => {
3551    ///         match $expr {
3552    ///             $(
3553    ///                 $( $pat => $expr_arm, )+
3554    ///             )+
3555    ///         }
3556    ///     };
3557    /// }
3558    ///
3559    /// fn main() {
3560    ///     let result: Result<i64, i32> = Err(42);
3561    ///     let int: i64 = match_any!(result, Ok(i) | Err(i) => i.into());
3562    ///     assert_eq!(int, 42);
3563    /// }
3564    /// ```
3565    ///
3566    /// {{produces}}
3567    ///
3568    /// ### Explanation
3569    ///
3570    /// In Rust 2021, the `pat` matcher will match additional patterns, which include the `|` character.
3571    pub RUST_2021_INCOMPATIBLE_OR_PATTERNS,
3572    Allow,
3573    "detects usage of old versions of or-patterns",
3574    @future_incompatible = FutureIncompatibleInfo {
3575        reason: fcw!(EditionError 2021 "or-patterns-macro-rules"),
3576    };
3577}
3578
3579#[doc =
r" The `rust_2021_prelude_collisions` lint detects the usage of trait methods which are ambiguous"]
#[doc = r" with traits added to the prelude in future editions."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2018,compile_fail"]
#[doc = r" #![deny(rust_2021_prelude_collisions)]"]
#[doc = r""]
#[doc = r" trait Foo {"]
#[doc = r"     fn try_into(self) -> Result<String, !>;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl Foo for &str {"]
#[doc = r"     fn try_into(self) -> Result<String, !> {"]
#[doc = r"         Ok(String::from(self))"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r#"     let x: String = "3".try_into().unwrap();"#]
#[doc = r"     //                  ^^^^^^^^"]
#[doc =
r"     // This call to try_into matches both Foo::try_into and TryInto::try_into as"]
#[doc =
r"     // `TryInto` has been added to the Rust prelude in 2021 edition."]
#[doc = r#"     println!("{x}");"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In Rust 2021, one of the important introductions is the [prelude changes], which add"]
#[doc =
r" `TryFrom`, `TryInto`, and `FromIterator` into the standard library's prelude. Since this"]
#[doc =
r" results in an ambiguity as to which method/function to call when an existing `try_into`"]
#[doc =
r" method is called via dot-call syntax or a `try_from`/`from_iter` associated function"]
#[doc = r" is called directly on a type."]
#[doc = r""]
#[doc =
r" [prelude changes]: https://blog.rust-lang.org/inside-rust/2021/03/04/planning-rust-2021.html#prelude-changes"]
pub static RUST_2021_PRELUDE_COLLISIONS: &crate::Lint =
    &crate::Lint {
            name: "RUST_2021_PRELUDE_COLLISIONS",
            default_level: crate::Allow,
            desc: "detects the usage of trait methods which are ambiguous with traits added to the \
        prelude in future editions",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2021,
                            page_slug: "prelude",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
3580    /// The `rust_2021_prelude_collisions` lint detects the usage of trait methods which are ambiguous
3581    /// with traits added to the prelude in future editions.
3582    ///
3583    /// ### Example
3584    ///
3585    /// ```rust,edition2018,compile_fail
3586    /// #![deny(rust_2021_prelude_collisions)]
3587    ///
3588    /// trait Foo {
3589    ///     fn try_into(self) -> Result<String, !>;
3590    /// }
3591    ///
3592    /// impl Foo for &str {
3593    ///     fn try_into(self) -> Result<String, !> {
3594    ///         Ok(String::from(self))
3595    ///     }
3596    /// }
3597    ///
3598    /// fn main() {
3599    ///     let x: String = "3".try_into().unwrap();
3600    ///     //                  ^^^^^^^^
3601    ///     // This call to try_into matches both Foo::try_into and TryInto::try_into as
3602    ///     // `TryInto` has been added to the Rust prelude in 2021 edition.
3603    ///     println!("{x}");
3604    /// }
3605    /// ```
3606    ///
3607    /// {{produces}}
3608    ///
3609    /// ### Explanation
3610    ///
3611    /// In Rust 2021, one of the important introductions is the [prelude changes], which add
3612    /// `TryFrom`, `TryInto`, and `FromIterator` into the standard library's prelude. Since this
3613    /// results in an ambiguity as to which method/function to call when an existing `try_into`
3614    /// method is called via dot-call syntax or a `try_from`/`from_iter` associated function
3615    /// is called directly on a type.
3616    ///
3617    /// [prelude changes]: https://blog.rust-lang.org/inside-rust/2021/03/04/planning-rust-2021.html#prelude-changes
3618    pub RUST_2021_PRELUDE_COLLISIONS,
3619    Allow,
3620    "detects the usage of trait methods which are ambiguous with traits added to the \
3621        prelude in future editions",
3622    @future_incompatible = FutureIncompatibleInfo {
3623        reason: fcw!(EditionError 2021 "prelude"),
3624    };
3625}
3626
3627#[doc =
r" The `rust_2024_prelude_collisions` lint detects the usage of trait methods which are ambiguous"]
#[doc = r" with traits added to the prelude in future editions."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2021,compile_fail"]
#[doc = r" #![deny(rust_2024_prelude_collisions)]"]
#[doc = r" trait Meow {"]
#[doc = r"     fn poll(&self) {}"]
#[doc = r" }"]
#[doc = r" impl<T> Meow for T {}"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     core::pin::pin!(async {}).poll();"]
#[doc = r"     //                        ^^^^^^"]
#[doc =
r"     // This call to try_into matches both Future::poll and Meow::poll as"]
#[doc =
r"     // `Future` has been added to the Rust prelude in 2024 edition."]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Rust 2024, introduces two new additions to the standard library's prelude:"]
#[doc =
r" `Future` and `IntoFuture`. This results in an ambiguity as to which method/function"]
#[doc =
r" to call when an existing `poll`/`into_future` method is called via dot-call syntax or"]
#[doc =
r" a `poll`/`into_future` associated function is called directly on a type."]
#[doc = r""]
pub static RUST_2024_PRELUDE_COLLISIONS: &crate::Lint =
    &crate::Lint {
            name: "RUST_2024_PRELUDE_COLLISIONS",
            default_level: crate::Allow,
            desc: "detects the usage of trait methods which are ambiguous with traits added to the \
        prelude in future editions",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "prelude",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
3628    /// The `rust_2024_prelude_collisions` lint detects the usage of trait methods which are ambiguous
3629    /// with traits added to the prelude in future editions.
3630    ///
3631    /// ### Example
3632    ///
3633    /// ```rust,edition2021,compile_fail
3634    /// #![deny(rust_2024_prelude_collisions)]
3635    /// trait Meow {
3636    ///     fn poll(&self) {}
3637    /// }
3638    /// impl<T> Meow for T {}
3639    ///
3640    /// fn main() {
3641    ///     core::pin::pin!(async {}).poll();
3642    ///     //                        ^^^^^^
3643    ///     // This call to try_into matches both Future::poll and Meow::poll as
3644    ///     // `Future` has been added to the Rust prelude in 2024 edition.
3645    /// }
3646    /// ```
3647    ///
3648    /// {{produces}}
3649    ///
3650    /// ### Explanation
3651    ///
3652    /// Rust 2024, introduces two new additions to the standard library's prelude:
3653    /// `Future` and `IntoFuture`. This results in an ambiguity as to which method/function
3654    /// to call when an existing `poll`/`into_future` method is called via dot-call syntax or
3655    /// a `poll`/`into_future` associated function is called directly on a type.
3656    ///
3657    pub RUST_2024_PRELUDE_COLLISIONS,
3658    Allow,
3659    "detects the usage of trait methods which are ambiguous with traits added to the \
3660        prelude in future editions",
3661    @future_incompatible = FutureIncompatibleInfo {
3662        reason: fcw!(EditionError 2024 "prelude"),
3663    };
3664}
3665
3666#[doc =
r" The `rust_2021_prefixes_incompatible_syntax` lint detects identifiers that will be parsed as a"]
#[doc = r" prefix instead in Rust 2021."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2018,compile_fail"]
#[doc = r" #![deny(rust_2021_prefixes_incompatible_syntax)]"]
#[doc = r""]
#[doc = r" macro_rules! m {"]
#[doc = r"     (z $x:expr) => ();"]
#[doc = r" }"]
#[doc = r""]
#[doc = r#" m!(z"hey");"#]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r#" In Rust 2015 and 2018, `z"hey"` is two tokens: the identifier `z`"#]
#[doc =
r#" followed by the string literal `"hey"`. In Rust 2021, the `z` is"#]
#[doc = r#" considered a prefix for `"hey"`."#]
#[doc = r""]
#[doc =
r#" This lint suggests to add whitespace between the `z` and `"hey"` tokens"#]
#[doc = r" to keep them separated in Rust 2021."]
#[allow(rustdoc::invalid_rust_codeblocks)]
pub static RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX: &crate::Lint =
    &crate::Lint {
            name: "RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX",
            default_level: crate::Allow,
            desc: "identifiers that will be parsed as a prefix in Rust 2021",
            crate_level_only: true,
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionSemanticsChange(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2021,
                            page_slug: "reserving-syntax",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
3667    /// The `rust_2021_prefixes_incompatible_syntax` lint detects identifiers that will be parsed as a
3668    /// prefix instead in Rust 2021.
3669    ///
3670    /// ### Example
3671    ///
3672    /// ```rust,edition2018,compile_fail
3673    /// #![deny(rust_2021_prefixes_incompatible_syntax)]
3674    ///
3675    /// macro_rules! m {
3676    ///     (z $x:expr) => ();
3677    /// }
3678    ///
3679    /// m!(z"hey");
3680    /// ```
3681    ///
3682    /// {{produces}}
3683    ///
3684    /// ### Explanation
3685    ///
3686    /// In Rust 2015 and 2018, `z"hey"` is two tokens: the identifier `z`
3687    /// followed by the string literal `"hey"`. In Rust 2021, the `z` is
3688    /// considered a prefix for `"hey"`.
3689    ///
3690    /// This lint suggests to add whitespace between the `z` and `"hey"` tokens
3691    /// to keep them separated in Rust 2021.
3692    // Allow this lint -- rustdoc doesn't yet support threading edition into this lint's parser.
3693    #[allow(rustdoc::invalid_rust_codeblocks)]
3694    pub RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
3695    Allow,
3696    "identifiers that will be parsed as a prefix in Rust 2021",
3697    @future_incompatible = FutureIncompatibleInfo {
3698        reason: fcw!(EditionSemanticsChange 2021 "reserving-syntax"),
3699    };
3700    crate_level_only
3701}
3702
3703#[doc =
r" The `unsupported_calling_conventions` lint is output whenever there is a use of the"]
#[doc =
r" `stdcall`, `fastcall`, and `cdecl` calling conventions (or their unwind"]
#[doc =
r" variants) on targets that cannot meaningfully be supported for the requested target."]
#[doc = r""]
#[doc =
r" For example, `stdcall` does not make much sense for a x86_64 or, more apparently, powerpc"]
#[doc =
r" code, because this calling convention was never specified for those targets."]
#[doc = r""]
#[doc =
r" Historically, MSVC toolchains have fallen back to the regular C calling convention for"]
#[doc =
r" targets other than x86, but Rust doesn't really see a similar need to introduce a similar"]
#[doc = r" hack across many more targets."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs specific targets)"]
#[doc = r#" extern "stdcall" fn stdcall() {}"#]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: use of calling convention not supported on this target"]
#[doc = r"   --> $DIR/unsupported.rs:39:1"]
#[doc = r"    |"]
#[doc = r#" LL | extern "stdcall" fn stdcall() {}"#]
#[doc = r"    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r"    |"]
#[doc =
r"    = note: `#[warn(unsupported_calling_conventions)]` on by default"]
#[doc =
r"    = warning: this was previously accepted by the compiler but is being phased out;"]
#[doc = r"               it will become a hard error in a future release!"]
#[doc = r"    = note: for more information, see issue ..."]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" On most of the targets, the behaviour of `stdcall` and similar calling conventions is not"]
#[doc =
r" defined at all, but was previously accepted due to a bug in the implementation of the"]
#[doc = r" compiler."]
pub static UNSUPPORTED_CALLING_CONVENTIONS: &crate::Lint =
    &crate::Lint {
            name: "UNSUPPORTED_CALLING_CONVENTIONS",
            default_level: crate::Warn,
            desc: "use of unsupported calling convention",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 137018,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
3704    /// The `unsupported_calling_conventions` lint is output whenever there is a use of the
3705    /// `stdcall`, `fastcall`, and `cdecl` calling conventions (or their unwind
3706    /// variants) on targets that cannot meaningfully be supported for the requested target.
3707    ///
3708    /// For example, `stdcall` does not make much sense for a x86_64 or, more apparently, powerpc
3709    /// code, because this calling convention was never specified for those targets.
3710    ///
3711    /// Historically, MSVC toolchains have fallen back to the regular C calling convention for
3712    /// targets other than x86, but Rust doesn't really see a similar need to introduce a similar
3713    /// hack across many more targets.
3714    ///
3715    /// ### Example
3716    ///
3717    /// ```rust,ignore (needs specific targets)
3718    /// extern "stdcall" fn stdcall() {}
3719    /// ```
3720    ///
3721    /// This will produce:
3722    ///
3723    /// ```text
3724    /// warning: use of calling convention not supported on this target
3725    ///   --> $DIR/unsupported.rs:39:1
3726    ///    |
3727    /// LL | extern "stdcall" fn stdcall() {}
3728    ///    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3729    ///    |
3730    ///    = note: `#[warn(unsupported_calling_conventions)]` on by default
3731    ///    = warning: this was previously accepted by the compiler but is being phased out;
3732    ///               it will become a hard error in a future release!
3733    ///    = note: for more information, see issue ...
3734    /// ```
3735    ///
3736    /// ### Explanation
3737    ///
3738    /// On most of the targets, the behaviour of `stdcall` and similar calling conventions is not
3739    /// defined at all, but was previously accepted due to a bug in the implementation of the
3740    /// compiler.
3741    pub UNSUPPORTED_CALLING_CONVENTIONS,
3742    Warn,
3743    "use of unsupported calling convention",
3744    @future_incompatible = FutureIncompatibleInfo {
3745        reason: fcw!(FutureReleaseError #137018),
3746        report_in_deps: false,
3747    };
3748}
3749
3750#[doc =
r" The `unsupported_fn_ptr_calling_conventions` lint is output whenever there is a use of"]
#[doc =
r" a target dependent calling convention on a target that does not support this calling"]
#[doc = r" convention on a function pointer."]
#[doc = r""]
#[doc =
r" For example `stdcall` does not make much sense for a x86_64 or, more apparently, powerpc"]
#[doc =
r" code, because this calling convention was never specified for those targets."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs specific targets)"]
#[doc = r#" fn stdcall_ptr(f: extern "stdcall" fn ()) {"#]
#[doc = r"     f()"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r#" warning: the calling convention `"stdcall"` is not supported on this target"#]
#[doc = r"   --> $DIR/unsupported.rs:34:15"]
#[doc = r"    |"]
#[doc = r#" LL | fn stdcall_ptr(f: extern "stdcall" fn()) {"#]
#[doc = r"    |               ^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r"    |"]
#[doc =
r"    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>"]
#[doc =
r"    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" On most of the targets the behaviour of `stdcall` and similar calling conventions is not"]
#[doc =
r" defined at all, but was previously accepted due to a bug in the implementation of the"]
#[doc = r" compiler."]
pub static UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS: &crate::Lint =
    &crate::Lint {
            name: "UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS",
            default_level: crate::Warn,
            desc: "use of unsupported calling convention for function pointer",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 130260,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
3751    /// The `unsupported_fn_ptr_calling_conventions` lint is output whenever there is a use of
3752    /// a target dependent calling convention on a target that does not support this calling
3753    /// convention on a function pointer.
3754    ///
3755    /// For example `stdcall` does not make much sense for a x86_64 or, more apparently, powerpc
3756    /// code, because this calling convention was never specified for those targets.
3757    ///
3758    /// ### Example
3759    ///
3760    /// ```rust,ignore (needs specific targets)
3761    /// fn stdcall_ptr(f: extern "stdcall" fn ()) {
3762    ///     f()
3763    /// }
3764    /// ```
3765    ///
3766    /// This will produce:
3767    ///
3768    /// ```text
3769    /// warning: the calling convention `"stdcall"` is not supported on this target
3770    ///   --> $DIR/unsupported.rs:34:15
3771    ///    |
3772    /// LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
3773    ///    |               ^^^^^^^^^^^^^^^^^^^^^^^^
3774    ///    |
3775    ///    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
3776    ///    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
3777    ///    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
3778    /// ```
3779    ///
3780    /// ### Explanation
3781    ///
3782    /// On most of the targets the behaviour of `stdcall` and similar calling conventions is not
3783    /// defined at all, but was previously accepted due to a bug in the implementation of the
3784    /// compiler.
3785    pub UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS,
3786    Warn,
3787    "use of unsupported calling convention for function pointer",
3788    @future_incompatible = FutureIncompatibleInfo {
3789        reason: fcw!(FutureReleaseError #130260),
3790        report_in_deps: true,
3791    };
3792}
3793
3794#[doc =
r" The `break_with_label_and_loop` lint detects labeled `break` expressions with"]
#[doc = r" an unlabeled loop as their value expression."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" 'label: loop {"]
#[doc = r"     break 'label loop { break 42; };"]
#[doc = r" };"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In Rust, loops can have a label, and `break` expressions can refer to that label to"]
#[doc =
r" break out of specific loops (and not necessarily the innermost one). `break` expressions"]
#[doc =
r" can also carry a value expression, which can be another loop. A labeled `break` with an"]
#[doc =
r" unlabeled loop as its value expression is easy to confuse with an unlabeled break with"]
#[doc =
r" a labeled loop and is thus discouraged (but allowed for compatibility); use parentheses"]
#[doc =
r" around the loop expression to silence this warning. Unlabeled `break` expressions with"]
#[doc =
r" labeled loops yield a hard error, which can also be silenced by wrapping the expression"]
#[doc = r" in parentheses."]
pub static BREAK_WITH_LABEL_AND_LOOP: &crate::Lint =
    &crate::Lint {
            name: "BREAK_WITH_LABEL_AND_LOOP",
            default_level: crate::Warn,
            desc: "`break` expression with label and unlabeled loop as value expression",
            ..
        };declare_lint! {
3795    /// The `break_with_label_and_loop` lint detects labeled `break` expressions with
3796    /// an unlabeled loop as their value expression.
3797    ///
3798    /// ### Example
3799    ///
3800    /// ```rust
3801    /// 'label: loop {
3802    ///     break 'label loop { break 42; };
3803    /// };
3804    /// ```
3805    ///
3806    /// {{produces}}
3807    ///
3808    /// ### Explanation
3809    ///
3810    /// In Rust, loops can have a label, and `break` expressions can refer to that label to
3811    /// break out of specific loops (and not necessarily the innermost one). `break` expressions
3812    /// can also carry a value expression, which can be another loop. A labeled `break` with an
3813    /// unlabeled loop as its value expression is easy to confuse with an unlabeled break with
3814    /// a labeled loop and is thus discouraged (but allowed for compatibility); use parentheses
3815    /// around the loop expression to silence this warning. Unlabeled `break` expressions with
3816    /// labeled loops yield a hard error, which can also be silenced by wrapping the expression
3817    /// in parentheses.
3818    pub BREAK_WITH_LABEL_AND_LOOP,
3819    Warn,
3820    "`break` expression with label and unlabeled loop as value expression"
3821}
3822
3823#[doc =
r" The `non_exhaustive_omitted_patterns` lint aims to help consumers of a `#[non_exhaustive]`"]
#[doc =
r" struct or enum who want to match all of its fields/variants explicitly."]
#[doc = r""]
#[doc =
r" The `#[non_exhaustive]` annotation forces matches to use wildcards, so exhaustiveness"]
#[doc =
r" checking cannot be used to ensure that all fields/variants are matched explicitly. To remedy"]
#[doc =
r" this, this allow-by-default lint warns the user when a match mentions some but not all of"]
#[doc = r" the fields/variants of a `#[non_exhaustive]` struct or enum."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs separate crate)"]
#[doc = r" // crate A"]
#[doc = r" #[non_exhaustive]"]
#[doc = r" pub enum Bar {"]
#[doc = r"     A,"]
#[doc = r"     B, // added variant in non breaking change"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" // in crate B"]
#[doc = r" #![feature(non_exhaustive_omitted_patterns_lint)]"]
#[doc = r" #[warn(non_exhaustive_omitted_patterns)]"]
#[doc = r" match Bar::A {"]
#[doc = r"     Bar::A => {},"]
#[doc = r"     _ => {},"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: some variants are not matched explicitly"]
#[doc = r"    --> $DIR/reachable-patterns.rs:70:9"]
#[doc = r"    |"]
#[doc = r" LL |         match Bar::A {"]
#[doc = r"    |               ^ pattern `Bar::B` not covered"]
#[doc = r"    |"]
#[doc = r"  note: the lint level is defined here"]
#[doc = r"   --> $DIR/reachable-patterns.rs:69:16"]
#[doc = r"    |"]
#[doc = r" LL |         #[warn(non_exhaustive_omitted_patterns)]"]
#[doc = r"    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc =
r"    = help: ensure that all variants are matched explicitly by adding the suggested match arms"]
#[doc =
r"    = note: the matched value is of type `Bar` and the `non_exhaustive_omitted_patterns` attribute was found"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" Warning: setting this to `deny` will make upstream non-breaking changes (adding fields or"]
#[doc =
r" variants to a `#[non_exhaustive]` struct or enum) break your crate. This goes against"]
#[doc = r" expected semver behavior."]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Structs and enums tagged with `#[non_exhaustive]` force the user to add a (potentially"]
#[doc =
r" redundant) wildcard when pattern-matching, to allow for future addition of fields or"]
#[doc =
r" variants. The `non_exhaustive_omitted_patterns` lint detects when such a wildcard happens to"]
#[doc =
r" actually catch some fields/variants. In other words, when the match without the wildcard"]
#[doc =
r" would not be exhaustive. This lets the user be informed if new fields/variants were added."]
pub static NON_EXHAUSTIVE_OMITTED_PATTERNS: &crate::Lint =
    &crate::Lint {
            name: "NON_EXHAUSTIVE_OMITTED_PATTERNS",
            default_level: crate::Allow,
            desc: "detect when patterns of types marked `non_exhaustive` are missed",
            feature_gate: Some(rustc_span::sym::non_exhaustive_omitted_patterns_lint),
            ..
        };declare_lint! {
3824    /// The `non_exhaustive_omitted_patterns` lint aims to help consumers of a `#[non_exhaustive]`
3825    /// struct or enum who want to match all of its fields/variants explicitly.
3826    ///
3827    /// The `#[non_exhaustive]` annotation forces matches to use wildcards, so exhaustiveness
3828    /// checking cannot be used to ensure that all fields/variants are matched explicitly. To remedy
3829    /// this, this allow-by-default lint warns the user when a match mentions some but not all of
3830    /// the fields/variants of a `#[non_exhaustive]` struct or enum.
3831    ///
3832    /// ### Example
3833    ///
3834    /// ```rust,ignore (needs separate crate)
3835    /// // crate A
3836    /// #[non_exhaustive]
3837    /// pub enum Bar {
3838    ///     A,
3839    ///     B, // added variant in non breaking change
3840    /// }
3841    ///
3842    /// // in crate B
3843    /// #![feature(non_exhaustive_omitted_patterns_lint)]
3844    /// #[warn(non_exhaustive_omitted_patterns)]
3845    /// match Bar::A {
3846    ///     Bar::A => {},
3847    ///     _ => {},
3848    /// }
3849    /// ```
3850    ///
3851    /// This will produce:
3852    ///
3853    /// ```text
3854    /// warning: some variants are not matched explicitly
3855    ///    --> $DIR/reachable-patterns.rs:70:9
3856    ///    |
3857    /// LL |         match Bar::A {
3858    ///    |               ^ pattern `Bar::B` not covered
3859    ///    |
3860    ///  note: the lint level is defined here
3861    ///   --> $DIR/reachable-patterns.rs:69:16
3862    ///    |
3863    /// LL |         #[warn(non_exhaustive_omitted_patterns)]
3864    ///    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3865    ///    = help: ensure that all variants are matched explicitly by adding the suggested match arms
3866    ///    = note: the matched value is of type `Bar` and the `non_exhaustive_omitted_patterns` attribute was found
3867    /// ```
3868    ///
3869    /// Warning: setting this to `deny` will make upstream non-breaking changes (adding fields or
3870    /// variants to a `#[non_exhaustive]` struct or enum) break your crate. This goes against
3871    /// expected semver behavior.
3872    ///
3873    /// ### Explanation
3874    ///
3875    /// Structs and enums tagged with `#[non_exhaustive]` force the user to add a (potentially
3876    /// redundant) wildcard when pattern-matching, to allow for future addition of fields or
3877    /// variants. The `non_exhaustive_omitted_patterns` lint detects when such a wildcard happens to
3878    /// actually catch some fields/variants. In other words, when the match without the wildcard
3879    /// would not be exhaustive. This lets the user be informed if new fields/variants were added.
3880    pub NON_EXHAUSTIVE_OMITTED_PATTERNS,
3881    Allow,
3882    "detect when patterns of types marked `non_exhaustive` are missed",
3883    @feature_gate = non_exhaustive_omitted_patterns_lint;
3884}
3885
3886#[doc =
r" The `text_direction_codepoint_in_comment` lint detects Unicode codepoints in comments that"]
#[doc =
r" change the visual representation of text on screen in a way that does not correspond to"]
#[doc = r" their on memory representation."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(text_direction_codepoint_in_comment)]"]
#[doc = r" fn main() {"]
#[doc = "    println!(\"{:?}\"); // '\u{202E}');"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unicode allows changing the visual flow of text on screen in order to support scripts that"]
#[doc =
r" are written right-to-left, but a specially crafted comment can make code that will be"]
#[doc =
r" compiled appear to be part of a comment, depending on the software used to read the code."]
#[doc =
r" To avoid potential problems or confusion, such as in CVE-2021-42574, by default we deny"]
#[doc = r" their use."]
pub static TEXT_DIRECTION_CODEPOINT_IN_COMMENT: &crate::Lint =
    &crate::Lint {
            name: "TEXT_DIRECTION_CODEPOINT_IN_COMMENT",
            default_level: crate::Deny,
            desc: "invisible directionality-changing codepoints in comment",
            crate_level_only: true,
            ..
        };declare_lint! {
3887    /// The `text_direction_codepoint_in_comment` lint detects Unicode codepoints in comments that
3888    /// change the visual representation of text on screen in a way that does not correspond to
3889    /// their on memory representation.
3890    ///
3891    /// ### Example
3892    ///
3893    /// ```rust,compile_fail
3894    /// #![deny(text_direction_codepoint_in_comment)]
3895    /// fn main() {
3896    #[doc = "    println!(\"{:?}\"); // '\u{202E}');"]
3897    /// }
3898    /// ```
3899    ///
3900    /// {{produces}}
3901    ///
3902    /// ### Explanation
3903    ///
3904    /// Unicode allows changing the visual flow of text on screen in order to support scripts that
3905    /// are written right-to-left, but a specially crafted comment can make code that will be
3906    /// compiled appear to be part of a comment, depending on the software used to read the code.
3907    /// To avoid potential problems or confusion, such as in CVE-2021-42574, by default we deny
3908    /// their use.
3909    pub TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
3910    Deny,
3911    "invisible directionality-changing codepoints in comment",
3912    crate_level_only
3913}
3914
3915#[doc =
r" The `text_direction_codepoint_in_literal` lint detects Unicode codepoints that change the"]
#[doc =
r" visual representation of text on screen in a way that does not correspond to their on"]
#[doc = r" memory representation."]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The unicode characters `\u{202A}`, `\u{202B}`, `\u{202D}`, `\u{202E}`, `\u{2066}`,"]
#[doc =
r" `\u{2067}`, `\u{2068}`, `\u{202C}` and `\u{2069}` make the flow of text on screen change"]
#[doc =
r#" its direction on software that supports these codepoints. This makes the text "abc" display"#]
#[doc =
r#" as "cba" on screen. By leveraging software that supports these, people can write specially"#]
#[doc =
r" crafted literals that make the surrounding code seem like it's performing one action, when"]
#[doc =
r" in reality it is performing another. Because of this, we proactively lint against their"]
#[doc = r" presence to avoid surprises."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(text_direction_codepoint_in_literal)]"]
#[doc = r" fn main() {"]
#[doc = "    println!(\"{:?}\", '\u{202E}');"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
pub static TEXT_DIRECTION_CODEPOINT_IN_LITERAL: &crate::Lint =
    &crate::Lint {
            name: "TEXT_DIRECTION_CODEPOINT_IN_LITERAL",
            default_level: crate::Deny,
            desc: "detect special Unicode codepoints that affect the visual representation of text on screen, \
     changing the direction in which text flows",
            crate_level_only: true,
            ..
        };declare_lint! {
3916    /// The `text_direction_codepoint_in_literal` lint detects Unicode codepoints that change the
3917    /// visual representation of text on screen in a way that does not correspond to their on
3918    /// memory representation.
3919    ///
3920    /// ### Explanation
3921    ///
3922    /// The unicode characters `\u{202A}`, `\u{202B}`, `\u{202D}`, `\u{202E}`, `\u{2066}`,
3923    /// `\u{2067}`, `\u{2068}`, `\u{202C}` and `\u{2069}` make the flow of text on screen change
3924    /// its direction on software that supports these codepoints. This makes the text "abc" display
3925    /// as "cba" on screen. By leveraging software that supports these, people can write specially
3926    /// crafted literals that make the surrounding code seem like it's performing one action, when
3927    /// in reality it is performing another. Because of this, we proactively lint against their
3928    /// presence to avoid surprises.
3929    ///
3930    /// ### Example
3931    ///
3932    /// ```rust,compile_fail
3933    /// #![deny(text_direction_codepoint_in_literal)]
3934    /// fn main() {
3935    // ` - convince tidy that backticks match
3936    #[doc = "    println!(\"{:?}\", '\u{202E}');"]
3937    // `
3938    /// }
3939    /// ```
3940    ///
3941    /// {{produces}}
3942    ///
3943    pub TEXT_DIRECTION_CODEPOINT_IN_LITERAL,
3944    Deny,
3945    "detect special Unicode codepoints that affect the visual representation of text on screen, \
3946     changing the direction in which text flows",
3947    crate_level_only
3948}
3949
3950#[doc =
r" The `duplicate_macro_attributes` lint detects when a `#[test]`-like built-in macro"]
#[doc =
r" attribute is duplicated on an item. This lint may trigger on `bench`, `cfg_eval`, `test`"]
#[doc = r" and `test_case`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs --test)"]
#[doc = r" #[test]"]
#[doc = r" #[test]"]
#[doc = r" fn foo() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: duplicated attribute"]
#[doc = r"  --> src/lib.rs:2:1"]
#[doc = r"   |"]
#[doc = r" 2 | #[test]"]
#[doc = r"   | ^^^^^^^"]
#[doc = r"   |"]
#[doc = r"   = note: `#[warn(duplicate_macro_attributes)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" A duplicated attribute may erroneously originate from a copy-paste and the effect of it"]
#[doc = r" being duplicated may not be obvious or desirable."]
#[doc = r""]
#[doc =
r" For instance, doubling the `#[test]` attributes registers the test to be run twice with no"]
#[doc = r" change to its environment."]
#[doc = r""]
#[doc = r" [issue #90979]: https://github.com/rust-lang/rust/issues/90979"]
pub static DUPLICATE_MACRO_ATTRIBUTES: &crate::Lint =
    &crate::Lint {
            name: "DUPLICATE_MACRO_ATTRIBUTES",
            default_level: crate::Warn,
            desc: "duplicated attribute",
            ..
        };declare_lint! {
3951    /// The `duplicate_macro_attributes` lint detects when a `#[test]`-like built-in macro
3952    /// attribute is duplicated on an item. This lint may trigger on `bench`, `cfg_eval`, `test`
3953    /// and `test_case`.
3954    ///
3955    /// ### Example
3956    ///
3957    /// ```rust,ignore (needs --test)
3958    /// #[test]
3959    /// #[test]
3960    /// fn foo() {}
3961    /// ```
3962    ///
3963    /// This will produce:
3964    ///
3965    /// ```text
3966    /// warning: duplicated attribute
3967    ///  --> src/lib.rs:2:1
3968    ///   |
3969    /// 2 | #[test]
3970    ///   | ^^^^^^^
3971    ///   |
3972    ///   = note: `#[warn(duplicate_macro_attributes)]` on by default
3973    /// ```
3974    ///
3975    /// ### Explanation
3976    ///
3977    /// A duplicated attribute may erroneously originate from a copy-paste and the effect of it
3978    /// being duplicated may not be obvious or desirable.
3979    ///
3980    /// For instance, doubling the `#[test]` attributes registers the test to be run twice with no
3981    /// change to its environment.
3982    ///
3983    /// [issue #90979]: https://github.com/rust-lang/rust/issues/90979
3984    pub DUPLICATE_MACRO_ATTRIBUTES,
3985    Warn,
3986    "duplicated attribute"
3987}
3988
3989#[doc =
r" The `deprecated_where_clause_location` lint detects when a where clause in front of the equals"]
#[doc = r" in an associated type."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" trait Trait {"]
#[doc = r"   type Assoc<'a> where Self: 'a;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl Trait for () {"]
#[doc = r"   type Assoc<'a> where Self: 'a = ();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" The preferred location for where clauses on associated types"]
#[doc =
r" is after the type. However, for most of generic associated types development,"]
#[doc =
r" it was only accepted before the equals. To provide a transition period and"]
#[doc =
r" further evaluate this change, both are currently accepted. At some point in"]
#[doc =
r" the future, this may be disallowed at an edition boundary; but, that is"]
#[doc = r" undecided currently."]
pub static DEPRECATED_WHERE_CLAUSE_LOCATION: &crate::Lint =
    &crate::Lint {
            name: "DEPRECATED_WHERE_CLAUSE_LOCATION",
            default_level: crate::Warn,
            desc: "deprecated where clause location",
            ..
        };declare_lint! {
3990    /// The `deprecated_where_clause_location` lint detects when a where clause in front of the equals
3991    /// in an associated type.
3992    ///
3993    /// ### Example
3994    ///
3995    /// ```rust
3996    /// trait Trait {
3997    ///   type Assoc<'a> where Self: 'a;
3998    /// }
3999    ///
4000    /// impl Trait for () {
4001    ///   type Assoc<'a> where Self: 'a = ();
4002    /// }
4003    /// ```
4004    ///
4005    /// {{produces}}
4006    ///
4007    /// ### Explanation
4008    ///
4009    /// The preferred location for where clauses on associated types
4010    /// is after the type. However, for most of generic associated types development,
4011    /// it was only accepted before the equals. To provide a transition period and
4012    /// further evaluate this change, both are currently accepted. At some point in
4013    /// the future, this may be disallowed at an edition boundary; but, that is
4014    /// undecided currently.
4015    pub DEPRECATED_WHERE_CLAUSE_LOCATION,
4016    Warn,
4017    "deprecated where clause location"
4018}
4019
4020#[doc =
r" The `test_unstable_lint` lint tests unstable lints and is perma-unstable."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc =
r" // This lint is intentionally used to test the compiler's behavior"]
#[doc =
r" // when an unstable lint is enabled without the corresponding feature gate."]
#[doc = r" #![allow(test_unstable_lint)]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In order to test the behavior of unstable lints, a permanently-unstable"]
#[doc =
r" lint is required. This lint can be used to trigger warnings and errors"]
#[doc = r" from the compiler related to unstable lints."]
pub static TEST_UNSTABLE_LINT: &crate::Lint =
    &crate::Lint {
            name: "TEST_UNSTABLE_LINT",
            default_level: crate::Deny,
            desc: "this unstable lint is only for testing",
            feature_gate: Some(rustc_span::sym::test_unstable_lint),
            ..
        };declare_lint! {
4021    /// The `test_unstable_lint` lint tests unstable lints and is perma-unstable.
4022    ///
4023    /// ### Example
4024    ///
4025    /// ```rust
4026    /// // This lint is intentionally used to test the compiler's behavior
4027    /// // when an unstable lint is enabled without the corresponding feature gate.
4028    /// #![allow(test_unstable_lint)]
4029    /// ```
4030    ///
4031    /// {{produces}}
4032    ///
4033    /// ### Explanation
4034    ///
4035    /// In order to test the behavior of unstable lints, a permanently-unstable
4036    /// lint is required. This lint can be used to trigger warnings and errors
4037    /// from the compiler related to unstable lints.
4038    pub TEST_UNSTABLE_LINT,
4039    Deny,
4040    "this unstable lint is only for testing",
4041    @feature_gate = test_unstable_lint;
4042}
4043
4044#[doc =
r" The `ffi_unwind_calls` lint detects calls to foreign functions or function pointers with"]
#[doc = r" `C-unwind` or other FFI-unwind ABIs."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![warn(ffi_unwind_calls)]"]
#[doc = r""]
#[doc = r#" unsafe extern "C-unwind" {"#]
#[doc = r"     fn foo();"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn bar() {"]
#[doc = r"     unsafe { foo(); }"]
#[doc = r#"     let ptr: unsafe extern "C-unwind" fn() = foo;"#]
#[doc = r"     unsafe { ptr(); }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" For crates containing such calls, if they are compiled with `-C panic=unwind` then the"]
#[doc =
r" produced library cannot be linked with crates compiled with `-C panic=abort`. For crates"]
#[doc =
r" that desire this ability it is therefore necessary to avoid such calls."]
pub static FFI_UNWIND_CALLS: &crate::Lint =
    &crate::Lint {
            name: "FFI_UNWIND_CALLS",
            default_level: crate::Allow,
            desc: "call to foreign functions or function pointers with FFI-unwind ABI",
            ..
        };declare_lint! {
4045    /// The `ffi_unwind_calls` lint detects calls to foreign functions or function pointers with
4046    /// `C-unwind` or other FFI-unwind ABIs.
4047    ///
4048    /// ### Example
4049    ///
4050    /// ```rust
4051    /// #![warn(ffi_unwind_calls)]
4052    ///
4053    /// unsafe extern "C-unwind" {
4054    ///     fn foo();
4055    /// }
4056    ///
4057    /// fn bar() {
4058    ///     unsafe { foo(); }
4059    ///     let ptr: unsafe extern "C-unwind" fn() = foo;
4060    ///     unsafe { ptr(); }
4061    /// }
4062    /// ```
4063    ///
4064    /// {{produces}}
4065    ///
4066    /// ### Explanation
4067    ///
4068    /// For crates containing such calls, if they are compiled with `-C panic=unwind` then the
4069    /// produced library cannot be linked with crates compiled with `-C panic=abort`. For crates
4070    /// that desire this ability it is therefore necessary to avoid such calls.
4071    pub FFI_UNWIND_CALLS,
4072    Allow,
4073    "call to foreign functions or function pointers with FFI-unwind ABI"
4074}
4075
4076#[doc = r" The `linker_messages` lint forwards warnings from the linker."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs CLI args, platform-specific)"]
#[doc = r" #![warn(linker_messages)]"]
#[doc = r""]
#[doc = r#" unsafe extern "C" {"#]
#[doc = r"   fn foo();"]
#[doc = r" }"]
#[doc = r" fn main () { unsafe { foo(); } }"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" On Linux, using `gcc -Wl,--warn-unresolved-symbols` as a linker, this will produce"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: linker stderr: rust-lld: undefined symbol: foo"]
#[doc = r"          >>> referenced by rust_out.69edbd30df4ae57d-cgu.0"]
#[doc =
r"          >>>               rust_out.rust_out.69edbd30df4ae57d-cgu.0.rcgu.o:(rust_out::main::h3a90094b06757803)"]
#[doc = r"   |"]
#[doc = r" note: the lint level is defined here"]
#[doc = r"  --> warn.rs:1:9"]
#[doc = r"   |"]
#[doc = r" 1 | #![warn(linker_messages)]"]
#[doc = r"   |         ^^^^^^^^^^^^^^^"]
#[doc = r" warning: 1 warning emitted"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Linkers emit platform-specific and program-specific warnings that cannot be predicted in"]
#[doc =
r" advance by the Rust compiler. Such messages are ignored by default for now. While linker"]
#[doc =
r" warnings could be very useful they have been ignored for many years by essentially all"]
#[doc =
r" users, so we need to do a bit more work than just surfacing their text to produce a clear"]
#[doc =
r" and actionable warning of similar quality to our other diagnostics. See this tracking"]
#[doc =
r" issue for more details: <https://github.com/rust-lang/rust/issues/136096>."]
pub static LINKER_MESSAGES: &crate::Lint =
    &crate::Lint {
            name: "LINKER_MESSAGES",
            default_level: crate::Warn,
            desc: "warnings emitted at runtime by the target-specific linker program",
            ignore_deny_warnings: true,
            crate_level_only: true,
            ..
        };declare_lint! {
4077    /// The `linker_messages` lint forwards warnings from the linker.
4078    ///
4079    /// ### Example
4080    ///
4081    /// ```rust,ignore (needs CLI args, platform-specific)
4082    /// #![warn(linker_messages)]
4083    ///
4084    /// unsafe extern "C" {
4085    ///   fn foo();
4086    /// }
4087    /// fn main () { unsafe { foo(); } }
4088    /// ```
4089    ///
4090    /// On Linux, using `gcc -Wl,--warn-unresolved-symbols` as a linker, this will produce
4091    ///
4092    /// ```text
4093    /// warning: linker stderr: rust-lld: undefined symbol: foo
4094    ///          >>> referenced by rust_out.69edbd30df4ae57d-cgu.0
4095    ///          >>>               rust_out.rust_out.69edbd30df4ae57d-cgu.0.rcgu.o:(rust_out::main::h3a90094b06757803)
4096    ///   |
4097    /// note: the lint level is defined here
4098    ///  --> warn.rs:1:9
4099    ///   |
4100    /// 1 | #![warn(linker_messages)]
4101    ///   |         ^^^^^^^^^^^^^^^
4102    /// warning: 1 warning emitted
4103    /// ```
4104    ///
4105    /// ### Explanation
4106    ///
4107    /// Linkers emit platform-specific and program-specific warnings that cannot be predicted in
4108    /// advance by the Rust compiler. Such messages are ignored by default for now. While linker
4109    /// warnings could be very useful they have been ignored for many years by essentially all
4110    /// users, so we need to do a bit more work than just surfacing their text to produce a clear
4111    /// and actionable warning of similar quality to our other diagnostics. See this tracking
4112    /// issue for more details: <https://github.com/rust-lang/rust/issues/136096>.
4113    pub LINKER_MESSAGES,
4114    Warn,
4115    "warnings emitted at runtime by the target-specific linker program",
4116    // Linker messages don't live up to the high standard people expect of rustc's errors.
4117    // Prevent `-D warnings` from applying to it.
4118    // It's still possible to pass `-D linker-messages` specifically.
4119    ignore_deny_warnings,
4120    crate_level_only
4121}
4122
4123#[doc =
r" The `linker_info` lint forwards warnings from the linker that are known to be informational-only."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs CLI args, platform-specific)"]
#[doc = r" #![warn(linker_info)]"]
#[doc = r""]
#[doc = r" fn main () {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" On MacOS, using `-C link-arg=-lc` and the default linker, this will produce"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: linker stderr: ld: ignoring duplicate libraries: '-lc'"]
#[doc = r"   |"]
#[doc = r" note: the lint level is defined here"]
#[doc = r"  --> ex.rs:1:9"]
#[doc = r"   |"]
#[doc = r" 1 | #![warn(linker_info)]"]
#[doc = r"   |         ^^^^^^^^^^^^^^^"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r#" Many linkers are very "chatty" and print lots of information that is not necessarily"#]
#[doc =
r" indicative of an issue. This output has been ignored for many years and is often not"]
#[doc =
r" actionable by developers. It is silenced unless the developer specifically requests for it"]
#[doc = r" to be printed. See this tracking issue for more details:"]
#[doc = r" <https://github.com/rust-lang/rust/issues/136096>."]
pub static LINKER_INFO: &crate::Lint =
    &crate::Lint {
            name: "LINKER_INFO",
            default_level: crate::Allow,
            desc: "linker warnings known to be informational-only and not indicative of a problem",
            crate_level_only: true,
            ..
        };declare_lint! {
4124    /// The `linker_info` lint forwards warnings from the linker that are known to be informational-only.
4125    ///
4126    /// ### Example
4127    ///
4128    /// ```rust,ignore (needs CLI args, platform-specific)
4129    /// #![warn(linker_info)]
4130    ///
4131    /// fn main () {}
4132    /// ```
4133    ///
4134    /// On MacOS, using `-C link-arg=-lc` and the default linker, this will produce
4135    ///
4136    /// ```text
4137    /// warning: linker stderr: ld: ignoring duplicate libraries: '-lc'
4138    ///   |
4139    /// note: the lint level is defined here
4140    ///  --> ex.rs:1:9
4141    ///   |
4142    /// 1 | #![warn(linker_info)]
4143    ///   |         ^^^^^^^^^^^^^^^
4144    /// ```
4145    ///
4146    /// ### Explanation
4147    ///
4148    /// Many linkers are very "chatty" and print lots of information that is not necessarily
4149    /// indicative of an issue. This output has been ignored for many years and is often not
4150    /// actionable by developers. It is silenced unless the developer specifically requests for it
4151    /// to be printed. See this tracking issue for more details:
4152    /// <https://github.com/rust-lang/rust/issues/136096>.
4153    pub LINKER_INFO,
4154    Allow,
4155    "linker warnings known to be informational-only and not indicative of a problem",
4156    crate_level_only
4157}
4158
4159#[doc =
r" The `named_arguments_used_positionally` lint detects cases where named arguments are only"]
#[doc =
r" used positionally in format strings. This usage is valid but potentially very confusing."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(named_arguments_used_positionally)]"]
#[doc = r" fn main() {"]
#[doc = r"     let _x = 5;"]
#[doc = r#"     println!("{}", _x = 1); // Prints 1, will trigger lint"#]
#[doc = r""]
#[doc = r#"     println!("{}", _x); // Prints 5, no lint emitted"#]
#[doc = r#"     println!("{_x}", _x = _x); // Prints 5, no lint emitted"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Rust formatting strings can refer to named arguments by their position, but this usage is"]
#[doc =
r" potentially confusing. In particular, readers can incorrectly assume that the declaration"]
#[doc =
r" of named arguments is an assignment (which would produce the unit type)."]
#[doc = r" For backwards compatibility, this is not a hard error."]
pub static NAMED_ARGUMENTS_USED_POSITIONALLY: &crate::Lint =
    &crate::Lint {
            name: "NAMED_ARGUMENTS_USED_POSITIONALLY",
            default_level: crate::Warn,
            desc: "named arguments in format used positionally",
            ..
        };declare_lint! {
4160    /// The `named_arguments_used_positionally` lint detects cases where named arguments are only
4161    /// used positionally in format strings. This usage is valid but potentially very confusing.
4162    ///
4163    /// ### Example
4164    ///
4165    /// ```rust,compile_fail
4166    /// #![deny(named_arguments_used_positionally)]
4167    /// fn main() {
4168    ///     let _x = 5;
4169    ///     println!("{}", _x = 1); // Prints 1, will trigger lint
4170    ///
4171    ///     println!("{}", _x); // Prints 5, no lint emitted
4172    ///     println!("{_x}", _x = _x); // Prints 5, no lint emitted
4173    /// }
4174    /// ```
4175    ///
4176    /// {{produces}}
4177    ///
4178    /// ### Explanation
4179    ///
4180    /// Rust formatting strings can refer to named arguments by their position, but this usage is
4181    /// potentially confusing. In particular, readers can incorrectly assume that the declaration
4182    /// of named arguments is an assignment (which would produce the unit type).
4183    /// For backwards compatibility, this is not a hard error.
4184    pub NAMED_ARGUMENTS_USED_POSITIONALLY,
4185    Warn,
4186    "named arguments in format used positionally"
4187}
4188
4189#[doc =
r" The `never_type_fallback_flowing_into_unsafe` lint detects cases where never type fallback"]
#[doc = r" affects unsafe function calls."]
#[doc = r""]
#[doc = r" ### Never type fallback"]
#[doc = r""]
#[doc =
r" When the compiler sees a value of type [`!`] it implicitly inserts a coercion (if possible),"]
#[doc = r" to allow type check to infer any type:"]
#[doc = r""]
#[doc = r" ```ignore (illustrative-and-has-placeholders)"]
#[doc = r" // this"]
#[doc = r" let x: u8 = panic!();"]
#[doc = r""]
#[doc = r" // is (essentially) turned by the compiler into"]
#[doc = r" let x: u8 = absurd(panic!());"]
#[doc = r""]
#[doc = r" // where absurd is a function with the following signature"]
#[doc = r" // (it's sound, because `!` always marks unreachable code):"]
#[doc = r" fn absurd<T>(never: !) -> T { ... }"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" While it's convenient to be able to use non-diverging code in one of the branches (like"]
#[doc =
r" `if a { b } else { return }`) this could lead to compilation errors:"]
#[doc = r""]
#[doc = r" ```compile_fail"]
#[doc = r" // this"]
#[doc = r" { panic!() };"]
#[doc = r""]
#[doc = r" // gets turned into this"]
#[doc = r" { absurd(panic!()) }; // error: can't infer the type of `absurd`"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" To prevent such errors, compiler remembers where it inserted `absurd` calls, and if it"]
#[doc =
r" can't infer their type, it sets the type to fallback. `{ absurd::<Fallback>(panic!()) };`."]
#[doc = r#" This is what is known as "never type fallback"."#]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" fn main() {"]
#[doc = r"     if true {"]
#[doc =
r"         // return has type `!` which, is some cases, causes never type fallback"]
#[doc = r"         return"]
#[doc = r"     } else {"]
#[doc =
r"         // `zeroed` is an unsafe function, which returns an unbounded type"]
#[doc = r"         unsafe { std::mem::zeroed() }"]
#[doc = r"     };"]
#[doc =
r"     // depending on the fallback, `zeroed` may create `()` (which is completely sound),"]
#[doc = r"     // or `!` (which is instant undefined behavior)"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The never type fallback used to be `()`, meaning that `!` got spontaneously coerced to `()`."]
#[doc =
r" Since then the never type fallback has been changed to `!`, making the above code undefined"]
#[doc =
r" behavior. Instead of depending on the fallback, you should specify the type explicitly:"]
#[doc = r" ```"]
#[doc = r" if true {"]
#[doc = r"     return"]
#[doc = r" } else {"]
#[doc =
r"     // type is explicitly specified, fallback can't hurt us no more"]
#[doc = r"     unsafe { std::mem::zeroed::<()>() }"]
#[doc = r" };"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" See [Tracking Issue for making `!` fall back to `!`](https://github.com/rust-lang/rust/issues/123748)."]
#[doc = r""]
#[doc = r" [`!`]: https://doc.rust-lang.org/core/primitive.never.html"]
#[doc = r" [`()`]: https://doc.rust-lang.org/core/primitive.unit.html"]
pub static NEVER_TYPE_FALLBACK_FLOWING_INTO_UNSAFE: &crate::Lint =
    &crate::Lint {
            name: "NEVER_TYPE_FALLBACK_FLOWING_INTO_UNSAFE",
            default_level: crate::Deny,
            desc: "never type fallback affecting unsafe function calls",
            report_in_external_macro: true,
            ..
        };declare_lint! {
4190    /// The `never_type_fallback_flowing_into_unsafe` lint detects cases where never type fallback
4191    /// affects unsafe function calls.
4192    ///
4193    /// ### Never type fallback
4194    ///
4195    /// When the compiler sees a value of type [`!`] it implicitly inserts a coercion (if possible),
4196    /// to allow type check to infer any type:
4197    ///
4198    /// ```ignore (illustrative-and-has-placeholders)
4199    /// // this
4200    /// let x: u8 = panic!();
4201    ///
4202    /// // is (essentially) turned by the compiler into
4203    /// let x: u8 = absurd(panic!());
4204    ///
4205    /// // where absurd is a function with the following signature
4206    /// // (it's sound, because `!` always marks unreachable code):
4207    /// fn absurd<T>(never: !) -> T { ... }
4208    /// ```
4209    ///
4210    /// While it's convenient to be able to use non-diverging code in one of the branches (like
4211    /// `if a { b } else { return }`) this could lead to compilation errors:
4212    ///
4213    /// ```compile_fail
4214    /// // this
4215    /// { panic!() };
4216    ///
4217    /// // gets turned into this
4218    /// { absurd(panic!()) }; // error: can't infer the type of `absurd`
4219    /// ```
4220    ///
4221    /// To prevent such errors, compiler remembers where it inserted `absurd` calls, and if it
4222    /// can't infer their type, it sets the type to fallback. `{ absurd::<Fallback>(panic!()) };`.
4223    /// This is what is known as "never type fallback".
4224    ///
4225    /// ### Example
4226    ///
4227    /// ```rust,compile_fail
4228    /// fn main() {
4229    ///     if true {
4230    ///         // return has type `!` which, is some cases, causes never type fallback
4231    ///         return
4232    ///     } else {
4233    ///         // `zeroed` is an unsafe function, which returns an unbounded type
4234    ///         unsafe { std::mem::zeroed() }
4235    ///     };
4236    ///     // depending on the fallback, `zeroed` may create `()` (which is completely sound),
4237    ///     // or `!` (which is instant undefined behavior)
4238    /// }
4239    /// ```
4240    ///
4241    /// {{produces}}
4242    ///
4243    /// ### Explanation
4244    ///
4245    /// The never type fallback used to be `()`, meaning that `!` got spontaneously coerced to `()`.
4246    /// Since then the never type fallback has been changed to `!`, making the above code undefined
4247    /// behavior. Instead of depending on the fallback, you should specify the type explicitly:
4248    /// ```
4249    /// if true {
4250    ///     return
4251    /// } else {
4252    ///     // type is explicitly specified, fallback can't hurt us no more
4253    ///     unsafe { std::mem::zeroed::<()>() }
4254    /// };
4255    /// ```
4256    ///
4257    /// See [Tracking Issue for making `!` fall back to `!`](https://github.com/rust-lang/rust/issues/123748).
4258    ///
4259    /// [`!`]: https://doc.rust-lang.org/core/primitive.never.html
4260    /// [`()`]: https://doc.rust-lang.org/core/primitive.unit.html
4261    pub NEVER_TYPE_FALLBACK_FLOWING_INTO_UNSAFE,
4262    Deny,
4263    "never type fallback affecting unsafe function calls",
4264    report_in_external_macro
4265}
4266
4267#[doc =
r" The `invalid_macro_export_arguments` lint detects cases where `#[macro_export]` is being used with invalid arguments."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(invalid_macro_export_arguments)]"]
#[doc = r""]
#[doc = r" #[macro_export(invalid_parameter)]"]
#[doc = r" macro_rules! myMacro {"]
#[doc = r"    () => {"]
#[doc = r"         // [...]"]
#[doc = r"    }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" #[macro_export(too, many, items)]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The only valid argument is `#[macro_export(local_inner_macros)]` or no argument (`#[macro_export]`)."]
#[doc =
r" You can't have multiple arguments in a `#[macro_export(..)]`, or mention arguments other than `local_inner_macros`."]
#[doc = r""]
pub static INVALID_MACRO_EXPORT_ARGUMENTS: &crate::Lint =
    &crate::Lint {
            name: "INVALID_MACRO_EXPORT_ARGUMENTS",
            default_level: crate::Deny,
            desc: "\"invalid_parameter\" isn't a valid argument for `#[macro_export]`",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 57571,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
4268    /// The `invalid_macro_export_arguments` lint detects cases where `#[macro_export]` is being used with invalid arguments.
4269    ///
4270    /// ### Example
4271    ///
4272    /// ```rust,compile_fail
4273    /// #![deny(invalid_macro_export_arguments)]
4274    ///
4275    /// #[macro_export(invalid_parameter)]
4276    /// macro_rules! myMacro {
4277    ///    () => {
4278    ///         // [...]
4279    ///    }
4280    /// }
4281    ///
4282    /// #[macro_export(too, many, items)]
4283    /// ```
4284    ///
4285    /// {{produces}}
4286    ///
4287    /// ### Explanation
4288    ///
4289    /// The only valid argument is `#[macro_export(local_inner_macros)]` or no argument (`#[macro_export]`).
4290    /// You can't have multiple arguments in a `#[macro_export(..)]`, or mention arguments other than `local_inner_macros`.
4291    ///
4292    pub INVALID_MACRO_EXPORT_ARGUMENTS,
4293    Deny,
4294    "\"invalid_parameter\" isn't a valid argument for `#[macro_export]`",
4295    @future_incompatible = FutureIncompatibleInfo {
4296        reason: fcw!(FutureReleaseError #57571),
4297        report_in_deps: true,
4298    };
4299}
4300
4301#[doc =
r" The `ambiguous_derive_helpers` lint detects cases where a derive macro's helper attribute"]
#[doc = r" is the same name as that of a built-in attribute."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (proc-macro)"]
#[doc = r#" #![crate_type = "proc-macro"]"#]
#[doc = r" #![deny(ambiguous_derive_helpers)]"]
#[doc = r""]
#[doc = r" use proc_macro::TokenStream;"]
#[doc = r""]
#[doc = r" #[proc_macro_derive(Trait, attributes(ignore))]"]
#[doc = r" pub fn example(input: TokenStream) -> TokenStream {"]
#[doc = r"     TokenStream::new()"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" Produces:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" warning: there exists a built-in attribute with the same name"]
#[doc = r"   --> file.rs:5:39"]
#[doc = r"    |"]
#[doc = r"  5 | #[proc_macro_derive(Trait, attributes(ignore))]"]
#[doc = r"    |                                       ^^^^^^"]
#[doc = r"    |"]
#[doc =
r"    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"    = note: for more information, see issue #151152 <https://github.com/rust-lang/rust/issues/151152>"]
#[doc =
r"    = note: `#[deny(ambiguous_derive_helpers)]` (part of `#[deny(future_incompatible)]`) on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Attempting to use this helper attribute will throw an error:"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs-dependency)"]
#[doc = r" #[derive(Trait)]"]
#[doc = r" struct Example {"]
#[doc = r"     #[ignore]"]
#[doc = r"     fields: ()"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" Produces:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" error[E0659]: `ignore` is ambiguous"]
#[doc = r"  --> src/lib.rs:5:7"]
#[doc = r"   |"]
#[doc = r" 5 |     #[ignore]"]
#[doc = r"   |       ^^^^^^ ambiguous name"]
#[doc = r"   |"]
#[doc =
r"   = note: ambiguous because of a name conflict with a builtin attribute"]
#[doc = r"   = note: `ignore` could refer to a built-in attribute"]
#[doc =
r" note: `ignore` could also refer to the derive helper attribute defined here"]
#[doc = r"  --> src/lib.rs:3:10"]
#[doc = r"   |"]
#[doc = r" 3 | #[derive(Trait)]"]
#[doc = r"   |          ^^^^^"]
#[doc = r" ```"]
pub static AMBIGUOUS_DERIVE_HELPERS: &crate::Lint =
    &crate::Lint {
            name: "AMBIGUOUS_DERIVE_HELPERS",
            default_level: crate::Warn,
            desc: "detects derive helper attributes that are ambiguous with built-in attributes",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 151276,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
4302    /// The `ambiguous_derive_helpers` lint detects cases where a derive macro's helper attribute
4303    /// is the same name as that of a built-in attribute.
4304    ///
4305    /// ### Example
4306    ///
4307    /// ```rust,ignore (proc-macro)
4308    /// #![crate_type = "proc-macro"]
4309    /// #![deny(ambiguous_derive_helpers)]
4310    ///
4311    /// use proc_macro::TokenStream;
4312    ///
4313    /// #[proc_macro_derive(Trait, attributes(ignore))]
4314    /// pub fn example(input: TokenStream) -> TokenStream {
4315    ///     TokenStream::new()
4316    /// }
4317    /// ```
4318    ///
4319    /// Produces:
4320    ///
4321    /// ```text
4322    /// warning: there exists a built-in attribute with the same name
4323    ///   --> file.rs:5:39
4324    ///    |
4325    ///  5 | #[proc_macro_derive(Trait, attributes(ignore))]
4326    ///    |                                       ^^^^^^
4327    ///    |
4328    ///    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
4329    ///    = note: for more information, see issue #151152 <https://github.com/rust-lang/rust/issues/151152>
4330    ///    = note: `#[deny(ambiguous_derive_helpers)]` (part of `#[deny(future_incompatible)]`) on by default
4331    /// ```
4332    ///
4333    /// ### Explanation
4334    ///
4335    /// Attempting to use this helper attribute will throw an error:
4336    ///
4337    /// ```rust,ignore (needs-dependency)
4338    /// #[derive(Trait)]
4339    /// struct Example {
4340    ///     #[ignore]
4341    ///     fields: ()
4342    /// }
4343    /// ```
4344    ///
4345    /// Produces:
4346    ///
4347    /// ```text
4348    /// error[E0659]: `ignore` is ambiguous
4349    ///  --> src/lib.rs:5:7
4350    ///   |
4351    /// 5 |     #[ignore]
4352    ///   |       ^^^^^^ ambiguous name
4353    ///   |
4354    ///   = note: ambiguous because of a name conflict with a builtin attribute
4355    ///   = note: `ignore` could refer to a built-in attribute
4356    /// note: `ignore` could also refer to the derive helper attribute defined here
4357    ///  --> src/lib.rs:3:10
4358    ///   |
4359    /// 3 | #[derive(Trait)]
4360    ///   |          ^^^^^
4361    /// ```
4362    pub AMBIGUOUS_DERIVE_HELPERS,
4363    Warn,
4364    "detects derive helper attributes that are ambiguous with built-in attributes",
4365    @future_incompatible = FutureIncompatibleInfo {
4366        reason: fcw!(FutureReleaseError #151276),
4367    };
4368}
4369
4370#[doc =
r" The `private_interfaces` lint detects types in a primary interface of an item,"]
#[doc =
r" that are more private than the item itself. Primary interface of an item is all"]
#[doc =
r" its interface except for bounds on generic parameters and where clauses."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" # #![allow(unused)]"]
#[doc = r" #![deny(private_interfaces)]"]
#[doc = r" struct SemiPriv;"]
#[doc = r""]
#[doc = r" mod m1 {"]
#[doc = r"     struct Priv;"]
#[doc = r"     impl crate::SemiPriv {"]
#[doc = r"         pub fn f(_: Priv) {}"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" # fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Having something private in primary interface guarantees that"]
#[doc = r" the item will be unusable from outer modules due to type privacy."]
pub static PRIVATE_INTERFACES: &crate::Lint =
    &crate::Lint {
            name: "PRIVATE_INTERFACES",
            default_level: crate::Warn,
            desc: "private type in primary interface of an item",
            ..
        };declare_lint! {
4371    /// The `private_interfaces` lint detects types in a primary interface of an item,
4372    /// that are more private than the item itself. Primary interface of an item is all
4373    /// its interface except for bounds on generic parameters and where clauses.
4374    ///
4375    /// ### Example
4376    ///
4377    /// ```rust,compile_fail
4378    /// # #![allow(unused)]
4379    /// #![deny(private_interfaces)]
4380    /// struct SemiPriv;
4381    ///
4382    /// mod m1 {
4383    ///     struct Priv;
4384    ///     impl crate::SemiPriv {
4385    ///         pub fn f(_: Priv) {}
4386    ///     }
4387    /// }
4388    ///
4389    /// # fn main() {}
4390    /// ```
4391    ///
4392    /// {{produces}}
4393    ///
4394    /// ### Explanation
4395    ///
4396    /// Having something private in primary interface guarantees that
4397    /// the item will be unusable from outer modules due to type privacy.
4398    pub PRIVATE_INTERFACES,
4399    Warn,
4400    "private type in primary interface of an item",
4401}
4402
4403#[doc =
r" The `private_bounds` lint detects types in a secondary interface of an item,"]
#[doc =
r" that are more private than the item itself. Secondary interface of an item consists of"]
#[doc =
r" bounds on generic parameters and where clauses, including supertraits for trait items."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" # #![allow(unused)]"]
#[doc = r" #![deny(private_bounds)]"]
#[doc = r""]
#[doc = r" struct PrivTy;"]
#[doc = r" pub struct S"]
#[doc = r"     where PrivTy:"]
#[doc = r" {}"]
#[doc = r" # fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Having private types or traits in item bounds makes it less clear what interface"]
#[doc = r" the item actually provides."]
pub static PRIVATE_BOUNDS: &crate::Lint =
    &crate::Lint {
            name: "PRIVATE_BOUNDS",
            default_level: crate::Warn,
            desc: "private type in secondary interface of an item",
            ..
        };declare_lint! {
4404    /// The `private_bounds` lint detects types in a secondary interface of an item,
4405    /// that are more private than the item itself. Secondary interface of an item consists of
4406    /// bounds on generic parameters and where clauses, including supertraits for trait items.
4407    ///
4408    /// ### Example
4409    ///
4410    /// ```rust,compile_fail
4411    /// # #![allow(unused)]
4412    /// #![deny(private_bounds)]
4413    ///
4414    /// struct PrivTy;
4415    /// pub struct S
4416    ///     where PrivTy:
4417    /// {}
4418    /// # fn main() {}
4419    /// ```
4420    ///
4421    /// {{produces}}
4422    ///
4423    /// ### Explanation
4424    ///
4425    /// Having private types or traits in item bounds makes it less clear what interface
4426    /// the item actually provides.
4427    pub PRIVATE_BOUNDS,
4428    Warn,
4429    "private type in secondary interface of an item",
4430}
4431
4432#[doc =
r" The `unnameable_types` lint detects types for which you can get objects of that type,"]
#[doc = r" but cannot name the type itself."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" # #![allow(unused)]"]
#[doc = r" #![deny(unnameable_types)]"]
#[doc = r" mod m {"]
#[doc = r"     pub struct S;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" pub fn get_unnameable() -> m::S { m::S }"]
#[doc = r" # fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is often expected that if you can obtain an object of type `T`, then"]
#[doc =
r" you can name the type `T` as well; this lint attempts to enforce this rule."]
#[doc =
r" The recommended action is to either reexport the type properly to make it nameable,"]
#[doc =
r" or document that users are not supposed to be able to name it for one reason or another."]
#[doc = r""]
#[doc =
r" Besides types, this lint applies to traits because traits can also leak through signatures,"]
#[doc =
r" and you may obtain objects of their `dyn Trait` or `impl Trait` types."]
pub static UNNAMEABLE_TYPES: &crate::Lint =
    &crate::Lint {
            name: "UNNAMEABLE_TYPES",
            default_level: crate::Allow,
            desc: "effective visibility of a type is larger than the area in which it can be named",
            ..
        };declare_lint! {
4433    /// The `unnameable_types` lint detects types for which you can get objects of that type,
4434    /// but cannot name the type itself.
4435    ///
4436    /// ### Example
4437    ///
4438    /// ```rust,compile_fail
4439    /// # #![allow(unused)]
4440    /// #![deny(unnameable_types)]
4441    /// mod m {
4442    ///     pub struct S;
4443    /// }
4444    ///
4445    /// pub fn get_unnameable() -> m::S { m::S }
4446    /// # fn main() {}
4447    /// ```
4448    ///
4449    /// {{produces}}
4450    ///
4451    /// ### Explanation
4452    ///
4453    /// It is often expected that if you can obtain an object of type `T`, then
4454    /// you can name the type `T` as well; this lint attempts to enforce this rule.
4455    /// The recommended action is to either reexport the type properly to make it nameable,
4456    /// or document that users are not supposed to be able to name it for one reason or another.
4457    ///
4458    /// Besides types, this lint applies to traits because traits can also leak through signatures,
4459    /// and you may obtain objects of their `dyn Trait` or `impl Trait` types.
4460    pub UNNAMEABLE_TYPES,
4461    Allow,
4462    "effective visibility of a type is larger than the area in which it can be named",
4463}
4464
4465#[doc =
r" The `malformed_diagnostic_attributes` lint detects malformed diagnostic attributes."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r#" #[diagnostic::do_not_recommend(message = "message")]"#]
#[doc = r" trait Trait {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is usually a mistake to use options or syntax that is not supported. Check the spelling,"]
#[doc =
r" and check the diagnostic attribute listing for the correct name and syntax. Also consider if"]
#[doc =
r" you are using an old version of the compiler; perhaps the option or syntax is only available"]
#[doc =
r" in a newer version. See the [reference] for a list of diagnostic attributes and the syntax"]
#[doc = r" of each."]
#[doc = r""]
#[doc =
r" [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace"]
pub static MALFORMED_DIAGNOSTIC_ATTRIBUTES: &crate::Lint =
    &crate::Lint {
            name: "MALFORMED_DIAGNOSTIC_ATTRIBUTES",
            default_level: crate::Warn,
            desc: "detects malformed diagnostic attributes",
            ..
        };declare_lint! {
4466    /// The `malformed_diagnostic_attributes` lint detects malformed diagnostic attributes.
4467    ///
4468    /// ### Example
4469    ///
4470    /// ```rust
4471    /// #[diagnostic::do_not_recommend(message = "message")]
4472    /// trait Trait {}
4473    /// ```
4474    ///
4475    /// {{produces}}
4476    ///
4477    /// ### Explanation
4478    ///
4479    /// It is usually a mistake to use options or syntax that is not supported. Check the spelling,
4480    /// and check the diagnostic attribute listing for the correct name and syntax. Also consider if
4481    /// you are using an old version of the compiler; perhaps the option or syntax is only available
4482    /// in a newer version. See the [reference] for a list of diagnostic attributes and the syntax
4483    /// of each.
4484    ///
4485    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
4486    pub MALFORMED_DIAGNOSTIC_ATTRIBUTES,
4487    Warn,
4488    "detects malformed diagnostic attributes",
4489}
4490
4491#[doc =
r" The `misplaced_diagnostic_attributes` lint detects wrongly placed diagnostic attributes."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #[diagnostic::do_not_recommend]"]
#[doc = r" struct NotUserFacing;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is usually a mistake to specify a diagnostic attribute on an item it is not meant for."]
#[doc =
r" For example, `#[diagnostic::do_not_recommend]` can only be placed on trait implementations,"]
#[doc =
r" and does nothing if placed elsewhere. See the [reference] for a list of diagnostic"]
#[doc = r" attributes and their correct positions."]
#[doc = r""]
#[doc =
r" [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace"]
pub static MISPLACED_DIAGNOSTIC_ATTRIBUTES: &crate::Lint =
    &crate::Lint {
            name: "MISPLACED_DIAGNOSTIC_ATTRIBUTES",
            default_level: crate::Warn,
            desc: "detects diagnostic attributes that are placed on the wrong item",
            ..
        };declare_lint! {
4492    /// The `misplaced_diagnostic_attributes` lint detects wrongly placed diagnostic attributes.
4493    ///
4494    /// ### Example
4495    ///
4496    /// ```rust
4497    /// #[diagnostic::do_not_recommend]
4498    /// struct NotUserFacing;
4499    /// ```
4500    ///
4501    /// {{produces}}
4502    ///
4503    /// ### Explanation
4504    ///
4505    /// It is usually a mistake to specify a diagnostic attribute on an item it is not meant for.
4506    /// For example, `#[diagnostic::do_not_recommend]` can only be placed on trait implementations,
4507    /// and does nothing if placed elsewhere. See the [reference] for a list of diagnostic
4508    /// attributes and their correct positions.
4509    ///
4510    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
4511    pub MISPLACED_DIAGNOSTIC_ATTRIBUTES,
4512    Warn,
4513    "detects diagnostic attributes that are placed on the wrong item",
4514}
4515
4516#[doc =
r" The `unknown_diagnostic_attributes` lint detects unknown diagnostic attributes."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #[diagnostic::does_not_exist]"]
#[doc = r" struct Thing;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" It is usually a mistake to specify a diagnostic attribute that does not exist. Check the"]
#[doc =
r" spelling, and check the diagnostic attribute listing for the correct name. Also consider if"]
#[doc =
r" you are using an old version of the compiler and the attribute is only available in a newer"]
#[doc =
r" version. See the [reference] for the list of diagnostic attributes."]
#[doc = r""]
#[doc =
r" [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace"]
pub static UNKNOWN_DIAGNOSTIC_ATTRIBUTES: &crate::Lint =
    &crate::Lint {
            name: "UNKNOWN_DIAGNOSTIC_ATTRIBUTES",
            default_level: crate::Warn,
            desc: "detects unknown diagnostic attributes",
            ..
        };declare_lint! {
4517    /// The `unknown_diagnostic_attributes` lint detects unknown diagnostic attributes.
4518    ///
4519    /// ### Example
4520    ///
4521    /// ```rust
4522    /// #[diagnostic::does_not_exist]
4523    /// struct Thing;
4524    /// ```
4525    ///
4526    /// {{produces}}
4527    ///
4528    /// ### Explanation
4529    ///
4530    /// It is usually a mistake to specify a diagnostic attribute that does not exist. Check the
4531    /// spelling, and check the diagnostic attribute listing for the correct name. Also consider if
4532    /// you are using an old version of the compiler and the attribute is only available in a newer
4533    /// version. See the [reference] for the list of diagnostic attributes.
4534    ///
4535    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
4536    pub UNKNOWN_DIAGNOSTIC_ATTRIBUTES,
4537    Warn,
4538    "detects unknown diagnostic attributes",
4539}
4540
4541#[doc =
r" The `malformed_diagnostic_format_literals` lint detects malformed diagnostic format"]
#[doc = r" literals."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc =
r#" #[diagnostic::on_unimplemented(message = "{Self}} does not implement `Trait`")]"#]
#[doc = r" trait Trait {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The `#[diagnostic::on_unimplemented]` attribute accepts string literal values that are"]
#[doc =
r" similar to `format!`'s string literal. See the [reference] for details on what is permitted"]
#[doc = r" in this string literal."]
#[doc = r""]
#[doc =
r" [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace"]
pub static MALFORMED_DIAGNOSTIC_FORMAT_LITERALS: &crate::Lint =
    &crate::Lint {
            name: "MALFORMED_DIAGNOSTIC_FORMAT_LITERALS",
            default_level: crate::Warn,
            desc: "detects diagnostic attribute with malformed diagnostic format literals",
            ..
        };declare_lint! {
4542    /// The `malformed_diagnostic_format_literals` lint detects malformed diagnostic format
4543    /// literals.
4544    ///
4545    /// ### Example
4546    ///
4547    /// ```rust
4548    /// #[diagnostic::on_unimplemented(message = "{Self}} does not implement `Trait`")]
4549    /// trait Trait {}
4550    /// ```
4551    ///
4552    /// {{produces}}
4553    ///
4554    /// ### Explanation
4555    ///
4556    /// The `#[diagnostic::on_unimplemented]` attribute accepts string literal values that are
4557    /// similar to `format!`'s string literal. See the [reference] for details on what is permitted
4558    /// in this string literal.
4559    ///
4560    /// [reference]: https://doc.rust-lang.org/nightly/reference/attributes/diagnostics.html#the-diagnostic-tool-attribute-namespace
4561    pub MALFORMED_DIAGNOSTIC_FORMAT_LITERALS,
4562    Warn,
4563    "detects diagnostic attribute with malformed diagnostic format literals",
4564}
4565
4566#[doc =
r" The `malformed_diagnostic_filters` lint detects malformed filters in diagnostic"]
#[doc = r" attributes."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![feature(rustc_attrs)]"]
#[doc = r" #![allow(internal_features)]"]
#[doc = r""]
#[doc = r#" #[rustc_on_unimplemented(on(invalid, message = "unused"))]"#]
#[doc = r" trait Trait {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" A `rustc_on_unimplemented` filter must use a supported flag, a name-value predicate,"]
#[doc =
r" or the `all`, `any`, and `not` predicate operators. Invalid filters are ignored."]
pub static MALFORMED_DIAGNOSTIC_FILTERS: &crate::Lint =
    &crate::Lint {
            name: "MALFORMED_DIAGNOSTIC_FILTERS",
            default_level: crate::Warn,
            desc: "detects malformed filters in diagnostic attributes",
            feature_gate: Some(rustc_span::sym::rustc_attrs),
            ..
        };declare_lint! {
4567    /// The `malformed_diagnostic_filters` lint detects malformed filters in diagnostic
4568    /// attributes.
4569    ///
4570    /// ### Example
4571    ///
4572    /// ```rust
4573    /// #![feature(rustc_attrs)]
4574    /// #![allow(internal_features)]
4575    ///
4576    /// #[rustc_on_unimplemented(on(invalid, message = "unused"))]
4577    /// trait Trait {}
4578    /// ```
4579    ///
4580    /// {{produces}}
4581    ///
4582    /// ### Explanation
4583    ///
4584    /// A `rustc_on_unimplemented` filter must use a supported flag, a name-value predicate,
4585    /// or the `all`, `any`, and `not` predicate operators. Invalid filters are ignored.
4586    pub MALFORMED_DIAGNOSTIC_FILTERS,
4587    Warn,
4588    "detects malformed filters in diagnostic attributes",
4589    @feature_gate = rustc_attrs;
4590}
4591
4592#[doc =
r" The `ambiguous_glob_imports` lint detects glob imports that should report ambiguity"]
#[doc = r" errors, but previously didn't do that due to rustc bugs."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs extern crate)"]
#[doc = r" // library crate `my_library`"]
#[doc = r" mod mod1 { pub const C: u32 = 1; }"]
#[doc = r" mod mod2 { pub const C: u32 = 2; }"]
#[doc = r" pub use mod1::*;"]
#[doc = r" pub use mod2::*;"]
#[doc = r""]
#[doc = r" // another crate using `my_library`"]
#[doc = r" let c = my_library::C; // `C` is ambiguous"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Previous versions of Rust compile it successfully because"]
#[doc =
r" ambiguous glob imports weren't preserved correctly over crate boundaries."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a"]
#[doc = r" hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static AMBIGUOUS_GLOB_IMPORTS: &crate::Lint =
    &crate::Lint {
            name: "AMBIGUOUS_GLOB_IMPORTS",
            default_level: crate::Deny,
            desc: "detects certain glob imports that require reporting an ambiguity error",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 114095,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
4593    /// The `ambiguous_glob_imports` lint detects glob imports that should report ambiguity
4594    /// errors, but previously didn't do that due to rustc bugs.
4595    ///
4596    /// ### Example
4597    ///
4598    /// ```rust,ignore (needs extern crate)
4599    /// // library crate `my_library`
4600    /// mod mod1 { pub const C: u32 = 1; }
4601    /// mod mod2 { pub const C: u32 = 2; }
4602    /// pub use mod1::*;
4603    /// pub use mod2::*;
4604    ///
4605    /// // another crate using `my_library`
4606    /// let c = my_library::C; // `C` is ambiguous
4607    /// ```
4608    ///
4609    /// ### Explanation
4610    ///
4611    /// Previous versions of Rust compile it successfully because
4612    /// ambiguous glob imports weren't preserved correctly over crate boundaries.
4613    ///
4614    /// This is a [future-incompatible] lint to transition this to a
4615    /// hard error in the future.
4616    ///
4617    /// [future-incompatible]: ../index.md#future-incompatible-lints
4618    pub AMBIGUOUS_GLOB_IMPORTS,
4619    Deny,
4620    "detects certain glob imports that require reporting an ambiguity error",
4621    @future_incompatible = FutureIncompatibleInfo {
4622        reason: fcw!(FutureReleaseError #114095),
4623        report_in_deps: true,
4624    };
4625}
4626
4627#[doc =
r" The `ambiguous_glob_imported_traits` lint reports uses of traits that are"]
#[doc =
r" imported ambiguously via glob imports. Previously, this was not enforced"]
#[doc = r" due to a bug in rustc."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(ambiguous_glob_imported_traits)]"]
#[doc = r" mod m1 {"]
#[doc = r"    pub trait Foo {"]
#[doc = r"        fn method1(&self) {}"]
#[doc = r"    }"]
#[doc = r"    impl Foo for u8 {}"]
#[doc = r" }"]
#[doc = r" mod m2 {"]
#[doc = r"     pub trait Foo {"]
#[doc = r"         fn method2(&self) {}"]
#[doc = r"     }"]
#[doc = r"     impl Foo for u8 {}"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" mod m3{"]
#[doc = r"     pub struct Foo;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn trait_and_trait() {"]
#[doc = r"     use m1::*;"]
#[doc = r"     use m2::*;"]
#[doc = r"     0u8.method1();"]
#[doc = r"     0u8.method2();"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn trait_and_non_trait(){"]
#[doc = r"     use m1::*;"]
#[doc = r"     use m3::*;"]
#[doc = r"     0u8.method1();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Glob imports can bring multiple items with the same name into scope, creating an ambiguity"]
#[doc =
r" that name resolution has to resolve somehow. This lint reports two different situations"]
#[doc = r" where that happens:"]
#[doc = r""]
#[doc =
r" When two or more traits with the same name are glob imported (as in `trait_and_trait`),"]
#[doc =
r#" one of them becomes the "primary" trait, while the others are shadowed. Methods from"#]
#[doc =
r" the primary trait (e.g. `method1`) still resolve, but methods from the shadowed trait"]
#[doc =
r" (e.g. `method2`) become inaccessible. Ideally none of the ambiguous traits would be"]
#[doc =
r" usable at all, but this is allowed for backwards compatibility (for now)."]
#[doc = r""]
#[doc =
r" When a trait and a non-trait item with the same name are both glob imported (as in"]
#[doc =
r" `trait_and_non_trait`), the trait is currently recovered from the ambiguity and treated"]
#[doc =
r" as in scope, specifically so that this lint can still be reported; method resolution is"]
#[doc =
r" therefore not affected today. This is only possible because the ambiguity is a lint and"]
#[doc =
r" not a hard error. Once it becomes one, the trait will no longer be placed into scope."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a"]
#[doc = r" hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static AMBIGUOUS_GLOB_IMPORTED_TRAITS: &crate::Lint =
    &crate::Lint {
            name: "AMBIGUOUS_GLOB_IMPORTED_TRAITS",
            default_level: crate::Warn,
            desc: "detects uses of ambiguously glob imported traits",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 152822,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
4628    /// The `ambiguous_glob_imported_traits` lint reports uses of traits that are
4629    /// imported ambiguously via glob imports. Previously, this was not enforced
4630    /// due to a bug in rustc.
4631    ///
4632    /// ### Example
4633    ///
4634    /// ```rust,compile_fail
4635    /// #![deny(ambiguous_glob_imported_traits)]
4636    /// mod m1 {
4637    ///    pub trait Foo {
4638    ///        fn method1(&self) {}
4639    ///    }
4640    ///    impl Foo for u8 {}
4641    /// }
4642    /// mod m2 {
4643    ///     pub trait Foo {
4644    ///         fn method2(&self) {}
4645    ///     }
4646    ///     impl Foo for u8 {}
4647    /// }
4648    ///
4649    /// mod m3{
4650    ///     pub struct Foo;
4651    /// }
4652    ///
4653    /// fn trait_and_trait() {
4654    ///     use m1::*;
4655    ///     use m2::*;
4656    ///     0u8.method1();
4657    ///     0u8.method2();
4658    /// }
4659    ///
4660    /// fn trait_and_non_trait(){
4661    ///     use m1::*;
4662    ///     use m3::*;
4663    ///     0u8.method1();
4664    /// }
4665    /// ```
4666    ///
4667    /// {{produces}}
4668    ///
4669    /// ### Explanation
4670    ///
4671    /// Glob imports can bring multiple items with the same name into scope, creating an ambiguity
4672    /// that name resolution has to resolve somehow. This lint reports two different situations
4673    /// where that happens:
4674    ///
4675    /// When two or more traits with the same name are glob imported (as in `trait_and_trait`),
4676    /// one of them becomes the "primary" trait, while the others are shadowed. Methods from
4677    /// the primary trait (e.g. `method1`) still resolve, but methods from the shadowed trait
4678    /// (e.g. `method2`) become inaccessible. Ideally none of the ambiguous traits would be
4679    /// usable at all, but this is allowed for backwards compatibility (for now).
4680    ///
4681    /// When a trait and a non-trait item with the same name are both glob imported (as in
4682    /// `trait_and_non_trait`), the trait is currently recovered from the ambiguity and treated
4683    /// as in scope, specifically so that this lint can still be reported; method resolution is
4684    /// therefore not affected today. This is only possible because the ambiguity is a lint and
4685    /// not a hard error. Once it becomes one, the trait will no longer be placed into scope.
4686    ///
4687    /// This is a [future-incompatible] lint to transition this to a
4688    /// hard error in the future.
4689    ///
4690    /// [future-incompatible]: ../index.md#future-incompatible-lints
4691    pub AMBIGUOUS_GLOB_IMPORTED_TRAITS,
4692    Warn,
4693    "detects uses of ambiguously glob imported traits",
4694    @future_incompatible = FutureIncompatibleInfo {
4695        reason: fcw!(FutureReleaseError #152822),
4696        report_in_deps: false,
4697    };
4698}
4699
4700#[doc =
r" The `ambiguous_panic_imports` lint detects ambiguous core and std panic imports, but"]
#[doc =
r" previously didn't do that due to `#[macro_use]` prelude macro import."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(ambiguous_panic_imports)]"]
#[doc = r" #![no_std]"]
#[doc = r""]
#[doc = r" extern crate std;"]
#[doc = r" use std::prelude::v1::*;"]
#[doc = r""]
#[doc = r" fn xx() {"]
#[doc = r"     panic!(); // resolves to core::panic"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Future versions of Rust will no longer accept the ambiguous resolution."]
#[doc = r""]
#[doc =
r" This is a [future-incompatible] lint to transition this to a hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static AMBIGUOUS_PANIC_IMPORTS: &crate::Lint =
    &crate::Lint {
            name: "AMBIGUOUS_PANIC_IMPORTS",
            default_level: crate::Warn,
            desc: "detects ambiguous core and std panic imports",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 147319,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
4701    /// The `ambiguous_panic_imports` lint detects ambiguous core and std panic imports, but
4702    /// previously didn't do that due to `#[macro_use]` prelude macro import.
4703    ///
4704    /// ### Example
4705    ///
4706    /// ```rust,compile_fail
4707    /// #![deny(ambiguous_panic_imports)]
4708    /// #![no_std]
4709    ///
4710    /// extern crate std;
4711    /// use std::prelude::v1::*;
4712    ///
4713    /// fn xx() {
4714    ///     panic!(); // resolves to core::panic
4715    /// }
4716    /// ```
4717    ///
4718    /// {{produces}}
4719    ///
4720    /// ### Explanation
4721    ///
4722    /// Future versions of Rust will no longer accept the ambiguous resolution.
4723    ///
4724    /// This is a [future-incompatible] lint to transition this to a hard error in the future.
4725    ///
4726    /// [future-incompatible]: ../index.md#future-incompatible-lints
4727    pub AMBIGUOUS_PANIC_IMPORTS,
4728    Warn,
4729    "detects ambiguous core and std panic imports",
4730    @future_incompatible = FutureIncompatibleInfo {
4731        reason: fcw!(FutureReleaseError #147319),
4732        report_in_deps: false,
4733    };
4734}
4735
4736#[doc =
r" The `ambiguous_import_visibilities` lint detects imports that should report ambiguity"]
#[doc = r" errors, but previously didn't do that due to rustc bugs."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(unknown_lints)]"]
#[doc = r" #![deny(ambiguous_import_visibilities)]"]
#[doc = r" mod reexport {"]
#[doc = r"     mod m {"]
#[doc = r"         pub struct S {}"]
#[doc = r"     }"]
#[doc = r""]
#[doc = r"     macro_rules! mac {"]
#[doc = r"         () => { use m::S; }"]
#[doc = r"     }"]
#[doc = r""]
#[doc = r"     pub use m::*;"]
#[doc = r"     mac!();"]
#[doc = r""]
#[doc = r"     pub use S as Z; // ambiguous visibility"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     reexport::Z {};"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Previous versions of Rust compile it successfully because it"]
#[doc =
r" fetched the glob import's visibility for `pub use S as Z` import, and ignored the private"]
#[doc = r" `use m::S` import that appeared later."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a"]
#[doc = r" hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static AMBIGUOUS_IMPORT_VISIBILITIES: &crate::Lint =
    &crate::Lint {
            name: "AMBIGUOUS_IMPORT_VISIBILITIES",
            default_level: crate::Warn,
            desc: "detects certain glob imports that require reporting an ambiguity error",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 149145,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
4737    /// The `ambiguous_import_visibilities` lint detects imports that should report ambiguity
4738    /// errors, but previously didn't do that due to rustc bugs.
4739    ///
4740    /// ### Example
4741    ///
4742    /// ```rust,compile_fail
4743    /// #![deny(unknown_lints)]
4744    /// #![deny(ambiguous_import_visibilities)]
4745    /// mod reexport {
4746    ///     mod m {
4747    ///         pub struct S {}
4748    ///     }
4749    ///
4750    ///     macro_rules! mac {
4751    ///         () => { use m::S; }
4752    ///     }
4753    ///
4754    ///     pub use m::*;
4755    ///     mac!();
4756    ///
4757    ///     pub use S as Z; // ambiguous visibility
4758    /// }
4759    ///
4760    /// fn main() {
4761    ///     reexport::Z {};
4762    /// }
4763    /// ```
4764    ///
4765    /// {{produces}}
4766    ///
4767    /// ### Explanation
4768    ///
4769    /// Previous versions of Rust compile it successfully because it
4770    /// fetched the glob import's visibility for `pub use S as Z` import, and ignored the private
4771    /// `use m::S` import that appeared later.
4772    ///
4773    /// This is a [future-incompatible] lint to transition this to a
4774    /// hard error in the future.
4775    ///
4776    /// [future-incompatible]: ../index.md#future-incompatible-lints
4777    pub AMBIGUOUS_IMPORT_VISIBILITIES,
4778    Warn,
4779    "detects certain glob imports that require reporting an ambiguity error",
4780    @future_incompatible = FutureIncompatibleInfo {
4781        reason: fcw!(FutureReleaseError #149145),
4782    };
4783}
4784
4785#[doc =
r" The `refining_impl_trait_reachable` lint detects `impl Trait` return"]
#[doc =
r" types in method signatures that are refined by a publically reachable"]
#[doc =
r" trait implementation, meaning the implementation adds information about"]
#[doc = r" the return type that is not present in the trait."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(refining_impl_trait)]"]
#[doc = r""]
#[doc = r" use std::fmt::Display;"]
#[doc = r""]
#[doc = r" pub trait AsDisplay {"]
#[doc = r"     fn as_display(&self) -> impl Display;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl<'s> AsDisplay for &'s str {"]
#[doc = r"     fn as_display(&self) -> Self {"]
#[doc = r"         *self"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     // users can observe that the return type of"]
#[doc = r"     // `<&str as AsDisplay>::as_display()` is `&str`."]
#[doc = r#"     let _x: &str = "".as_display();"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Callers of methods for types where the implementation is known are"]
#[doc =
r" able to observe the types written in the impl signature. This may be"]
#[doc =
r" intended behavior, but may also lead to implementation details being"]
#[doc =
r" revealed unintentionally. In particular, it may pose a semver hazard"]
#[doc =
r" for authors of libraries who do not wish to make stronger guarantees"]
#[doc = r" about the types than what is written in the trait signature."]
#[doc = r""]
#[doc = r" `refining_impl_trait` is a lint group composed of two lints:"]
#[doc = r""]
#[doc =
r" * `refining_impl_trait_reachable`, for refinements that are publically"]
#[doc = r"   reachable outside a crate, and"]
#[doc =
r" * `refining_impl_trait_internal`, for refinements that are only visible"]
#[doc = r"    within a crate."]
#[doc = r""]
#[doc = r" We are seeking feedback on each of these lints; see issue"]
#[doc =
r" [#121718](https://github.com/rust-lang/rust/issues/121718) for more"]
#[doc = r" information."]
pub static REFINING_IMPL_TRAIT_REACHABLE: &crate::Lint =
    &crate::Lint {
            name: "REFINING_IMPL_TRAIT_REACHABLE",
            default_level: crate::Warn,
            desc: "impl trait in impl method signature does not match trait method signature",
            ..
        };declare_lint! {
4786    /// The `refining_impl_trait_reachable` lint detects `impl Trait` return
4787    /// types in method signatures that are refined by a publically reachable
4788    /// trait implementation, meaning the implementation adds information about
4789    /// the return type that is not present in the trait.
4790    ///
4791    /// ### Example
4792    ///
4793    /// ```rust,compile_fail
4794    /// #![deny(refining_impl_trait)]
4795    ///
4796    /// use std::fmt::Display;
4797    ///
4798    /// pub trait AsDisplay {
4799    ///     fn as_display(&self) -> impl Display;
4800    /// }
4801    ///
4802    /// impl<'s> AsDisplay for &'s str {
4803    ///     fn as_display(&self) -> Self {
4804    ///         *self
4805    ///     }
4806    /// }
4807    ///
4808    /// fn main() {
4809    ///     // users can observe that the return type of
4810    ///     // `<&str as AsDisplay>::as_display()` is `&str`.
4811    ///     let _x: &str = "".as_display();
4812    /// }
4813    /// ```
4814    ///
4815    /// {{produces}}
4816    ///
4817    /// ### Explanation
4818    ///
4819    /// Callers of methods for types where the implementation is known are
4820    /// able to observe the types written in the impl signature. This may be
4821    /// intended behavior, but may also lead to implementation details being
4822    /// revealed unintentionally. In particular, it may pose a semver hazard
4823    /// for authors of libraries who do not wish to make stronger guarantees
4824    /// about the types than what is written in the trait signature.
4825    ///
4826    /// `refining_impl_trait` is a lint group composed of two lints:
4827    ///
4828    /// * `refining_impl_trait_reachable`, for refinements that are publically
4829    ///   reachable outside a crate, and
4830    /// * `refining_impl_trait_internal`, for refinements that are only visible
4831    ///    within a crate.
4832    ///
4833    /// We are seeking feedback on each of these lints; see issue
4834    /// [#121718](https://github.com/rust-lang/rust/issues/121718) for more
4835    /// information.
4836    pub REFINING_IMPL_TRAIT_REACHABLE,
4837    Warn,
4838    "impl trait in impl method signature does not match trait method signature",
4839}
4840
4841#[doc =
r" The `refining_impl_trait_internal` lint detects `impl Trait` return"]
#[doc =
r" types in method signatures that are refined by a trait implementation,"]
#[doc =
r" meaning the implementation adds information about the return type that"]
#[doc = r" is not present in the trait."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(refining_impl_trait)]"]
#[doc = r""]
#[doc = r" use std::fmt::Display;"]
#[doc = r""]
#[doc = r" trait AsDisplay {"]
#[doc = r"     fn as_display(&self) -> impl Display;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl<'s> AsDisplay for &'s str {"]
#[doc = r"     fn as_display(&self) -> Self {"]
#[doc = r"         *self"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     // users can observe that the return type of"]
#[doc = r"     // `<&str as AsDisplay>::as_display()` is `&str`."]
#[doc = r#"     let _x: &str = "".as_display();"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Callers of methods for types where the implementation is known are"]
#[doc =
r" able to observe the types written in the impl signature. This may be"]
#[doc =
r" intended behavior, but may also lead to implementation details being"]
#[doc =
r" revealed unintentionally. In particular, it may pose a semver hazard"]
#[doc =
r" for authors of libraries who do not wish to make stronger guarantees"]
#[doc = r" about the types than what is written in the trait signature."]
#[doc = r""]
#[doc = r" `refining_impl_trait` is a lint group composed of two lints:"]
#[doc = r""]
#[doc =
r" * `refining_impl_trait_reachable`, for refinements that are publically"]
#[doc = r"   reachable outside a crate, and"]
#[doc =
r" * `refining_impl_trait_internal`, for refinements that are only visible"]
#[doc = r"    within a crate."]
#[doc = r""]
#[doc = r" We are seeking feedback on each of these lints; see issue"]
#[doc =
r" [#121718](https://github.com/rust-lang/rust/issues/121718) for more"]
#[doc = r" information."]
pub static REFINING_IMPL_TRAIT_INTERNAL: &crate::Lint =
    &crate::Lint {
            name: "REFINING_IMPL_TRAIT_INTERNAL",
            default_level: crate::Warn,
            desc: "impl trait in impl method signature does not match trait method signature",
            ..
        };declare_lint! {
4842    /// The `refining_impl_trait_internal` lint detects `impl Trait` return
4843    /// types in method signatures that are refined by a trait implementation,
4844    /// meaning the implementation adds information about the return type that
4845    /// is not present in the trait.
4846    ///
4847    /// ### Example
4848    ///
4849    /// ```rust,compile_fail
4850    /// #![deny(refining_impl_trait)]
4851    ///
4852    /// use std::fmt::Display;
4853    ///
4854    /// trait AsDisplay {
4855    ///     fn as_display(&self) -> impl Display;
4856    /// }
4857    ///
4858    /// impl<'s> AsDisplay for &'s str {
4859    ///     fn as_display(&self) -> Self {
4860    ///         *self
4861    ///     }
4862    /// }
4863    ///
4864    /// fn main() {
4865    ///     // users can observe that the return type of
4866    ///     // `<&str as AsDisplay>::as_display()` is `&str`.
4867    ///     let _x: &str = "".as_display();
4868    /// }
4869    /// ```
4870    ///
4871    /// {{produces}}
4872    ///
4873    /// ### Explanation
4874    ///
4875    /// Callers of methods for types where the implementation is known are
4876    /// able to observe the types written in the impl signature. This may be
4877    /// intended behavior, but may also lead to implementation details being
4878    /// revealed unintentionally. In particular, it may pose a semver hazard
4879    /// for authors of libraries who do not wish to make stronger guarantees
4880    /// about the types than what is written in the trait signature.
4881    ///
4882    /// `refining_impl_trait` is a lint group composed of two lints:
4883    ///
4884    /// * `refining_impl_trait_reachable`, for refinements that are publically
4885    ///   reachable outside a crate, and
4886    /// * `refining_impl_trait_internal`, for refinements that are only visible
4887    ///    within a crate.
4888    ///
4889    /// We are seeking feedback on each of these lints; see issue
4890    /// [#121718](https://github.com/rust-lang/rust/issues/121718) for more
4891    /// information.
4892    pub REFINING_IMPL_TRAIT_INTERNAL,
4893    Warn,
4894    "impl trait in impl method signature does not match trait method signature",
4895}
4896
4897#[doc =
r" The `private_macro_use` lint detects private macros that are imported"]
#[doc = r" with `#[macro_use]`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs extern crate)"]
#[doc = r" // extern_macro.rs"]
#[doc = r" macro_rules! foo_ { () => {}; }"]
#[doc = r" use foo_ as foo;"]
#[doc = r""]
#[doc = r" // code.rs"]
#[doc = r""]
#[doc = r" #![deny(private_macro_use)]"]
#[doc = r""]
#[doc = r" #[macro_use]"]
#[doc = r" extern crate extern_macro;"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     foo!();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" error: cannot find macro `foo` in this scope"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" This lint arises from overlooking visibility checks for macros"]
#[doc = r" in an external crate."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a"]
#[doc = r" hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static PRIVATE_MACRO_USE: &crate::Lint =
    &crate::Lint {
            name: "PRIVATE_MACRO_USE",
            default_level: crate::Deny,
            desc: "detects certain macro bindings that should not be re-exported",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 120192,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
4898    /// The `private_macro_use` lint detects private macros that are imported
4899    /// with `#[macro_use]`.
4900    ///
4901    /// ### Example
4902    ///
4903    /// ```rust,ignore (needs extern crate)
4904    /// // extern_macro.rs
4905    /// macro_rules! foo_ { () => {}; }
4906    /// use foo_ as foo;
4907    ///
4908    /// // code.rs
4909    ///
4910    /// #![deny(private_macro_use)]
4911    ///
4912    /// #[macro_use]
4913    /// extern crate extern_macro;
4914    ///
4915    /// fn main() {
4916    ///     foo!();
4917    /// }
4918    /// ```
4919    ///
4920    /// This will produce:
4921    ///
4922    /// ```text
4923    /// error: cannot find macro `foo` in this scope
4924    /// ```
4925    ///
4926    /// ### Explanation
4927    ///
4928    /// This lint arises from overlooking visibility checks for macros
4929    /// in an external crate.
4930    ///
4931    /// This is a [future-incompatible] lint to transition this to a
4932    /// hard error in the future.
4933    ///
4934    /// [future-incompatible]: ../index.md#future-incompatible-lints
4935    pub PRIVATE_MACRO_USE,
4936    Deny,
4937    "detects certain macro bindings that should not be re-exported",
4938    @future_incompatible = FutureIncompatibleInfo {
4939        reason: fcw!(FutureReleaseError #120192),
4940        report_in_deps: true,
4941    };
4942}
4943
4944#[doc =
r" The `uncovered_param_in_projection` lint detects a violation of one of Rust's orphan rules for"]
#[doc =
r" foreign trait implementations that concerns the use of type parameters inside trait associated"]
#[doc =
r#" type paths ("projections") whose output may not be a local type that is mistakenly considered"#]
#[doc =
r#" to "cover" said parameters which is **unsound** and which may be rejected by a future version"#]
#[doc = r" of the compiler."]
#[doc = r""]
#[doc = r" Originally reported in [#99554]."]
#[doc = r""]
#[doc = r" [#99554]: https://github.com/rust-lang/rust/issues/99554"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (dependent)"]
#[doc = r" // dependency.rs"]
#[doc = r#" #![crate_type = "lib"]"#]
#[doc = r""]
#[doc = r" pub trait Trait<T, U> {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ```edition2021,ignore (needs dependency)"]
#[doc = r" // dependent.rs"]
#[doc = r" trait Identity {"]
#[doc = r"     type Output;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" impl<T> Identity for T {"]
#[doc = r"     type Output = T;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" struct Local;"]
#[doc = r""]
#[doc =
r" impl<T> dependency::Trait<Local, T> for <T as Identity>::Output {}"]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" warning[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)"]
#[doc = r"   --> dependent.rs:11:6"]
#[doc = r"    |"]
#[doc =
r" 11 | impl<T> dependency::Trait<Local, T> for <T as Identity>::Output {}"]
#[doc =
r"    |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)"]
#[doc = r"    |"]
#[doc =
r"    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>"]
#[doc =
r"    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local, and no uncovered type parameters appear before that first local type"]
#[doc =
r"    = note: in this case, 'before' refers to the following order: `impl<..> ForeignTrait<T1, ..., Tn> for T0`, where `T0` is the first and `Tn` is the last"]
#[doc = r"    = note: `#[warn(uncovered_param_in_projection)]` on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" FIXME(fmease): Write explainer."]
pub static UNCOVERED_PARAM_IN_PROJECTION: &crate::Lint =
    &crate::Lint {
            name: "UNCOVERED_PARAM_IN_PROJECTION",
            default_level: crate::Warn,
            desc: "impl contains type parameters that are not covered",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 124559,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
4945    /// The `uncovered_param_in_projection` lint detects a violation of one of Rust's orphan rules for
4946    /// foreign trait implementations that concerns the use of type parameters inside trait associated
4947    /// type paths ("projections") whose output may not be a local type that is mistakenly considered
4948    /// to "cover" said parameters which is **unsound** and which may be rejected by a future version
4949    /// of the compiler.
4950    ///
4951    /// Originally reported in [#99554].
4952    ///
4953    /// [#99554]: https://github.com/rust-lang/rust/issues/99554
4954    ///
4955    /// ### Example
4956    ///
4957    /// ```rust,ignore (dependent)
4958    /// // dependency.rs
4959    /// #![crate_type = "lib"]
4960    ///
4961    /// pub trait Trait<T, U> {}
4962    /// ```
4963    ///
4964    /// ```edition2021,ignore (needs dependency)
4965    /// // dependent.rs
4966    /// trait Identity {
4967    ///     type Output;
4968    /// }
4969    ///
4970    /// impl<T> Identity for T {
4971    ///     type Output = T;
4972    /// }
4973    ///
4974    /// struct Local;
4975    ///
4976    /// impl<T> dependency::Trait<Local, T> for <T as Identity>::Output {}
4977    ///
4978    /// fn main() {}
4979    /// ```
4980    ///
4981    /// This will produce:
4982    ///
4983    /// ```text
4984    /// warning[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
4985    ///   --> dependent.rs:11:6
4986    ///    |
4987    /// 11 | impl<T> dependency::Trait<Local, T> for <T as Identity>::Output {}
4988    ///    |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
4989    ///    |
4990    ///    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
4991    ///    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
4992    ///    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local, and no uncovered type parameters appear before that first local type
4993    ///    = note: in this case, 'before' refers to the following order: `impl<..> ForeignTrait<T1, ..., Tn> for T0`, where `T0` is the first and `Tn` is the last
4994    ///    = note: `#[warn(uncovered_param_in_projection)]` on by default
4995    /// ```
4996    ///
4997    /// ### Explanation
4998    ///
4999    /// FIXME(fmease): Write explainer.
5000    pub UNCOVERED_PARAM_IN_PROJECTION,
5001    Warn,
5002    "impl contains type parameters that are not covered",
5003    @future_incompatible = FutureIncompatibleInfo {
5004        reason: fcw!(FutureReleaseError #124559),
5005    };
5006}
5007
5008#[doc =
r" The `deprecated_safe_2024` lint detects unsafe functions being used as"]
#[doc = r" safe functions."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2021,compile_fail"]
#[doc = r" #![deny(deprecated_safe)]"]
#[doc = r" // edition 2021"]
#[doc = r" use std::env;"]
#[doc = r" fn enable_backtrace() {"]
#[doc = r#"     env::set_var("RUST_BACKTRACE", "1");"#]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Rust [editions] allow the language to evolve without breaking backward"]
#[doc =
r" compatibility. This lint catches code that uses `unsafe` functions that"]
#[doc =
r" were declared as safe (non-`unsafe`) in editions prior to Rust 2024. If"]
#[doc =
r" you switch the compiler to Rust 2024 without updating the code, then it"]
#[doc =
r" will fail to compile if you are using a function previously marked as"]
#[doc = r" safe."]
#[doc = r""]
#[doc =
r" You can audit the code to see if it suffices the preconditions of the"]
#[doc =
r" `unsafe` code, and if it does, you can wrap it in an `unsafe` block. If"]
#[doc =
r" you can't fulfill the preconditions, you probably need to switch to a"]
#[doc = r" different way of doing what you want to achieve."]
#[doc = r""]
#[doc =
r" This lint can automatically wrap the calls in `unsafe` blocks, but this"]
#[doc = r" obviously cannot verify that the preconditions of the `unsafe`"]
#[doc = r" functions are fulfilled, so that is still up to the user."]
#[doc = r""]
#[doc =
r#" The lint is currently "allow" by default, but that might change in the"#]
#[doc = r" future."]
#[doc = r""]
#[doc = r" [editions]: https://doc.rust-lang.org/edition-guide/"]
pub static DEPRECATED_SAFE_2024: &crate::Lint =
    &crate::Lint {
            name: "DEPRECATED_SAFE_2024",
            default_level: crate::Allow,
            desc: "detects unsafe functions being used as safe functions",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "newly-unsafe-functions",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
5009    /// The `deprecated_safe_2024` lint detects unsafe functions being used as
5010    /// safe functions.
5011    ///
5012    /// ### Example
5013    ///
5014    /// ```rust,edition2021,compile_fail
5015    /// #![deny(deprecated_safe)]
5016    /// // edition 2021
5017    /// use std::env;
5018    /// fn enable_backtrace() {
5019    ///     env::set_var("RUST_BACKTRACE", "1");
5020    /// }
5021    /// ```
5022    ///
5023    /// {{produces}}
5024    ///
5025    /// ### Explanation
5026    ///
5027    /// Rust [editions] allow the language to evolve without breaking backward
5028    /// compatibility. This lint catches code that uses `unsafe` functions that
5029    /// were declared as safe (non-`unsafe`) in editions prior to Rust 2024. If
5030    /// you switch the compiler to Rust 2024 without updating the code, then it
5031    /// will fail to compile if you are using a function previously marked as
5032    /// safe.
5033    ///
5034    /// You can audit the code to see if it suffices the preconditions of the
5035    /// `unsafe` code, and if it does, you can wrap it in an `unsafe` block. If
5036    /// you can't fulfill the preconditions, you probably need to switch to a
5037    /// different way of doing what you want to achieve.
5038    ///
5039    /// This lint can automatically wrap the calls in `unsafe` blocks, but this
5040    /// obviously cannot verify that the preconditions of the `unsafe`
5041    /// functions are fulfilled, so that is still up to the user.
5042    ///
5043    /// The lint is currently "allow" by default, but that might change in the
5044    /// future.
5045    ///
5046    /// [editions]: https://doc.rust-lang.org/edition-guide/
5047    pub DEPRECATED_SAFE_2024,
5048    Allow,
5049    "detects unsafe functions being used as safe functions",
5050    @future_incompatible = FutureIncompatibleInfo {
5051        reason: fcw!(EditionError 2024 "newly-unsafe-functions"),
5052    };
5053}
5054
5055#[doc =
r" The `missing_unsafe_on_extern` lint detects missing unsafe keyword on extern declarations."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2021"]
#[doc = r" #![warn(missing_unsafe_on_extern)]"]
#[doc = r" #![allow(dead_code)]"]
#[doc = r""]
#[doc = r#" extern "C" {"#]
#[doc = r"     fn foo(_: i32);"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Declaring extern items, even without ever using them, can cause Undefined Behavior. We"]
#[doc = r" should consider all sources of Undefined Behavior to be unsafe."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a"]
#[doc = r" hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static MISSING_UNSAFE_ON_EXTERN: &crate::Lint =
    &crate::Lint {
            name: "MISSING_UNSAFE_ON_EXTERN",
            default_level: crate::Allow,
            desc: "detects missing unsafe keyword on extern declarations",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "unsafe-extern",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
5056    /// The `missing_unsafe_on_extern` lint detects missing unsafe keyword on extern declarations.
5057    ///
5058    /// ### Example
5059    ///
5060    /// ```rust,edition2021
5061    /// #![warn(missing_unsafe_on_extern)]
5062    /// #![allow(dead_code)]
5063    ///
5064    /// extern "C" {
5065    ///     fn foo(_: i32);
5066    /// }
5067    ///
5068    /// fn main() {}
5069    /// ```
5070    ///
5071    /// {{produces}}
5072    ///
5073    /// ### Explanation
5074    ///
5075    /// Declaring extern items, even without ever using them, can cause Undefined Behavior. We
5076    /// should consider all sources of Undefined Behavior to be unsafe.
5077    ///
5078    /// This is a [future-incompatible] lint to transition this to a
5079    /// hard error in the future.
5080    ///
5081    /// [future-incompatible]: ../index.md#future-incompatible-lints
5082    pub MISSING_UNSAFE_ON_EXTERN,
5083    Allow,
5084    "detects missing unsafe keyword on extern declarations",
5085    @future_incompatible = FutureIncompatibleInfo {
5086        reason: fcw!(EditionError 2024 "unsafe-extern"),
5087    };
5088}
5089
5090#[doc =
r" The `unsafe_attr_outside_unsafe` lint detects a missing unsafe keyword"]
#[doc = r" on attributes considered unsafe."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2021"]
#[doc = r" #![warn(unsafe_attr_outside_unsafe)]"]
#[doc = r""]
#[doc = r" #[no_mangle]"]
#[doc = r#" extern "C" fn foo() {}"#]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Some attributes (e.g. `no_mangle`, `export_name`, `link_section` -- see"]
#[doc =
r#" [issue #82499] for a more complete list) are considered "unsafe" attributes."#]
#[doc = r" An unsafe attribute must only be used inside unsafe(...)."]
#[doc = r""]
#[doc =
r" This lint can automatically wrap the attributes in `unsafe(...)` , but this"]
#[doc = r" obviously cannot verify that the preconditions of the `unsafe`"]
#[doc = r" attributes are fulfilled, so that is still up to the user."]
#[doc = r""]
#[doc =
r#" The lint is currently "allow" by default, but that might change in the"#]
#[doc = r" future."]
#[doc = r""]
#[doc = r" [editions]: https://doc.rust-lang.org/edition-guide/"]
#[doc = r" [issue #82499]: https://github.com/rust-lang/rust/issues/82499"]
pub static UNSAFE_ATTR_OUTSIDE_UNSAFE: &crate::Lint =
    &crate::Lint {
            name: "UNSAFE_ATTR_OUTSIDE_UNSAFE",
            default_level: crate::Allow,
            desc: "detects unsafe attributes outside of unsafe",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "unsafe-attributes",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
5091    /// The `unsafe_attr_outside_unsafe` lint detects a missing unsafe keyword
5092    /// on attributes considered unsafe.
5093    ///
5094    /// ### Example
5095    ///
5096    /// ```rust,edition2021
5097    /// #![warn(unsafe_attr_outside_unsafe)]
5098    ///
5099    /// #[no_mangle]
5100    /// extern "C" fn foo() {}
5101    ///
5102    /// fn main() {}
5103    /// ```
5104    ///
5105    /// {{produces}}
5106    ///
5107    /// ### Explanation
5108    ///
5109    /// Some attributes (e.g. `no_mangle`, `export_name`, `link_section` -- see
5110    /// [issue #82499] for a more complete list) are considered "unsafe" attributes.
5111    /// An unsafe attribute must only be used inside unsafe(...).
5112    ///
5113    /// This lint can automatically wrap the attributes in `unsafe(...)` , but this
5114    /// obviously cannot verify that the preconditions of the `unsafe`
5115    /// attributes are fulfilled, so that is still up to the user.
5116    ///
5117    /// The lint is currently "allow" by default, but that might change in the
5118    /// future.
5119    ///
5120    /// [editions]: https://doc.rust-lang.org/edition-guide/
5121    /// [issue #82499]: https://github.com/rust-lang/rust/issues/82499
5122    pub UNSAFE_ATTR_OUTSIDE_UNSAFE,
5123    Allow,
5124    "detects unsafe attributes outside of unsafe",
5125    @future_incompatible = FutureIncompatibleInfo {
5126        reason: fcw!(EditionError 2024 "unsafe-attributes"),
5127    };
5128}
5129
5130#[doc =
r" The `out_of_scope_macro_calls` lint detects `macro_rules` called when they are not in scope,"]
#[doc = r" above their definition, which may happen in key-value attributes."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![doc = in_root!()]"]
#[doc = r""]
#[doc = r#" macro_rules! in_root { () => { "" } }"#]
#[doc = r""]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The scope in which a `macro_rules` item is visible starts at that item and continues"]
#[doc =
r" below it. This is more similar to `let` than to other items, which are in scope both above"]
#[doc = r" and below their definition."]
#[doc =
r" Due to a bug `macro_rules` were accidentally in scope inside some key-value attributes"]
#[doc = r" above their definition. The lint catches such cases."]
#[doc =
r" To address the issue turn the `macro_rules` into a regularly scoped item by importing it"]
#[doc = r" with `use`."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a"]
#[doc = r" hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static OUT_OF_SCOPE_MACRO_CALLS: &crate::Lint =
    &crate::Lint {
            name: "OUT_OF_SCOPE_MACRO_CALLS",
            default_level: crate::Deny,
            desc: "detects out of scope calls to `macro_rules` in key-value attributes",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 124535,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
5131    /// The `out_of_scope_macro_calls` lint detects `macro_rules` called when they are not in scope,
5132    /// above their definition, which may happen in key-value attributes.
5133    ///
5134    /// ### Example
5135    ///
5136    /// ```rust,compile_fail
5137    /// #![doc = in_root!()]
5138    ///
5139    /// macro_rules! in_root { () => { "" } }
5140    ///
5141    /// fn main() {}
5142    /// ```
5143    ///
5144    /// {{produces}}
5145    ///
5146    /// ### Explanation
5147    ///
5148    /// The scope in which a `macro_rules` item is visible starts at that item and continues
5149    /// below it. This is more similar to `let` than to other items, which are in scope both above
5150    /// and below their definition.
5151    /// Due to a bug `macro_rules` were accidentally in scope inside some key-value attributes
5152    /// above their definition. The lint catches such cases.
5153    /// To address the issue turn the `macro_rules` into a regularly scoped item by importing it
5154    /// with `use`.
5155    ///
5156    /// This is a [future-incompatible] lint to transition this to a
5157    /// hard error in the future.
5158    ///
5159    /// [future-incompatible]: ../index.md#future-incompatible-lints
5160    pub OUT_OF_SCOPE_MACRO_CALLS,
5161    Deny,
5162    "detects out of scope calls to `macro_rules` in key-value attributes",
5163    @future_incompatible = FutureIncompatibleInfo {
5164        reason: fcw!(FutureReleaseError #124535),
5165        report_in_deps: true,
5166    };
5167}
5168
5169#[doc =
r" The `resolving_to_items_shadowing_supertrait_items` lint detects when the"]
#[doc =
r" usage of an item that is provided by both a subtrait and supertrait"]
#[doc = r" is shadowed, preferring the subtrait."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![feature(supertrait_item_shadowing)]"]
#[doc = r" #![deny(resolving_to_items_shadowing_supertrait_items)]"]
#[doc = r""]
#[doc = r" trait Upstream {"]
#[doc = r"     fn hello(&self) {}"]
#[doc = r" }"]
#[doc = r" impl<T> Upstream for T {}"]
#[doc = r""]
#[doc = r" trait Downstream: Upstream {"]
#[doc = r"     fn hello(&self) {}"]
#[doc = r" }"]
#[doc = r" impl<T> Downstream for T {}"]
#[doc = r""]
#[doc = r" struct MyType;"]
#[doc = r" MyType.hello();"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" RFC 3624 specified a heuristic in which a supertrait item would be"]
#[doc = r" shadowed by a subtrait item when ambiguity occurs during item"]
#[doc = r" selection. In order to mitigate side-effects of this happening"]
#[doc =
r" silently, this lint detects these cases when users want to deny them"]
#[doc = r" or fix the call sites."]
pub static RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS: &crate::Lint =
    &crate::Lint {
            name: "RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS",
            default_level: crate::Allow,
            desc: "detects when a supertrait item is shadowed by a subtrait item",
            feature_gate: Some(rustc_span::sym::supertrait_item_shadowing),
            ..
        };declare_lint! {
5170    /// The `resolving_to_items_shadowing_supertrait_items` lint detects when the
5171    /// usage of an item that is provided by both a subtrait and supertrait
5172    /// is shadowed, preferring the subtrait.
5173    ///
5174    /// ### Example
5175    ///
5176    /// ```rust,compile_fail
5177    /// #![feature(supertrait_item_shadowing)]
5178    /// #![deny(resolving_to_items_shadowing_supertrait_items)]
5179    ///
5180    /// trait Upstream {
5181    ///     fn hello(&self) {}
5182    /// }
5183    /// impl<T> Upstream for T {}
5184    ///
5185    /// trait Downstream: Upstream {
5186    ///     fn hello(&self) {}
5187    /// }
5188    /// impl<T> Downstream for T {}
5189    ///
5190    /// struct MyType;
5191    /// MyType.hello();
5192    /// ```
5193    ///
5194    /// {{produces}}
5195    ///
5196    /// ### Explanation
5197    ///
5198    /// RFC 3624 specified a heuristic in which a supertrait item would be
5199    /// shadowed by a subtrait item when ambiguity occurs during item
5200    /// selection. In order to mitigate side-effects of this happening
5201    /// silently, this lint detects these cases when users want to deny them
5202    /// or fix the call sites.
5203    pub RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS,
5204    // FIXME(supertrait_item_shadowing): It is not decided if this should
5205    // warn by default at the call site.
5206    Allow,
5207    "detects when a supertrait item is shadowed by a subtrait item",
5208    @feature_gate = supertrait_item_shadowing;
5209}
5210
5211#[doc = r" The `shadowing_supertrait_items` lint detects when the"]
#[doc = r" definition of an item that is provided by both a subtrait and"]
#[doc = r" supertrait is shadowed, preferring the subtrait."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![feature(supertrait_item_shadowing)]"]
#[doc = r" #![deny(shadowing_supertrait_items)]"]
#[doc = r""]
#[doc = r" trait Upstream {"]
#[doc = r"     fn hello(&self) {}"]
#[doc = r" }"]
#[doc = r" impl<T> Upstream for T {}"]
#[doc = r""]
#[doc = r" trait Downstream: Upstream {"]
#[doc = r"     fn hello(&self) {}"]
#[doc = r" }"]
#[doc = r" impl<T> Downstream for T {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" RFC 3624 specified a heuristic in which a supertrait item would be"]
#[doc = r" shadowed by a subtrait item when ambiguity occurs during item"]
#[doc = r" selection. In order to mitigate side-effects of this happening"]
#[doc =
r" silently, this lint detects these cases when users want to deny them"]
#[doc = r" or fix their trait definitions."]
pub static SHADOWING_SUPERTRAIT_ITEMS: &crate::Lint =
    &crate::Lint {
            name: "SHADOWING_SUPERTRAIT_ITEMS",
            default_level: crate::Allow,
            desc: "detects when a supertrait item is shadowed by a subtrait item",
            feature_gate: Some(rustc_span::sym::supertrait_item_shadowing),
            ..
        };declare_lint! {
5212    /// The `shadowing_supertrait_items` lint detects when the
5213    /// definition of an item that is provided by both a subtrait and
5214    /// supertrait is shadowed, preferring the subtrait.
5215    ///
5216    /// ### Example
5217    ///
5218    /// ```rust,compile_fail
5219    /// #![feature(supertrait_item_shadowing)]
5220    /// #![deny(shadowing_supertrait_items)]
5221    ///
5222    /// trait Upstream {
5223    ///     fn hello(&self) {}
5224    /// }
5225    /// impl<T> Upstream for T {}
5226    ///
5227    /// trait Downstream: Upstream {
5228    ///     fn hello(&self) {}
5229    /// }
5230    /// impl<T> Downstream for T {}
5231    /// ```
5232    ///
5233    /// {{produces}}
5234    ///
5235    /// ### Explanation
5236    ///
5237    /// RFC 3624 specified a heuristic in which a supertrait item would be
5238    /// shadowed by a subtrait item when ambiguity occurs during item
5239    /// selection. In order to mitigate side-effects of this happening
5240    /// silently, this lint detects these cases when users want to deny them
5241    /// or fix their trait definitions.
5242    pub SHADOWING_SUPERTRAIT_ITEMS,
5243    // FIXME(supertrait_item_shadowing): It is not decided if this should
5244    // warn by default at the usage site.
5245    Allow,
5246    "detects when a supertrait item is shadowed by a subtrait item",
5247    @feature_gate = supertrait_item_shadowing;
5248}
5249
5250#[doc =
r" The `tail_expr_drop_order` lint looks for those values generated at the tail expression location,"]
#[doc = r" that runs a custom `Drop` destructor."]
#[doc =
r" Some of them may be dropped earlier in Edition 2024 that they used to in Edition 2021 and prior."]
#[doc =
r" This lint detects those cases and provides you information on those values and their custom destructor implementations."]
#[doc = r" Your discretion on this information is required."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r" ```rust,edition2021"]
#[doc = r" #![warn(tail_expr_drop_order)]"]
#[doc = r" struct Droppy(i32);"]
#[doc = r" impl Droppy {"]
#[doc = r"     fn get(&self) -> i32 {"]
#[doc = r"         self.0"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" impl Drop for Droppy {"]
#[doc = r"     fn drop(&mut self) {"]
#[doc =
r"         // This is a custom destructor and it induces side-effects that is observable"]
#[doc =
r"         // especially when the drop order at a tail expression changes."]
#[doc = r#"         println!("loud drop {}", self.0);"#]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" fn edition_2021() -> i32 {"]
#[doc = r"     let another_droppy = Droppy(0);"]
#[doc = r"     Droppy(1).get()"]
#[doc = r" }"]
#[doc = r" fn main() {"]
#[doc = r"     edition_2021();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" In tail expression of blocks or function bodies,"]
#[doc =
r" values of type with significant `Drop` implementation has an ill-specified drop order"]
#[doc =
r" before Edition 2024 so that they are dropped only after dropping local variables."]
#[doc = r" Edition 2024 introduces a new rule with drop orders for them,"]
#[doc = r" so that they are dropped first before dropping local variables."]
#[doc = r""]
#[doc =
r" A significant `Drop::drop` destructor here refers to an explicit, arbitrary"]
#[doc =
r" implementation of the `Drop` trait on the type, with exceptions including `Vec`,"]
#[doc =
r" `Box`, `Rc`, `BTreeMap` and `HashMap` that are marked by the compiler otherwise"]
#[doc =
r" so long that the generic types have no significant destructor recursively."]
#[doc =
r" In other words, a type has a significant drop destructor when it has a `Drop` implementation"]
#[doc = r" or its destructor invokes a significant destructor on a type."]
#[doc =
r" Since we cannot completely reason about the change by just inspecting the existence of"]
#[doc =
r" a significant destructor, this lint remains only a suggestion and is set to `allow` by default."]
#[doc = r""]
#[doc =
r" This lint only points out the issue with `Droppy`, which will be dropped before `another_droppy`"]
#[doc = r" does in Edition 2024."]
#[doc = r" No fix will be proposed by this lint."]
#[doc =
r" However, the most probable fix is to hoist `Droppy` into its own local variable binding."]
#[doc = r" ```rust"]
#[doc = r" struct Droppy(i32);"]
#[doc = r" impl Droppy {"]
#[doc = r"     fn get(&self) -> i32 {"]
#[doc = r"         self.0"]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r" fn edition_2024() -> i32 {"]
#[doc = r"     let value = Droppy(0);"]
#[doc = r"     let another_droppy = Droppy(1);"]
#[doc = r"     value.get()"]
#[doc = r" }"]
#[doc = r" ```"]
pub static TAIL_EXPR_DROP_ORDER: &crate::Lint =
    &crate::Lint {
            name: "TAIL_EXPR_DROP_ORDER",
            default_level: crate::Allow,
            desc: "Detect and warn on significant change in drop order in tail expression location",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionSemanticsChange(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "temporary-tail-expr-scope",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
5251    /// The `tail_expr_drop_order` lint looks for those values generated at the tail expression location,
5252    /// that runs a custom `Drop` destructor.
5253    /// Some of them may be dropped earlier in Edition 2024 that they used to in Edition 2021 and prior.
5254    /// This lint detects those cases and provides you information on those values and their custom destructor implementations.
5255    /// Your discretion on this information is required.
5256    ///
5257    /// ### Example
5258    /// ```rust,edition2021
5259    /// #![warn(tail_expr_drop_order)]
5260    /// struct Droppy(i32);
5261    /// impl Droppy {
5262    ///     fn get(&self) -> i32 {
5263    ///         self.0
5264    ///     }
5265    /// }
5266    /// impl Drop for Droppy {
5267    ///     fn drop(&mut self) {
5268    ///         // This is a custom destructor and it induces side-effects that is observable
5269    ///         // especially when the drop order at a tail expression changes.
5270    ///         println!("loud drop {}", self.0);
5271    ///     }
5272    /// }
5273    /// fn edition_2021() -> i32 {
5274    ///     let another_droppy = Droppy(0);
5275    ///     Droppy(1).get()
5276    /// }
5277    /// fn main() {
5278    ///     edition_2021();
5279    /// }
5280    /// ```
5281    ///
5282    /// {{produces}}
5283    ///
5284    /// ### Explanation
5285    ///
5286    /// In tail expression of blocks or function bodies,
5287    /// values of type with significant `Drop` implementation has an ill-specified drop order
5288    /// before Edition 2024 so that they are dropped only after dropping local variables.
5289    /// Edition 2024 introduces a new rule with drop orders for them,
5290    /// so that they are dropped first before dropping local variables.
5291    ///
5292    /// A significant `Drop::drop` destructor here refers to an explicit, arbitrary
5293    /// implementation of the `Drop` trait on the type, with exceptions including `Vec`,
5294    /// `Box`, `Rc`, `BTreeMap` and `HashMap` that are marked by the compiler otherwise
5295    /// so long that the generic types have no significant destructor recursively.
5296    /// In other words, a type has a significant drop destructor when it has a `Drop` implementation
5297    /// or its destructor invokes a significant destructor on a type.
5298    /// Since we cannot completely reason about the change by just inspecting the existence of
5299    /// a significant destructor, this lint remains only a suggestion and is set to `allow` by default.
5300    ///
5301    /// This lint only points out the issue with `Droppy`, which will be dropped before `another_droppy`
5302    /// does in Edition 2024.
5303    /// No fix will be proposed by this lint.
5304    /// However, the most probable fix is to hoist `Droppy` into its own local variable binding.
5305    /// ```rust
5306    /// struct Droppy(i32);
5307    /// impl Droppy {
5308    ///     fn get(&self) -> i32 {
5309    ///         self.0
5310    ///     }
5311    /// }
5312    /// fn edition_2024() -> i32 {
5313    ///     let value = Droppy(0);
5314    ///     let another_droppy = Droppy(1);
5315    ///     value.get()
5316    /// }
5317    /// ```
5318    pub TAIL_EXPR_DROP_ORDER,
5319    Allow,
5320    "Detect and warn on significant change in drop order in tail expression location",
5321    @future_incompatible = FutureIncompatibleInfo {
5322        reason: fcw!(EditionSemanticsChange 2024 "temporary-tail-expr-scope"),
5323    };
5324}
5325
5326#[doc =
r" The `rust_2024_guarded_string_incompatible_syntax` lint detects `#` tokens"]
#[doc =
r" that will be parsed as part of a guarded string literal in Rust 2024."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,edition2021,compile_fail"]
#[doc = r" #![deny(rust_2024_guarded_string_incompatible_syntax)]"]
#[doc = r""]
#[doc = r" macro_rules! m {"]
#[doc = r"     (# $x:expr #) => ();"]
#[doc = r"     (# $x:expr) => ();"]
#[doc = r" }"]
#[doc = r""]
#[doc = r##" m!(#"hey"#);"##]
#[doc = r#" m!(#"hello");"#]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r##" Prior to Rust 2024, `#"hey"#` is three tokens: the first `#`"##]
#[doc = r#" followed by the string literal `"hey"` then the final `#`."#]
#[doc = r" In Rust 2024, the whole sequence is considered a single token."]
#[doc = r""]
#[doc = r" This lint suggests to add whitespace between the leading `#`"]
#[doc = r" and the string to keep them separated in Rust 2024."]
#[allow(rustdoc::invalid_rust_codeblocks)]
pub static RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX: &crate::Lint =
    &crate::Lint {
            name: "RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX",
            default_level: crate::Allow,
            desc: "will be parsed as a guarded string in Rust 2024",
            crate_level_only: true,
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::EditionError(crate::EditionFcw {
                            edition: rustc_span::edition::Edition::Edition2024,
                            page_slug: "reserved-syntax",
                        }),
                    ..
                }),
            ..
        };declare_lint! {
5327    /// The `rust_2024_guarded_string_incompatible_syntax` lint detects `#` tokens
5328    /// that will be parsed as part of a guarded string literal in Rust 2024.
5329    ///
5330    /// ### Example
5331    ///
5332    /// ```rust,edition2021,compile_fail
5333    /// #![deny(rust_2024_guarded_string_incompatible_syntax)]
5334    ///
5335    /// macro_rules! m {
5336    ///     (# $x:expr #) => ();
5337    ///     (# $x:expr) => ();
5338    /// }
5339    ///
5340    /// m!(#"hey"#);
5341    /// m!(#"hello");
5342    /// ```
5343    ///
5344    /// {{produces}}
5345    ///
5346    /// ### Explanation
5347    ///
5348    /// Prior to Rust 2024, `#"hey"#` is three tokens: the first `#`
5349    /// followed by the string literal `"hey"` then the final `#`.
5350    /// In Rust 2024, the whole sequence is considered a single token.
5351    ///
5352    /// This lint suggests to add whitespace between the leading `#`
5353    /// and the string to keep them separated in Rust 2024.
5354    // Allow this lint -- rustdoc doesn't yet support threading edition into this lint's parser.
5355    #[allow(rustdoc::invalid_rust_codeblocks)]
5356    pub RUST_2024_GUARDED_STRING_INCOMPATIBLE_SYNTAX,
5357    Allow,
5358    "will be parsed as a guarded string in Rust 2024",
5359    @future_incompatible = FutureIncompatibleInfo {
5360        reason: fcw!(EditionError 2024 "reserved-syntax"),
5361    };
5362    crate_level_only
5363}
5364
5365#[doc =
r#" The `aarch64_softfloat_neon` lint detects usage of `#[target_feature(enable = "neon")]` on"#]
#[doc =
r" softfloat aarch64 targets. Enabling this target feature causes LLVM to alter the ABI of"]
#[doc = r" function calls, making this attribute unsound to use."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs aarch64-unknown-none-softfloat)"]
#[doc = r#" #[target_feature(enable = "neon")]"#]
#[doc = r" fn with_neon() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" error: enabling the `neon` target feature on the current target is unsound due to ABI issues"]
#[doc = r"   --> $DIR/abi-incompatible-target-feature-attribute-fcw.rs:11:18"]
#[doc = r"    |"]
#[doc = r#"    | #[target_feature(enable = "neon")]"#]
#[doc = r"    |                  ^^^^^^^^^^^^^^^"]
#[doc = r"    |"]
#[doc =
r"    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"    = note: for more information, see issue #134375 <https://github.com/rust-lang/rust/issues/134375>"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" If a function like `with_neon` above ends up containing calls to LLVM builtins, those will"]
#[doc =
r" not use the correct ABI. This is caused by a lack of support in LLVM for mixing code with"]
#[doc =
r" and without the `neon` target feature. The target feature should never have been stabilized"]
#[doc =
r" on this target due to this issue, but the problem was not known at the time of"]
#[doc = r" stabilization."]
pub static AARCH64_SOFTFLOAT_NEON: &crate::Lint =
    &crate::Lint {
            name: "AARCH64_SOFTFLOAT_NEON",
            default_level: crate::Deny,
            desc: "detects code that could be affected by ABI issues on aarch64 softfloat targets",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 134375,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
5366    /// The `aarch64_softfloat_neon` lint detects usage of `#[target_feature(enable = "neon")]` on
5367    /// softfloat aarch64 targets. Enabling this target feature causes LLVM to alter the ABI of
5368    /// function calls, making this attribute unsound to use.
5369    ///
5370    /// ### Example
5371    ///
5372    /// ```rust,ignore (needs aarch64-unknown-none-softfloat)
5373    /// #[target_feature(enable = "neon")]
5374    /// fn with_neon() {}
5375    /// ```
5376    ///
5377    /// This will produce:
5378    ///
5379    /// ```text
5380    /// error: enabling the `neon` target feature on the current target is unsound due to ABI issues
5381    ///   --> $DIR/abi-incompatible-target-feature-attribute-fcw.rs:11:18
5382    ///    |
5383    ///    | #[target_feature(enable = "neon")]
5384    ///    |                  ^^^^^^^^^^^^^^^
5385    ///    |
5386    ///    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
5387    ///    = note: for more information, see issue #134375 <https://github.com/rust-lang/rust/issues/134375>
5388    /// ```
5389    ///
5390    /// ### Explanation
5391    ///
5392    /// If a function like `with_neon` above ends up containing calls to LLVM builtins, those will
5393    /// not use the correct ABI. This is caused by a lack of support in LLVM for mixing code with
5394    /// and without the `neon` target feature. The target feature should never have been stabilized
5395    /// on this target due to this issue, but the problem was not known at the time of
5396    /// stabilization.
5397    pub AARCH64_SOFTFLOAT_NEON,
5398    Deny,
5399    "detects code that could be affected by ABI issues on aarch64 softfloat targets",
5400    @future_incompatible = FutureIncompatibleInfo {
5401        reason: fcw!(FutureReleaseError #134375),
5402        report_in_deps: true,
5403    };
5404}
5405
5406#[doc =
r#" The `x86_softfloat_sse` lint detects usage of `#[target_feature(enable = "sse")]` or target"#]
#[doc =
r" features that imply SSE on softfloat x86 and x86-64 targets. Enabling this target feature"]
#[doc =
r" in a soft-float configuration is not supported by LLVM and can lead to crashes."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs x86_64-unknown-none)"]
#[doc = r#" #[target_feature(enable = "avx")]"#]
#[doc = r" fn with_avx() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" error: enabling the `sse` target feature on the current target is unsupported due to LLVM backend issues"]
#[doc = r"   --> $DIR/abi-incompatible-target-feature-attribute-fcw.rs:11:18"]
#[doc = r"    |"]
#[doc = r#"    | #[target_feature(enable = "avx")]"#]
#[doc = r"    |                  ^^^^^^^^^^^^^^^"]
#[doc = r"    |"]
#[doc =
r"    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"    = note: for more information, see issue #117938 <https://github.com/rust-lang/rust/issues/117938>"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" LLVM does not support combining the `soft-float` target feature (which is implicitly enabled"]
#[doc =
r" on these targets) with `sse`. This can lead to crashes of the backend. To prevent that,"]
#[doc = r" Rust is turning that combination into an error."]
pub static X86_SOFTFLOAT_SSE: &crate::Lint =
    &crate::Lint {
            name: "X86_SOFTFLOAT_SSE",
            default_level: crate::Deny,
            desc: "detects code that could be affected by LLVM backend issues on x86 softfloat targets",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 117938,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
5407    /// The `x86_softfloat_sse` lint detects usage of `#[target_feature(enable = "sse")]` or target
5408    /// features that imply SSE on softfloat x86 and x86-64 targets. Enabling this target feature
5409    /// in a soft-float configuration is not supported by LLVM and can lead to crashes.
5410    ///
5411    /// ### Example
5412    ///
5413    /// ```rust,ignore (needs x86_64-unknown-none)
5414    /// #[target_feature(enable = "avx")]
5415    /// fn with_avx() {}
5416    /// ```
5417    ///
5418    /// This will produce:
5419    ///
5420    /// ```text
5421    /// error: enabling the `sse` target feature on the current target is unsupported due to LLVM backend issues
5422    ///   --> $DIR/abi-incompatible-target-feature-attribute-fcw.rs:11:18
5423    ///    |
5424    ///    | #[target_feature(enable = "avx")]
5425    ///    |                  ^^^^^^^^^^^^^^^
5426    ///    |
5427    ///    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
5428    ///    = note: for more information, see issue #117938 <https://github.com/rust-lang/rust/issues/117938>
5429    /// ```
5430    ///
5431    /// ### Explanation
5432    ///
5433    /// LLVM does not support combining the `soft-float` target feature (which is implicitly enabled
5434    /// on these targets) with `sse`. This can lead to crashes of the backend. To prevent that,
5435    /// Rust is turning that combination into an error.
5436    pub X86_SOFTFLOAT_SSE,
5437    Deny,
5438    "detects code that could be affected by LLVM backend issues on x86 softfloat targets",
5439    @future_incompatible = FutureIncompatibleInfo {
5440        reason: fcw!(FutureReleaseError #117938),
5441        report_in_deps: true,
5442    };
5443}
5444
5445#[doc =
r" The `tail_call_track_caller` lint detects usage of `become` attempting to tail call"]
#[doc = r" a function marked with `#[track_caller]`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" #![feature(explicit_tail_calls)]"]
#[doc = r" #![expect(incomplete_features)]"]
#[doc = r""]
#[doc = r" #[track_caller]"]
#[doc = r" fn f() {}"]
#[doc = r""]
#[doc = r" fn g() {"]
#[doc = r"     become f();"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" g();"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Due to implementation details of tail calls and `#[track_caller]` attribute, calls to"]
#[doc =
r" functions marked with `#[track_caller]` cannot become tail calls. As such using `become`"]
#[doc =
r" is no different than a normal call (except for changes in drop order)."]
pub static TAIL_CALL_TRACK_CALLER: &crate::Lint =
    &crate::Lint {
            name: "TAIL_CALL_TRACK_CALLER",
            default_level: crate::Warn,
            desc: "detects tail calls of functions marked with `#[track_caller]`",
            feature_gate: Some(rustc_span::sym::explicit_tail_calls),
            ..
        };declare_lint! {
5446    /// The `tail_call_track_caller` lint detects usage of `become` attempting to tail call
5447    /// a function marked with `#[track_caller]`.
5448    ///
5449    /// ### Example
5450    ///
5451    /// ```rust
5452    /// #![feature(explicit_tail_calls)]
5453    /// #![expect(incomplete_features)]
5454    ///
5455    /// #[track_caller]
5456    /// fn f() {}
5457    ///
5458    /// fn g() {
5459    ///     become f();
5460    /// }
5461    ///
5462    /// g();
5463    /// ```
5464    ///
5465    /// {{produces}}
5466    ///
5467    /// ### Explanation
5468    ///
5469    /// Due to implementation details of tail calls and `#[track_caller]` attribute, calls to
5470    /// functions marked with `#[track_caller]` cannot become tail calls. As such using `become`
5471    /// is no different than a normal call (except for changes in drop order).
5472    pub TAIL_CALL_TRACK_CALLER,
5473    Warn,
5474    "detects tail calls of functions marked with `#[track_caller]`",
5475    @feature_gate = explicit_tail_calls;
5476}
5477#[doc =
r" The `repr_c_enums_larger_than_int` lint detects `repr(C)` enums with discriminant"]
#[doc = r" values that do not fit into a C `int` or `unsigned int`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (only errors on 64bit)"]
#[doc = r" #[repr(C)]"]
#[doc = r" enum E {"]
#[doc = r"     V = 9223372036854775807, // i64::MAX"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" error: `repr(C)` enum discriminant does not fit into C `int` nor into C `unsigned int`"]
#[doc = r"   --> $DIR/repr-c-big-discriminant1.rs:16:5"]
#[doc = r"    |"]
#[doc = r" LL |     A = 9223372036854775807, // i64::MAX"]
#[doc = r"    |     ^"]
#[doc = r"    |"]
#[doc =
r"    = note: `repr(C)` enums with big discriminants are non-portable, and their size in Rust might not match their size in C"]
#[doc =
r"    = help: use `repr($int_ty)` instead to explicitly set the size of this enum"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" In C, enums with discriminants that do not all fit into an `int` or all fit into an"]
#[doc =
r" `unsigned int` are a portability hazard: such enums are only permitted since C23, and not"]
#[doc = r" supported e.g. by MSVC."]
#[doc = r""]
#[doc =
r" Furthermore, Rust interprets the discriminant values of `repr(C)` enums as expressions of"]
#[doc =
r" type `isize`. This makes it impossible to implement the C23 behavior of enums where the enum"]
#[doc =
r" discriminants have no predefined type and instead the enum uses a type large enough to hold"]
#[doc = r" all discriminants."]
#[doc = r""]
#[doc =
r" Therefore, `repr(C)` enums in Rust require that either all discriminants to fit into a C"]
#[doc = r" `int` or they all fit into an `unsigned int`."]
pub static REPR_C_ENUMS_LARGER_THAN_INT: &crate::Lint =
    &crate::Lint {
            name: "REPR_C_ENUMS_LARGER_THAN_INT",
            default_level: crate::Warn,
            desc: "repr(C) enums with discriminant values that do not fit into a C int",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 124403,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
5478    /// The `repr_c_enums_larger_than_int` lint detects `repr(C)` enums with discriminant
5479    /// values that do not fit into a C `int` or `unsigned int`.
5480    ///
5481    /// ### Example
5482    ///
5483    /// ```rust,ignore (only errors on 64bit)
5484    /// #[repr(C)]
5485    /// enum E {
5486    ///     V = 9223372036854775807, // i64::MAX
5487    /// }
5488    /// ```
5489    ///
5490    /// This will produce:
5491    ///
5492    /// ```text
5493    /// error: `repr(C)` enum discriminant does not fit into C `int` nor into C `unsigned int`
5494    ///   --> $DIR/repr-c-big-discriminant1.rs:16:5
5495    ///    |
5496    /// LL |     A = 9223372036854775807, // i64::MAX
5497    ///    |     ^
5498    ///    |
5499    ///    = note: `repr(C)` enums with big discriminants are non-portable, and their size in Rust might not match their size in C
5500    ///    = help: use `repr($int_ty)` instead to explicitly set the size of this enum
5501    /// ```
5502    ///
5503    /// ### Explanation
5504    ///
5505    /// In C, enums with discriminants that do not all fit into an `int` or all fit into an
5506    /// `unsigned int` are a portability hazard: such enums are only permitted since C23, and not
5507    /// supported e.g. by MSVC.
5508    ///
5509    /// Furthermore, Rust interprets the discriminant values of `repr(C)` enums as expressions of
5510    /// type `isize`. This makes it impossible to implement the C23 behavior of enums where the enum
5511    /// discriminants have no predefined type and instead the enum uses a type large enough to hold
5512    /// all discriminants.
5513    ///
5514    /// Therefore, `repr(C)` enums in Rust require that either all discriminants to fit into a C
5515    /// `int` or they all fit into an `unsigned int`.
5516    pub REPR_C_ENUMS_LARGER_THAN_INT,
5517    Warn,
5518    "repr(C) enums with discriminant values that do not fit into a C int",
5519    @future_incompatible = FutureIncompatibleInfo {
5520        reason: fcw!(FutureReleaseError #124403),
5521        report_in_deps: false,
5522    };
5523}
5524
5525#[doc =
r" The `varargs_without_pattern` lint detects when `...` is used as an argument to a"]
#[doc = r" non-foreign function without any pattern being specified."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc =
r" // Using `...` in non-foreign function definitions is unstable, however stability is"]
#[doc =
r" // currently only checked after attributes are expanded, so using `#[cfg(false)]` here will"]
#[doc = r" // allow this to compile on stable Rust."]
#[doc = r" #[cfg(false)]"]
#[doc = r" fn foo(...) {"]
#[doc = r""]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Patterns are currently required for all non-`...` arguments in function definitions (with"]
#[doc =
r" some exceptions in the 2015 edition). Requiring `...` arguments to have patterns in"]
#[doc =
r" non-foreign function definitions makes the language more consistent, and removes a source of"]
#[doc =
r" confusion for the unstable C variadic feature. `...` arguments without a pattern are already"]
#[doc =
r" stable and widely used in foreign function definitions; this lint only affects non-foreign"]
#[doc = r" function definitions."]
#[doc = r""]
#[doc =
r" Using `...` (C varargs) in a non-foreign function definition is currently unstable. However,"]
#[doc =
r" stability checking for the `...` syntax in non-foreign function definitions is currently"]
#[doc =
r" implemented after attributes have been expanded, meaning that if the attribute removes the"]
#[doc =
r" use of the unstable syntax (e.g. `#[cfg(false)]`, or a procedural macro), the code will"]
#[doc =
r" compile on stable Rust; this is the only situation where this lint affects code that"]
#[doc = r" compiles on stable Rust."]
#[doc = r""]
#[doc =
r" This is a [future-incompatible] lint to transition this to a hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static VARARGS_WITHOUT_PATTERN: &crate::Lint =
    &crate::Lint {
            name: "VARARGS_WITHOUT_PATTERN",
            default_level: crate::Deny,
            desc: "detects usage of `...` arguments without a pattern in non-foreign items",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 145544,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
5526    /// The `varargs_without_pattern` lint detects when `...` is used as an argument to a
5527    /// non-foreign function without any pattern being specified.
5528    ///
5529    /// ### Example
5530    ///
5531    /// ```rust,compile_fail
5532    /// // Using `...` in non-foreign function definitions is unstable, however stability is
5533    /// // currently only checked after attributes are expanded, so using `#[cfg(false)]` here will
5534    /// // allow this to compile on stable Rust.
5535    /// #[cfg(false)]
5536    /// fn foo(...) {
5537    ///
5538    /// }
5539    /// ```
5540    ///
5541    /// {{produces}}
5542    ///
5543    /// ### Explanation
5544    ///
5545    /// Patterns are currently required for all non-`...` arguments in function definitions (with
5546    /// some exceptions in the 2015 edition). Requiring `...` arguments to have patterns in
5547    /// non-foreign function definitions makes the language more consistent, and removes a source of
5548    /// confusion for the unstable C variadic feature. `...` arguments without a pattern are already
5549    /// stable and widely used in foreign function definitions; this lint only affects non-foreign
5550    /// function definitions.
5551    ///
5552    /// Using `...` (C varargs) in a non-foreign function definition is currently unstable. However,
5553    /// stability checking for the `...` syntax in non-foreign function definitions is currently
5554    /// implemented after attributes have been expanded, meaning that if the attribute removes the
5555    /// use of the unstable syntax (e.g. `#[cfg(false)]`, or a procedural macro), the code will
5556    /// compile on stable Rust; this is the only situation where this lint affects code that
5557    /// compiles on stable Rust.
5558    ///
5559    /// This is a [future-incompatible] lint to transition this to a hard error in the future.
5560    ///
5561    /// [future-incompatible]: ../index.md#future-incompatible-lints
5562    pub VARARGS_WITHOUT_PATTERN,
5563    Deny,
5564    "detects usage of `...` arguments without a pattern in non-foreign items",
5565    @future_incompatible = FutureIncompatibleInfo {
5566        reason: fcw!(FutureReleaseError #145544),
5567        report_in_deps: true,
5568    };
5569}
5570
5571#[doc =
r" The `deprecated_llvm_intrinsic` lint detects usage of deprecated LLVM intrinsics."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,ignore (requires x86)"]
#[doc = r#" #![cfg(any(target_arch = "x86", target_arch = "x86_64"))]"#]
#[doc = r" #![feature(link_llvm_intrinsics)]"]
#[doc = r" #![deny(deprecated_llvm_intrinsic)]"]
#[doc = r""]
#[doc = r#" unsafe extern "llvm-intrinsic" {"#]
#[doc = r#"     #[link_name = "llvm.x86.addcarryx.u32"]"#]
#[doc = r"     fn foo(a: u8, b: u32, c: u32, d: &mut u32) -> u8;"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" #[inline(never)]"]
#[doc = r#" #[target_feature(enable = "adx")]"#]
#[doc = r" pub fn bar(a: u8, b: u32, c: u32, d: &mut u32) -> u8 {"]
#[doc = r"     unsafe { foo(a, b, c, d) }"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" error: Using deprecated intrinsic `llvm.x86.addcarryx.u32`"]
#[doc = r"  --> example.rs:7:5"]
#[doc = r"   |"]
#[doc = r" 7 |     fn foo(a: u8, b: u32, c: u32, d: &mut u32) -> u8;"]
#[doc = r"   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r"   |"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" LLVM periodically updates its list of intrinsics. Deprecated intrinsics are unlikely"]
#[doc =
r" to be removed, but they may optimize less well than their new versions, so it's"]
#[doc =
r" best to use the new version. Also, some deprecated intrinsics might have buggy"]
#[doc = r" behavior."]
#[doc = r""]
#[doc =
r" This `link_llvm_intrinsics` lint is intended to be used internally only, and requires the"]
#[doc =
r" `#![feature(link_llvm_intrinsics)]` internal feature gate. For more information, see [its chapter in"]
#[doc =
r" the Unstable Book](https://doc.rust-lang.org/unstable-book/language-features/link-llvm-intrinsics.html)"]
#[doc =
r" and [its tracking issue](https://github.com/rust-lang/rust/issues/29602)."]
pub static DEPRECATED_LLVM_INTRINSIC: &crate::Lint =
    &crate::Lint {
            name: "DEPRECATED_LLVM_INTRINSIC",
            default_level: crate::Allow,
            desc: "detects uses of deprecated LLVM intrinsics",
            feature_gate: Some(rustc_span::sym::link_llvm_intrinsics),
            ..
        };declare_lint! {
5572    /// The `deprecated_llvm_intrinsic` lint detects usage of deprecated LLVM intrinsics.
5573    ///
5574    /// ### Example
5575    ///
5576    /// ```rust,ignore (requires x86)
5577    /// #![cfg(any(target_arch = "x86", target_arch = "x86_64"))]
5578    /// #![feature(link_llvm_intrinsics)]
5579    /// #![deny(deprecated_llvm_intrinsic)]
5580    ///
5581    /// unsafe extern "llvm-intrinsic" {
5582    ///     #[link_name = "llvm.x86.addcarryx.u32"]
5583    ///     fn foo(a: u8, b: u32, c: u32, d: &mut u32) -> u8;
5584    /// }
5585    ///
5586    /// #[inline(never)]
5587    /// #[target_feature(enable = "adx")]
5588    /// pub fn bar(a: u8, b: u32, c: u32, d: &mut u32) -> u8 {
5589    ///     unsafe { foo(a, b, c, d) }
5590    /// }
5591    /// ```
5592    ///
5593    /// This will produce:
5594    ///
5595    /// ```text
5596    /// error: Using deprecated intrinsic `llvm.x86.addcarryx.u32`
5597    ///  --> example.rs:7:5
5598    ///   |
5599    /// 7 |     fn foo(a: u8, b: u32, c: u32, d: &mut u32) -> u8;
5600    ///   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
5601    ///   |
5602    /// ```
5603    ///
5604    /// ### Explanation
5605    ///
5606    /// LLVM periodically updates its list of intrinsics. Deprecated intrinsics are unlikely
5607    /// to be removed, but they may optimize less well than their new versions, so it's
5608    /// best to use the new version. Also, some deprecated intrinsics might have buggy
5609    /// behavior.
5610    ///
5611    /// This `link_llvm_intrinsics` lint is intended to be used internally only, and requires the
5612    /// `#![feature(link_llvm_intrinsics)]` internal feature gate. For more information, see [its chapter in
5613    /// the Unstable Book](https://doc.rust-lang.org/unstable-book/language-features/link-llvm-intrinsics.html)
5614    /// and [its tracking issue](https://github.com/rust-lang/rust/issues/29602).
5615    pub DEPRECATED_LLVM_INTRINSIC,
5616    Allow,
5617    "detects uses of deprecated LLVM intrinsics",
5618    @feature_gate = link_llvm_intrinsics;
5619}
5620
5621#[doc =
r" The `float_literal_f32_fallback` lint detects situations where the type of an unsuffixed"]
#[doc =
r" float literal falls back to `f32` instead of `f64` to avoid a compilation error. This occurs"]
#[doc =
r" when there is a trait bound `f32: From<T>` (or equivalent, such as `T: Into<f32>`) and the"]
#[doc = r" literal is inferred to have the same type as `T`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" fn foo(x: impl Into<f32>) -> f32 {"]
#[doc = r"     x.into()"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" fn main() {"]
#[doc = r"     dbg!(foo(2.5));"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Rust allows traits that are only implemented for a single floating point type to guide type"]
#[doc =
r" inference for floating point literals. This used to apply in the case of `f32: From<T>`"]
#[doc =
r" (where `T` was inferred to be the same type as a floating point literal), as the only"]
#[doc =
r" floating point type impl was `f32: From<f32>`. However, as Rust is in the process of adding"]
#[doc =
r" support for `f16`, there are now two implementations for floating point types:"]
#[doc =
r" `f32: From<f16>` and `f32: From<f32>`. This means that the trait bound `f32: From<T>` can no"]
#[doc =
r" longer guide inference for the type of the floating point literal. The default fallback for"]
#[doc =
r" unsuffixed floating point literals is `f64`. As `f32` does not implement `From<f64>`,"]
#[doc =
r" falling back to `f64` would cause a compilation error; therefore, the float type fallback"]
#[doc =
r" has been tempoarily adjusted to fallback to `f32` in this scenario."]
#[doc = r""]
#[doc =
r" The lint will automatically provide a machine-applicable suggestion to add a `_f32` suffix"]
#[doc = r" to the literal, which will fix the problem."]
#[doc = r""]
#[doc =
r" This is a [future-incompatible] lint to transition this to a hard error in the future. See"]
#[doc = r" [issue #154024] for more details."]
#[doc = r""]
#[doc = r" [issue #154024]: https://github.com/rust-lang/rust/issues/154024"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static FLOAT_LITERAL_F32_FALLBACK: &crate::Lint =
    &crate::Lint {
            name: "FLOAT_LITERAL_F32_FALLBACK",
            default_level: crate::Warn,
            desc: "detects unsuffixed floating point literals whose type fallback to `f32`",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 154024,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
5622    /// The `float_literal_f32_fallback` lint detects situations where the type of an unsuffixed
5623    /// float literal falls back to `f32` instead of `f64` to avoid a compilation error. This occurs
5624    /// when there is a trait bound `f32: From<T>` (or equivalent, such as `T: Into<f32>`) and the
5625    /// literal is inferred to have the same type as `T`.
5626    ///
5627    /// ### Example
5628    ///
5629    /// ```rust
5630    /// fn foo(x: impl Into<f32>) -> f32 {
5631    ///     x.into()
5632    /// }
5633    ///
5634    /// fn main() {
5635    ///     dbg!(foo(2.5));
5636    /// }
5637    /// ```
5638    ///
5639    /// {{produces}}
5640    ///
5641    /// ### Explanation
5642    ///
5643    /// Rust allows traits that are only implemented for a single floating point type to guide type
5644    /// inference for floating point literals. This used to apply in the case of `f32: From<T>`
5645    /// (where `T` was inferred to be the same type as a floating point literal), as the only
5646    /// floating point type impl was `f32: From<f32>`. However, as Rust is in the process of adding
5647    /// support for `f16`, there are now two implementations for floating point types:
5648    /// `f32: From<f16>` and `f32: From<f32>`. This means that the trait bound `f32: From<T>` can no
5649    /// longer guide inference for the type of the floating point literal. The default fallback for
5650    /// unsuffixed floating point literals is `f64`. As `f32` does not implement `From<f64>`,
5651    /// falling back to `f64` would cause a compilation error; therefore, the float type fallback
5652    /// has been tempoarily adjusted to fallback to `f32` in this scenario.
5653    ///
5654    /// The lint will automatically provide a machine-applicable suggestion to add a `_f32` suffix
5655    /// to the literal, which will fix the problem.
5656    ///
5657    /// This is a [future-incompatible] lint to transition this to a hard error in the future. See
5658    /// [issue #154024] for more details.
5659    ///
5660    /// [issue #154024]: https://github.com/rust-lang/rust/issues/154024
5661    /// [future-incompatible]: ../index.md#future-incompatible-lints
5662    pub FLOAT_LITERAL_F32_FALLBACK,
5663    Warn,
5664    "detects unsuffixed floating point literals whose type fallback to `f32`",
5665    @future_incompatible = FutureIncompatibleInfo {
5666        reason: fcw!(FutureReleaseError #154024),
5667        report_in_deps: false,
5668    };
5669}
5670
5671#[doc = r" The `unsafe_code` lint catches usage of `unsafe` code and other"]
#[doc = r" potentially unsound constructs like `no_mangle`, `export_name`,"]
#[doc = r" and `link_section`."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![deny(unsafe_code)]"]
#[doc = r" fn main() {"]
#[doc = r"     unsafe {"]
#[doc = r""]
#[doc = r"     }"]
#[doc = r" }"]
#[doc = r""]
#[doc = r" #[no_mangle]"]
#[doc = r" fn func_0() { }"]
#[doc = r""]
#[doc = r#" #[export_name = "exported_symbol_name"]"#]
#[doc = r" pub fn name_in_rust() { }"]
#[doc = r""]
#[doc = r" #[no_mangle]"]
#[doc = r#" #[link_section = ".example_section"]"#]
#[doc = r" pub static VAR1: u32 = 1;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This lint is intended to restrict the usage of `unsafe` blocks and other"]
#[doc =
r" constructs (including, but not limited to `no_mangle`, `link_section`"]
#[doc =
r" and `export_name` attributes) wrong usage of which causes undefined"]
#[doc = r" behavior."]
pub static UNSAFE_CODE: &crate::Lint =
    &crate::Lint {
            name: "UNSAFE_CODE",
            default_level: crate::Allow,
            desc: "usage of `unsafe` code and other potentially unsound constructs",
            eval_always: true,
            ..
        };declare_lint! {
5672    /// The `unsafe_code` lint catches usage of `unsafe` code and other
5673    /// potentially unsound constructs like `no_mangle`, `export_name`,
5674    /// and `link_section`.
5675    ///
5676    /// ### Example
5677    ///
5678    /// ```rust,compile_fail
5679    /// #![deny(unsafe_code)]
5680    /// fn main() {
5681    ///     unsafe {
5682    ///
5683    ///     }
5684    /// }
5685    ///
5686    /// #[no_mangle]
5687    /// fn func_0() { }
5688    ///
5689    /// #[export_name = "exported_symbol_name"]
5690    /// pub fn name_in_rust() { }
5691    ///
5692    /// #[no_mangle]
5693    /// #[link_section = ".example_section"]
5694    /// pub static VAR1: u32 = 1;
5695    /// ```
5696    ///
5697    /// {{produces}}
5698    ///
5699    /// ### Explanation
5700    ///
5701    /// This lint is intended to restrict the usage of `unsafe` blocks and other
5702    /// constructs (including, but not limited to `no_mangle`, `link_section`
5703    /// and `export_name` attributes) wrong usage of which causes undefined
5704    /// behavior.
5705    pub UNSAFE_CODE,
5706    Allow,
5707    "usage of `unsafe` code and other potentially unsound constructs",
5708    @eval_always = true
5709}
5710
5711#[doc =
r" The `method_call_on_diverging_infer_var` lint detects situations in which a method is called on a value resulting from a never-to-any coercion,"]
#[doc = r" without necessary information to infer a type for it."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,no_run"]
#[doc = r" fn main() {"]
#[doc = r"     let x = panic!();"]
#[doc = r"     x.clone();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Rust does not generally allow calling methods on values which do not have a known type,"]
#[doc = r" such a result of a never-to-any coercion with no type specified."]
#[doc = r""]
#[doc =
r" To aid with transition of code calling methods on `Infallible` after changing `Infallible` to be an alias for `!`, rustc *temporarily* allows such calls."]
#[doc = r" This will (once again) become an error in the future."]
#[doc = r""]
#[doc =
r" Thanks to never-to-any coercion you can replace method calls on `!` with the use of the `!` variable, or an `as` cast to an explicit type:"]
#[doc = r""]
#[doc = r" ```diff"]
#[doc = r" - x.clone()"]
#[doc = r" + x"]
#[doc = r" ```"]
#[doc = r" ```diff"]
#[doc = r" - result.map(|x| x.convert_error())?;"]
#[doc = r" + result.map(|x| x as ErrorType)?;"]
#[doc = r" ```"]
pub static METHOD_CALL_ON_DIVERGING_INFER_VAR: &crate::Lint =
    &crate::Lint {
            name: "METHOD_CALL_ON_DIVERGING_INFER_VAR",
            default_level: crate::Warn,
            desc: "detects method calls on a result of never-to-any coercion",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 156047,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
5712    /// The `method_call_on_diverging_infer_var` lint detects situations in which a method is called on a value resulting from a never-to-any coercion,
5713    /// without necessary information to infer a type for it.
5714    ///
5715    /// ### Example
5716    ///
5717    /// ```rust,no_run
5718    /// fn main() {
5719    ///     let x = panic!();
5720    ///     x.clone();
5721    /// }
5722    /// ```
5723    ///
5724    /// {{produces}}
5725    ///
5726    /// ### Explanation
5727    ///
5728    /// Rust does not generally allow calling methods on values which do not have a known type,
5729    /// such a result of a never-to-any coercion with no type specified.
5730    ///
5731    /// To aid with transition of code calling methods on `Infallible` after changing `Infallible` to be an alias for `!`, rustc *temporarily* allows such calls.
5732    /// This will (once again) become an error in the future.
5733    ///
5734    /// Thanks to never-to-any coercion you can replace method calls on `!` with the use of the `!` variable, or an `as` cast to an explicit type:
5735    ///
5736    /// ```diff
5737    /// - x.clone()
5738    /// + x
5739    /// ```
5740    /// ```diff
5741    /// - result.map(|x| x.convert_error())?;
5742    /// + result.map(|x| x as ErrorType)?;
5743    /// ```
5744    pub METHOD_CALL_ON_DIVERGING_INFER_VAR,
5745    Warn,
5746    "detects method calls on a result of never-to-any coercion",
5747    @future_incompatible = FutureIncompatibleInfo {
5748        reason: fcw!(FutureReleaseError #156047),
5749        report_in_deps: true,
5750    };
5751}
5752
5753#[doc =
r" The `recursion_depth_exceeding_limit` lint detects cases where the compiler does not"]
#[doc = r" correctly track the recursion depth in obligation evaluation."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r" ```text"]
#[doc = r" rustc -Znext-solver example.rs"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ```rust,ignore (requires next solver)"]
#[doc = r#" #![recursion_limit = "8"]"#]
#[doc = r" struct Foo<T> {"]
#[doc = r"    t: T,"]
#[doc = r"    opt_t: Option<T>,"]
#[doc = r" }"]
#[doc = r" fn require_sync<T: Sync>() {}"]
#[doc = r" fn main() {"]
#[doc = r"     require_sync::<Foo<Foo<Foo<Foo<Foo<Foo<()>>>>>>>();"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produces:"]
#[doc = r" ```text"]
#[doc =
r" error[E0275]: overflow evaluating the requirement `Foo<Foo<Foo<Foo<Foo<Foo<()>>>>>>: Sync`"]
#[doc = r"  --> example.rs:12:20"]
#[doc = r"   |"]
#[doc = r"   |     require_sync::<Foo<Foo<Foo<Foo<Foo<Foo<()>>>>>>>();"]
#[doc = r"   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"]
#[doc = r"   |"]
#[doc =
r#"   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "16"]` attribute to your crate"#]
#[doc = r" note: required by a bound in `require_sync`"]
#[doc = r"  --> example.rs:9:20"]
#[doc = r"   |"]
#[doc = r"   | fn require_sync<T: Sync>() {}"]
#[doc =
r"   |                    ^^^^ required by this bound in `require_sync`"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The compiler uses a recursion limit in obligation evaluation to avoid hangs."]
#[doc = r""]
#[doc =
r" However, the old trait solver sometimes ignores the recursion depth, whereas"]
#[doc =
r" the new solver correctly tracks it. This reveals cases where overflow should"]
#[doc = r" have occurred previously."]
#[doc = r""]
#[doc =
r" This is a [future-incompatible] lint to transition this to a hard error in the future."]
#[doc = r""]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static RECURSION_DEPTH_EXCEEDING_LIMIT: &crate::Lint =
    &crate::Lint {
            name: "RECURSION_DEPTH_EXCEEDING_LIMIT",
            default_level: crate::Warn,
            desc: "detects trait solving overflow that only happens with the next solver",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 159228,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
5754    /// The `recursion_depth_exceeding_limit` lint detects cases where the compiler does not
5755    /// correctly track the recursion depth in obligation evaluation.
5756    ///
5757    /// ### Example
5758    /// ```text
5759    /// rustc -Znext-solver example.rs
5760    /// ```
5761    ///
5762    /// ```rust,ignore (requires next solver)
5763    /// #![recursion_limit = "8"]
5764    /// struct Foo<T> {
5765    ///    t: T,
5766    ///    opt_t: Option<T>,
5767    /// }
5768    /// fn require_sync<T: Sync>() {}
5769    /// fn main() {
5770    ///     require_sync::<Foo<Foo<Foo<Foo<Foo<Foo<()>>>>>>>();
5771    /// }
5772    /// ```
5773    ///
5774    /// This will produces:
5775    /// ```text
5776    /// error[E0275]: overflow evaluating the requirement `Foo<Foo<Foo<Foo<Foo<Foo<()>>>>>>: Sync`
5777    ///  --> example.rs:12:20
5778    ///   |
5779    ///   |     require_sync::<Foo<Foo<Foo<Foo<Foo<Foo<()>>>>>>>();
5780    ///   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
5781    ///   |
5782    ///   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "16"]` attribute to your crate
5783    /// note: required by a bound in `require_sync`
5784    ///  --> example.rs:9:20
5785    ///   |
5786    ///   | fn require_sync<T: Sync>() {}
5787    ///   |                    ^^^^ required by this bound in `require_sync`
5788    /// ```
5789    ///
5790    /// ### Explanation
5791    ///
5792    /// The compiler uses a recursion limit in obligation evaluation to avoid hangs.
5793    ///
5794    /// However, the old trait solver sometimes ignores the recursion depth, whereas
5795    /// the new solver correctly tracks it. This reveals cases where overflow should
5796    /// have occurred previously.
5797    ///
5798    /// This is a [future-incompatible] lint to transition this to a hard error in the future.
5799    ///
5800    /// [future-incompatible]: ../index.md#future-incompatible-lints
5801    pub RECURSION_DEPTH_EXCEEDING_LIMIT,
5802    Warn,
5803    "detects trait solving overflow that only happens with the next solver",
5804    @future_incompatible = FutureIncompatibleInfo {
5805        reason: fcw!(FutureReleaseError #159228),
5806        report_in_deps: false,
5807    };
5808}
5809
5810#[doc =
r" The `duplicate_tools` lint detects duplicate tools found in crate-level"]
#[doc =
r" [`register_tool` attributes] (including `register_attribute_tool` or `register_lint_tool`)."]
#[doc = r""]
#[doc =
r" [`register_tool` attributes]: https://doc.rust-lang.org/nightly/unstable-book/language-features/register-tool.html"]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![feature(register_tool)]"]
#[doc = r" #![register_tool(foo)]"]
#[doc = r" #![register_tool(foo)]"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc = r" Enabling a tool more than once is a no-op."]
#[doc =
r" To avoid this warning, remove the second `register_tool()` attribute."]
pub static DUPLICATE_TOOLS: &crate::Lint =
    &crate::Lint {
            name: "DUPLICATE_TOOLS",
            default_level: crate::Deny,
            desc: "duplicate tools found in crate-level `#[register_tools]` directives",
            feature_gate: Some(rustc_span::sym::register_tool),
            ..
        };declare_lint! {
5811    /// The `duplicate_tools` lint detects duplicate tools found in crate-level
5812    /// [`register_tool` attributes] (including `register_attribute_tool` or `register_lint_tool`).
5813    ///
5814    /// [`register_tool` attributes]: https://doc.rust-lang.org/nightly/unstable-book/language-features/register-tool.html
5815    ///
5816    /// ### Example
5817    ///
5818    /// ```rust,compile_fail
5819    /// #![feature(register_tool)]
5820    /// #![register_tool(foo)]
5821    /// #![register_tool(foo)]
5822    /// ```
5823    ///
5824    /// {{produces}}
5825    ///
5826    /// ### Explanation
5827    ///
5828    /// Enabling a tool more than once is a no-op.
5829    /// To avoid this warning, remove the second `register_tool()` attribute.
5830    pub DUPLICATE_TOOLS,
5831    Deny,
5832    "duplicate tools found in crate-level `#[register_tools]` directives",
5833    @feature_gate = register_tool;
5834}
5835
5836#[doc =
r" The `aligned_fields_in_packed` lint detects fields with `align` representation hints"]
#[doc = r" inside `repr(C)` types with `packed` representation hint."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #[repr(C, align(16))]"]
#[doc = r" struct Aligned(i32);"]
#[doc = r""]
#[doc = r" #[repr(C, packed)] // error!"]
#[doc = r" struct Packed(Aligned);"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" The behavior of this combination of hints is inconsistent across C compilers. The layout"]
#[doc =
r" computed for these types by Rust may thus not match the layout actually used by C."]
#[doc =
r" Specifically, Rust always follows the GCC convention, which makes it incompatible with MSVC"]
#[doc =
r" for these types. This may change in the future for targets where GCC is not the default C"]
#[doc = r" compiler."]
pub static ALIGNED_FIELDS_IN_PACKED: &crate::Lint =
    &crate::Lint {
            name: "ALIGNED_FIELDS_IN_PACKED",
            default_level: crate::Deny,
            desc: "`repr(C, align)` types nested inside `repr(C, packed)` types \
    do not always have a C-compatible layout",
            ..
        };declare_lint! {
5837    /// The `aligned_fields_in_packed` lint detects fields with `align` representation hints
5838    /// inside `repr(C)` types with `packed` representation hint.
5839    ///
5840    /// ### Example
5841    ///
5842    /// ```rust,compile_fail
5843    /// #[repr(C, align(16))]
5844    /// struct Aligned(i32);
5845    ///
5846    /// #[repr(C, packed)] // error!
5847    /// struct Packed(Aligned);
5848    /// ```
5849    ///
5850    /// {{produces}}
5851    ///
5852    /// ### Explanation
5853    ///
5854    /// The behavior of this combination of hints is inconsistent across C compilers. The layout
5855    /// computed for these types by Rust may thus not match the layout actually used by C.
5856    /// Specifically, Rust always follows the GCC convention, which makes it incompatible with MSVC
5857    /// for these types. This may change in the future for targets where GCC is not the default C
5858    /// compiler.
5859    pub ALIGNED_FIELDS_IN_PACKED,
5860    Deny,
5861    "`repr(C, align)` types nested inside `repr(C, packed)` types \
5862    do not always have a C-compatible layout",
5863}
5864
5865#[doc =
r" The `unstable_imports` lints detects imports that go through unstable modules."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust"]
#[doc = r" use core::intrinsics::transmute;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Previous versions of Rust accidentally allowed certain imports through unstable modules"]
#[doc =
r" because stability information of modules was not correctly accounted for if the imported"]
#[doc = r" item was stable itself."]
pub static UNSTABLE_IMPORTS: &crate::Lint =
    &crate::Lint {
            name: "UNSTABLE_IMPORTS",
            default_level: crate::Deny,
            desc: "lints on accidentally allowed unstable imports",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 163160,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
5866    /// The `unstable_imports` lints detects imports that go through unstable modules.
5867    ///
5868    /// ### Example
5869    ///
5870    /// ```rust
5871    /// use core::intrinsics::transmute;
5872    /// ```
5873    ///
5874    /// {{produces}}
5875    ///
5876    /// ### Explanation
5877    ///
5878    /// Previous versions of Rust accidentally allowed certain imports through unstable modules
5879    /// because stability information of modules was not correctly accounted for if the imported
5880    /// item was stable itself.
5881    pub UNSTABLE_IMPORTS,
5882    Deny,
5883    "lints on accidentally allowed unstable imports",
5884    @future_incompatible = FutureIncompatibleInfo {
5885        reason: fcw!(FutureReleaseError # 163160),
5886        report_in_deps: true,
5887    };
5888}
5889
5890#[doc = r" The `unsafe_panic_handlers` lint detects unsafe functions with"]
#[doc = r" the `#[panic_handler]` attribute."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #![no_std]"]
#[doc = r""]
#[doc = r" use core::panic::PanicInfo;"]
#[doc = r""]
#[doc = r" #[panic_handler]"]
#[doc = r" unsafe fn handle(_: &PanicInfo<'_>) -> ! {"]
#[doc = r"     loop {}"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Unsafe functions (declared as `unsafe fn`) are functions that can only be called"]
#[doc =
r" when the caller ensures that their safety requirements are met. On the other hand,"]
#[doc =
r" `#[panic_handler]` functions get called automatically by the compiler without"]
#[doc =
r" checking for any preconditions. Therefore, using the `#[panic_handler]` attribute"]
#[doc =
r" on unsafe functions is either incorrect or a misuse of `unsafe fn`."]
#[doc = r""]
#[doc = r" This is a [future-incompatible] lint to transition this to a hard"]
#[doc = r" error in the future. See [issue #163263] for more details."]
#[doc = r""]
#[doc = r" [issue #163263]: https://github.com/rust-lang/rust/issues/163263"]
pub static UNSAFE_PANIC_HANDLERS: &crate::Lint =
    &crate::Lint {
            name: "UNSAFE_PANIC_HANDLERS",
            default_level: crate::Warn,
            desc: "detects unsafe functions with the `#[panic_handler]` attribute",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 163263,
                        }),
                    ..
                }),
            ..
        };declare_lint! {
5891    /// The `unsafe_panic_handlers` lint detects unsafe functions with
5892    /// the `#[panic_handler]` attribute.
5893    ///
5894    /// ### Example
5895    ///
5896    /// ```rust,compile_fail
5897    /// #![no_std]
5898    ///
5899    /// use core::panic::PanicInfo;
5900    ///
5901    /// #[panic_handler]
5902    /// unsafe fn handle(_: &PanicInfo<'_>) -> ! {
5903    ///     loop {}
5904    /// }
5905    /// ```
5906    ///
5907    /// {{produces}}
5908    ///
5909    /// ### Explanation
5910    ///
5911    /// Unsafe functions (declared as `unsafe fn`) are functions that can only be called
5912    /// when the caller ensures that their safety requirements are met. On the other hand,
5913    /// `#[panic_handler]` functions get called automatically by the compiler without
5914    /// checking for any preconditions. Therefore, using the `#[panic_handler]` attribute
5915    /// on unsafe functions is either incorrect or a misuse of `unsafe fn`.
5916    ///
5917    /// This is a [future-incompatible] lint to transition this to a hard
5918    /// error in the future. See [issue #163263] for more details.
5919    ///
5920    /// [issue #163263]: https://github.com/rust-lang/rust/issues/163263
5921    pub UNSAFE_PANIC_HANDLERS,
5922    Warn,
5923    "detects unsafe functions with the `#[panic_handler]` attribute",
5924    @future_incompatible = FutureIncompatibleInfo {
5925        reason: fcw!(FutureReleaseError #163263),
5926    };
5927}
5928
5929#[doc =
r" The `partial_stack_protector` lint detects uses of the `-Z stack-protector`"]
#[doc =
r" compile flag to build a program that contains crates that are not protected"]
#[doc =
r" by stack-protector, or protected by a weaker level of it than the crate"]
#[doc = r" you are compiling."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```text"]
#[doc = r" rustc -Z stack-protector=all"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ```rust,ignore (needs command line option)"]
#[doc = r" fn main() {}"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" This will produce:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" warning: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled"]
#[doc = r"  |"]
#[doc =
r"  = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled"]
#[doc =
r"  = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector`"]
#[doc =
r"  = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"]
#[doc =
r"  = note: for more information, see issue #154613 <https://github.com/rust-lang/rust/issues/154613>"]
#[doc =
r"  = note: `#[warn(partial_stack_protector)]` (part of `#[warn(future_incompatible)]`) on by default"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Using the `-Z stack-protector` flag on only part of a compiled object"]
#[doc =
r" will lead to a compiled program that is not fully protected by stack-protector,"]
#[doc =
r" which is a security risk. This was previously accepted and used in practice,"]
#[doc =
r" and is now being phased out. This is a [future-incompatible] lint to transition this"]
#[doc =
r" to a hard error in the future. See [issue #154613] for more details."]
#[doc = r""]
#[doc =
r" If you intentionally want to use the `-Z stack-protector` flag for only a part"]
#[doc =
r" of your compiled program, you can allow it in a future-compatible way"]
#[doc =
r" using the `-Z allow-partial-mitigations=stack-protector` flag, which must be"]
#[doc =
r" passed *after* the `-Z stack-protector` flag in the command line, for example:"]
#[doc = r""]
#[doc = r" ```text"]
#[doc =
r" rustc -Z stack-protector=all -Z allow-partial-mitigations=stack-protector"]
#[doc = r" ```"]
#[doc = r""]
#[doc =
r" The order dependency is by design, see the [RFC 3855] for details."]
#[doc = r""]
#[doc = r" [issue #154613]: https://github.com/rust-lang/rust/issues/154613"]
#[doc =
r" [RFC 3855]: https://github.com/rust-lang/rfcs/blob/master/text/3855-mitigation-enforcement.md"]
#[doc = r" [future-incompatible]: ../index.md#future-incompatible-lints"]
pub static PARTIAL_STACK_PROTECTOR: &crate::Lint =
    &crate::Lint {
            name: "PARTIAL_STACK_PROTECTOR",
            default_level: crate::Warn,
            desc: "partial use of stack-protector that was previously accepted and used in practice",
            crate_level_only: true,
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 154613,
                        }),
                    report_in_deps: false,
                    ..
                }),
            ..
        };declare_lint! {
5930    /// The `partial_stack_protector` lint detects uses of the `-Z stack-protector`
5931    /// compile flag to build a program that contains crates that are not protected
5932    /// by stack-protector, or protected by a weaker level of it than the crate
5933    /// you are compiling.
5934    ///
5935    /// ### Example
5936    ///
5937    /// ```text
5938    /// rustc -Z stack-protector=all
5939    /// ```
5940    ///
5941    /// ```rust,ignore (needs command line option)
5942    /// fn main() {}
5943    /// ```
5944    ///
5945    /// This will produce:
5946    ///
5947    /// ```text
5948    /// warning: your program uses the crate `std`, that is not compiled with `stack-protector=all` enabled
5949    ///  |
5950    ///  = note: recompile `std` with `stack-protector=all` enabled, or use `-Z allow-partial-mitigations=stack-protector` to allow creating an artifact that has the mitigation partially enabled
5951    ///  = help: it is possible to disable `-Z allow-partial-mitigations=stack-protector` via `-Z deny-partial-mitigations=stack-protector`
5952    ///  = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
5953    ///  = note: for more information, see issue #154613 <https://github.com/rust-lang/rust/issues/154613>
5954    ///  = note: `#[warn(partial_stack_protector)]` (part of `#[warn(future_incompatible)]`) on by default
5955    /// ```
5956    ///
5957    /// ### Explanation
5958    ///
5959    /// Using the `-Z stack-protector` flag on only part of a compiled object
5960    /// will lead to a compiled program that is not fully protected by stack-protector,
5961    /// which is a security risk. This was previously accepted and used in practice,
5962    /// and is now being phased out. This is a [future-incompatible] lint to transition this
5963    /// to a hard error in the future. See [issue #154613] for more details.
5964    ///
5965    /// If you intentionally want to use the `-Z stack-protector` flag for only a part
5966    /// of your compiled program, you can allow it in a future-compatible way
5967    /// using the `-Z allow-partial-mitigations=stack-protector` flag, which must be
5968    /// passed *after* the `-Z stack-protector` flag in the command line, for example:
5969    ///
5970    /// ```text
5971    /// rustc -Z stack-protector=all -Z allow-partial-mitigations=stack-protector
5972    /// ```
5973    ///
5974    /// The order dependency is by design, see the [RFC 3855] for details.
5975    ///
5976    /// [issue #154613]: https://github.com/rust-lang/rust/issues/154613
5977    /// [RFC 3855]: https://github.com/rust-lang/rfcs/blob/master/text/3855-mitigation-enforcement.md
5978    /// [future-incompatible]: ../index.md#future-incompatible-lints
5979    pub PARTIAL_STACK_PROTECTOR,
5980    Warn,
5981    "partial use of stack-protector that was previously accepted and used in practice",
5982    @future_incompatible = FutureIncompatibleInfo {
5983        reason: fcw!(FutureReleaseError #154613),
5984        report_in_deps: false,
5985    };
5986    crate_level_only
5987}
5988
5989#[doc =
r" The `unevaluated_default_field_value` lint detects default field values that don't get"]
#[doc =
r" evaluated at the definition site because the corresponding struct or enum has type or const"]
#[doc =
r" parameters, meaning they only get evaluated when the struct or enum gets constructed using"]
#[doc = r" that default (post-monormophization)."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,no_run"]
#[doc = r" #![feature(default_field_values)]"]
#[doc = r""]
#[doc = r" struct Struct<const T: u8> {"]
#[doc =
r"     field1: u8 = 100 + T, // none of these values will be checked until `Struct` is"]
#[doc =
r"     field2: u8 = 100,     // constructed, even if they don't refer to the cont param"]
#[doc = r" }"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" Const evaluation requires all values to be known. In the case of default field values, they"]
#[doc =
r" will get evaluated eagerly, but if there are any type or const parameters, the evaluation of"]
#[doc =
r" the default will only occur when materializing a value of its owning struct *and* leaving"]
#[doc =
r" the field with a default value unspecified. For the example above, if you wrote"]
#[doc =
r" `let _: Struct<180> = Struct { .. };`, you would get a const evaluation compile error."]
#[doc = r""]
#[doc =
r" This inconsistency can be confusing, and surprising, because the fields *are* sometimes"]
#[doc = r" evaluated eagerly."]
pub static UNEVALUATED_DEFAULT_FIELD_VALUE: &crate::Lint =
    &crate::Lint {
            name: "UNEVALUATED_DEFAULT_FIELD_VALUE",
            default_level: crate::Warn,
            desc: r#"detects default field values on types that have const parameters"#,
            feature_gate: Some(rustc_span::sym::default_field_values),
            ..
        };declare_lint! {
5990    /// The `unevaluated_default_field_value` lint detects default field values that don't get
5991    /// evaluated at the definition site because the corresponding struct or enum has type or const
5992    /// parameters, meaning they only get evaluated when the struct or enum gets constructed using
5993    /// that default (post-monormophization).
5994    ///
5995    /// ### Example
5996    ///
5997    /// ```rust,no_run
5998    /// #![feature(default_field_values)]
5999    ///
6000    /// struct Struct<const T: u8> {
6001    ///     field1: u8 = 100 + T, // none of these values will be checked until `Struct` is
6002    ///     field2: u8 = 100,     // constructed, even if they don't refer to the cont param
6003    /// }
6004    /// ```
6005    ///
6006    /// {{produces}}
6007    ///
6008    /// ### Explanation
6009    ///
6010    /// Const evaluation requires all values to be known. In the case of default field values, they
6011    /// will get evaluated eagerly, but if there are any type or const parameters, the evaluation of
6012    /// the default will only occur when materializing a value of its owning struct *and* leaving
6013    /// the field with a default value unspecified. For the example above, if you wrote
6014    /// `let _: Struct<180> = Struct { .. };`, you would get a const evaluation compile error.
6015    ///
6016    /// This inconsistency can be confusing, and surprising, because the fields *are* sometimes
6017    /// evaluated eagerly.
6018    pub UNEVALUATED_DEFAULT_FIELD_VALUE,
6019    Warn,
6020    r#"detects default field values on types that have const parameters"#,
6021    @feature_gate = default_field_values;
6022}
6023
6024#[doc =
r" The `no_link_attributes` lint detects that you used `#[no_link]` on an"]
#[doc = r" `extern crate` item."]
#[doc = r""]
#[doc = r" ### Example"]
#[doc = r""]
#[doc = r" ```rust,compile_fail"]
#[doc = r" #[no_link]"]
#[doc = r" extern crate std;"]
#[doc = r" ```"]
#[doc = r""]
#[doc = r" {{produces}}"]
#[doc = r""]
#[doc = r" ### Explanation"]
#[doc = r""]
#[doc =
r" This is a pre-1.0 attribute that accidentally got stabilized. It was only meant"]
#[doc =
r" for compiler plugins which we no longer support, not for regular crates. It is"]
#[doc =
r" rather fragile and can easily lead to linker errors depending on where rustc"]
#[doc =
r" decides to codegen functions and statics, which varies between rustc versions. It"]
#[doc =
r" might also be unsound if a crate for example expects a global constructor it"]
#[doc =
r" defined to run. Using it doesn't have an effect on the size of the produced"]
#[doc =
r" binaries except when it defines a `#[used]` static given that we remove all unused"]
#[doc = r" functions and statics at link time already."]
pub static NO_LINK_ATTRIBUTES: &crate::Lint =
    &crate::Lint {
            name: "NO_LINK_ATTRIBUTES",
            default_level: crate::Deny,
            desc: "detects usage of `#[no_link]` on `extern crate` items",
            future_incompatible: Some(crate::FutureIncompatibleInfo {
                    reason: crate::FutureIncompatibilityReason::FutureReleaseError(crate::ReleaseFcw {
                            issue_number: 164032,
                        }),
                    report_in_deps: true,
                    ..
                }),
            ..
        };declare_lint! {
6025    /// The `no_link_attributes` lint detects that you used `#[no_link]` on an
6026    /// `extern crate` item.
6027    ///
6028    /// ### Example
6029    ///
6030    /// ```rust,compile_fail
6031    /// #[no_link]
6032    /// extern crate std;
6033    /// ```
6034    ///
6035    /// {{produces}}
6036    ///
6037    /// ### Explanation
6038    ///
6039    /// This is a pre-1.0 attribute that accidentally got stabilized. It was only meant
6040    /// for compiler plugins which we no longer support, not for regular crates. It is
6041    /// rather fragile and can easily lead to linker errors depending on where rustc
6042    /// decides to codegen functions and statics, which varies between rustc versions. It
6043    /// might also be unsound if a crate for example expects a global constructor it
6044    /// defined to run. Using it doesn't have an effect on the size of the produced
6045    /// binaries except when it defines a `#[used]` static given that we remove all unused
6046    /// functions and statics at link time already.
6047    pub NO_LINK_ATTRIBUTES,
6048    Deny,
6049    "detects usage of `#[no_link]` on `extern crate` items",
6050    @future_incompatible = FutureIncompatibleInfo {
6051        reason: fcw!(FutureReleaseError #164032),
6052        report_in_deps: true,
6053    };
6054}