Skip to main content

rustc_errors/
lib.rs

1//! Diagnostics creation and emission for `rustc`.
2//!
3//! This module contains the code for creating and emitting diagnostics.
4
5// tidy-alphabetical-start
6#![feature(default_field_values)]
7#![feature(macro_metavar_expr_concat)]
8#![feature(negative_impls)]
9// tidy-alphabetical-end
10
11extern crate self as rustc_errors;
12
13use std::backtrace::{Backtrace, BacktraceStatus};
14use std::borrow::Cow;
15use std::cell::Cell;
16use std::ffi::OsStr;
17use std::hash::Hash;
18use std::io::Write;
19use std::num::NonZero;
20use std::ops::DerefMut;
21use std::path::{Path, PathBuf};
22use std::thread::ThreadId;
23use std::{assert_matches, fmt, mem, panic};
24
25use Level::*;
26// Used by external projects such as `rust-gpu`.
27// See https://github.com/rust-lang/rust/pull/115393.
28pub use anstream::{AutoStream, ColorChoice};
29pub use anstyle::{
30    Ansi256Color, AnsiColor, Color, EffectIter, Effects, Reset, RgbColor, Style as Anstyle,
31};
32pub use codes::*;
33pub use decorate_diag::{BufferedEarlyLint, DecorateDiagCompat, LintBuffer};
34pub use diagnostic::{
35    Diag, DiagDecorator, DiagInner, DiagLocation, DiagStyledString, Diagnostic, StringPart,
36    Subdiag, Subdiagnostic,
37};
38pub use diagnostic_impls::{
39    DiagSymbolList, ElidedLifetimeInPathSubdiag, ExpectedLifetimeParameter,
40    IndicateAnonymousLifetime, SingleLabelManySpans,
41};
42pub use emitter::ColorConfig;
43use emitter::{DynEmitter, Emitter};
44use rustc_ast::attr::version::RustcVersion;
45use rustc_data_structures::AtomicRef;
46use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
47use rustc_data_structures::sync::{DynSend, Lock};
48pub use rustc_error_messages::{
49    DiagArg, DiagArgFromDisplay, DiagArgMap, DiagArgName, DiagArgValue, DiagMessage, IntoDiagArg,
50    LanguageIdentifier, MultiSpan, SpanLabel, fluent_bundle, into_diag_arg_using_display,
51};
52use rustc_hashes::Hash128;
53use rustc_lint_defs::LintExpectationId;
54pub use rustc_lint_defs::{Applicability, listify, pluralize};
55pub use rustc_macros::msg;
56use rustc_macros::{Decodable, Encodable};
57pub use rustc_span::ErrorGuaranteed;
58pub use rustc_span::fatal_error::{FatalError, FatalErrorMarker, catch_fatal_errors};
59pub use rustc_span::macros::ExplicitBug;
60use rustc_span::source_map::SourceMap;
61use rustc_span::{DUMMY_SP, Span};
62use tracing::debug;
63
64use crate::emitter::TimingEvent;
65use crate::formatting::DiagMessageAddArg;
66pub use crate::formatting::format_diag_message;
67use crate::timings::TimingRecord;
68
69pub mod annotate_snippet_emitter_writer;
70pub mod codes;
71mod decorate_diag;
72mod dedup_hash;
73mod diagnostic;
74mod diagnostic_impls;
75pub mod emitter;
76pub mod formatting;
77pub mod json;
78mod lock;
79pub mod markdown;
80pub mod timings;
81
82pub type PResult<'a, T> = Result<T, Diag<'a>>;
83
84// `PResult` is used a lot. Make sure it doesn't unintentionally get bigger.
85#[cfg(target_pointer_width = "64")]
86const _: [(); 24] = [(); ::std::mem::size_of::<PResult<'_, ()>>()];rustc_data_structures::static_assert_size!(PResult<'_, ()>, 24);
87#[cfg(target_pointer_width = "64")]
88const _: [(); 24] = [(); ::std::mem::size_of::<PResult<'_, bool>>()];rustc_data_structures::static_assert_size!(PResult<'_, bool>, 24);
89
90#[derive(#[automatically_derived]impl ::core::fmt::Debug for SuggestionStyle {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_c_like_enum_write_str(f,
            "HideCodeInline HideCodeAlways CompletelyHidden ShowCode ShowAlways",
            match self {
                SuggestionStyle::HideCodeInline => 0usize,
                SuggestionStyle::HideCodeAlways => 15usize,
                SuggestionStyle::CompletelyHidden => 30usize,
                SuggestionStyle::ShowCode => 47usize,
                SuggestionStyle::ShowAlways => 56usize,
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    SuggestionStyle {
}
#[automatically_derived]impl ::core::cmp::PartialEq for SuggestionStyle {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for SuggestionStyle { }Eq, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for SuggestionStyle {
}
#[automatically_derived]impl ::core::clone::Clone for SuggestionStyle {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for SuggestionStyle { }Copy, #[automatically_derived]impl ::core::hash::Hash for SuggestionStyle {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for SuggestionStyle {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        SuggestionStyle::HideCodeInline => { 0usize }
                        SuggestionStyle::HideCodeAlways => { 1usize }
                        SuggestionStyle::CompletelyHidden => { 2usize }
                        SuggestionStyle::ShowCode => { 3usize }
                        SuggestionStyle::ShowAlways => { 4usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for SuggestionStyle {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { SuggestionStyle::HideCodeInline }
                    1usize => { SuggestionStyle::HideCodeAlways }
                    2usize => { SuggestionStyle::CompletelyHidden }
                    3usize => { SuggestionStyle::ShowCode }
                    4usize => { SuggestionStyle::ShowAlways }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `SuggestionStyle`, expected 0..5, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable)]
91pub enum SuggestionStyle {
92    /// Hide the suggested code when displaying this suggestion inline.
93    HideCodeInline,
94    /// Always hide the suggested code but display the message.
95    HideCodeAlways,
96    /// Do not display this suggestion in the cli output, it is only meant for tools.
97    CompletelyHidden,
98    /// Always show the suggested code.
99    /// This will *not* show the code if the suggestion is inline *and* the suggested code is
100    /// empty.
101    ShowCode,
102    /// Always show the suggested code independently.
103    ShowAlways,
104}
105
106impl SuggestionStyle {
107    fn hide_inline(&self) -> bool {
108        !#[allow(non_exhaustive_omitted_patterns)] match *self {
    SuggestionStyle::ShowCode => true,
    _ => false,
}matches!(*self, SuggestionStyle::ShowCode)
109    }
110}
111
112/// Represents the help messages seen on a diagnostic.
113#[derive(#[automatically_derived]impl ::core::clone::Clone for Suggestions {
    #[inline]
    fn clone(&self) -> Self {
        match self {
            Self::Enabled(__self_0) =>
                Suggestions::Enabled(::core::clone::Clone::clone(__self_0)),
            Self::Sealed(__self_0) =>
                Suggestions::Sealed(::core::clone::Clone::clone(__self_0)),
            Self::Disabled => Suggestions::Disabled,
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for Suggestions {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::Enabled(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Enabled", &__self_0),
            Self::Sealed(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Sealed", &__self_0),
            Self::Disabled =>
                ::core::fmt::Formatter::write_str(f, "Disabled"),
        }
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    Suggestions {
}
#[automatically_derived]impl ::core::cmp::PartialEq for Suggestions {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Enabled(__self_0), Self::Enabled(__arg1_0)) =>
                    __self_0 == __arg1_0,
                (Self::Sealed(__self_0), Self::Sealed(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, #[automatically_derived]impl ::core::hash::Hash for Suggestions {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state);
        match self {
            Self::Enabled(__self_0) =>
                ::core::hash::Hash::hash(__self_0, state),
            Self::Sealed(__self_0) =>
                ::core::hash::Hash::hash(__self_0, state),
            _ => {}
        }
    }
}Hash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for Suggestions {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        Suggestions::Enabled(ref __binding_0) => { 0usize }
                        Suggestions::Sealed(ref __binding_0) => { 1usize }
                        Suggestions::Disabled => { 2usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    Suggestions::Enabled(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    Suggestions::Sealed(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    Suggestions::Disabled => {}
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for Suggestions {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        Suggestions::Enabled(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    1usize => {
                        Suggestions::Sealed(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    2usize => { Suggestions::Disabled }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `Suggestions`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable)]
114pub enum Suggestions {
115    /// Indicates that new suggestions can be added or removed from this diagnostic.
116    ///
117    /// `DiagInner`'s new_* methods initialize the `suggestions` field with
118    /// this variant. Also, this is the default variant for `Suggestions`.
119    Enabled(Vec<CodeSuggestion>),
120    /// Indicates that suggestions cannot be added or removed from this diagnostic.
121    ///
122    /// Gets toggled when `.seal_suggestions()` is called on the `DiagInner`.
123    Sealed(Box<[CodeSuggestion]>),
124    /// Indicates that no suggestion is available for this diagnostic.
125    ///
126    /// Gets toggled when `.disable_suggestions()` is called on the `DiagInner`.
127    Disabled,
128}
129
130impl Suggestions {
131    /// Returns the underlying list of suggestions.
132    pub fn unwrap_tag(self) -> Vec<CodeSuggestion> {
133        match self {
134            Suggestions::Enabled(suggestions) => suggestions,
135            Suggestions::Sealed(suggestions) => suggestions.into_vec(),
136            Suggestions::Disabled => Vec::new(),
137        }
138    }
139
140    pub fn len(&self) -> usize {
141        match self {
142            Suggestions::Enabled(suggestions) => suggestions.len(),
143            Suggestions::Sealed(suggestions) => suggestions.len(),
144            Suggestions::Disabled => 0,
145        }
146    }
147}
148
149impl Default for Suggestions {
150    fn default() -> Self {
151        Self::Enabled(::alloc::vec::Vec::new()vec![])
152    }
153}
154
155#[derive(#[automatically_derived]impl ::core::clone::Clone for CodeSuggestion {
    #[inline]
    fn clone(&self) -> Self {
        CodeSuggestion {
            substitutions: ::core::clone::Clone::clone(&self.substitutions),
            msg: ::core::clone::Clone::clone(&self.msg),
            style: ::core::clone::Clone::clone(&self.style),
            applicability: ::core::clone::Clone::clone(&self.applicability),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for CodeSuggestion {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field4_finish(f,
            "CodeSuggestion substitutions msg style applicability",
            &self.substitutions, &self.msg, &self.style, &&self.applicability)
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    CodeSuggestion {
}
#[automatically_derived]impl ::core::cmp::PartialEq for CodeSuggestion {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.substitutions == other.substitutions && self.msg == other.msg &&
                self.style == other.style &&
            self.applicability == other.applicability
    }
}PartialEq, #[automatically_derived]impl ::core::hash::Hash for CodeSuggestion {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&self.substitutions, state);
        ::core::hash::Hash::hash(&self.msg, state);
        ::core::hash::Hash::hash(&self.style, state);
        ::core::hash::Hash::hash(&self.applicability, state)
    }
}Hash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for CodeSuggestion {
            fn encode(&self, __encoder: &mut __E) {
                let CodeSuggestion {
                        substitutions: ref __binding_0,
                        msg: ref __binding_1,
                        style: ref __binding_2,
                        applicability: ref __binding_3 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_2,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_3,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for CodeSuggestion {
            fn decode(__decoder: &mut __D) -> Self {
                CodeSuggestion {
                    substitutions: ::rustc_serialize::Decodable::decode(__decoder),
                    msg: ::rustc_serialize::Decodable::decode(__decoder),
                    style: ::rustc_serialize::Decodable::decode(__decoder),
                    applicability: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable)]
156pub struct CodeSuggestion {
157    /// Each substitute can have multiple variants due to multiple
158    /// applicable suggestions
159    ///
160    /// `foo.bar` might be replaced with `a.b` or `x.y` by replacing
161    /// `foo` and `bar` on their own:
162    ///
163    /// ```ignore (illustrative)
164    /// vec![
165    ///     Substitution { parts: vec![(0..3, "a"), (4..7, "b")] },
166    ///     Substitution { parts: vec![(0..3, "x"), (4..7, "y")] },
167    /// ]
168    /// ```
169    ///
170    /// or by replacing the entire span:
171    ///
172    /// ```ignore (illustrative)
173    /// vec![
174    ///     Substitution { parts: vec![(0..7, "a.b")] },
175    ///     Substitution { parts: vec![(0..7, "x.y")] },
176    /// ]
177    /// ```
178    pub substitutions: Vec<Substitution>,
179    pub msg: DiagMessage,
180    /// Visual representation of this suggestion.
181    pub style: SuggestionStyle,
182    /// Whether or not the suggestion is approximate
183    ///
184    /// Sometimes we may show suggestions with placeholders,
185    /// which are useful for users but not useful for
186    /// tools like rustfix
187    pub applicability: Applicability,
188}
189
190#[derive(#[automatically_derived]impl ::core::clone::Clone for Substitution {
    #[inline]
    fn clone(&self) -> Self {
        Substitution { parts: ::core::clone::Clone::clone(&self.parts) }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for Substitution {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field1_finish(f,
            "Substitution parts", &&self.parts)
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    Substitution {
}
#[automatically_derived]impl ::core::cmp::PartialEq for Substitution {
    #[inline]
    fn eq(&self, other: &Self) -> bool { self.parts == other.parts }
}PartialEq, #[automatically_derived]impl ::core::hash::Hash for Substitution {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&self.parts, state)
    }
}Hash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for Substitution {
            fn encode(&self, __encoder: &mut __E) {
                let Substitution { parts: ref __binding_0 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for Substitution {
            fn decode(__decoder: &mut __D) -> Self {
                Substitution {
                    parts: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable)]
191/// See the docs on `CodeSuggestion::substitutions`
192pub struct Substitution {
193    pub parts: Vec<SubstitutionPart>,
194}
195
196#[derive(#[automatically_derived]impl ::core::clone::Clone for SubstitutionPart {
    #[inline]
    fn clone(&self) -> Self {
        SubstitutionPart {
            span: ::core::clone::Clone::clone(&self.span),
            snippet: ::core::clone::Clone::clone(&self.snippet),
        }
    }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for SubstitutionPart {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f,
            "SubstitutionPart span snippet", &self.span, &&self.snippet)
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    SubstitutionPart {
}
#[automatically_derived]impl ::core::cmp::PartialEq for SubstitutionPart {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.span == other.span && self.snippet == other.snippet
    }
}PartialEq, #[automatically_derived]impl ::core::hash::Hash for SubstitutionPart {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&self.span, state);
        ::core::hash::Hash::hash(&self.snippet, state)
    }
}Hash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for SubstitutionPart {
            fn encode(&self, __encoder: &mut __E) {
                let SubstitutionPart {
                        span: ref __binding_0, snippet: ref __binding_1 } = *self;
                ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                    __encoder);
                ::rustc_serialize::Encodable::<__E>::encode(__binding_1,
                    __encoder);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for SubstitutionPart {
            fn decode(__decoder: &mut __D) -> Self {
                SubstitutionPart {
                    span: ::rustc_serialize::Decodable::decode(__decoder),
                    snippet: ::rustc_serialize::Decodable::decode(__decoder),
                }
            }
        }
    };Decodable)]
197pub struct SubstitutionPart {
198    pub span: Span,
199    pub snippet: String,
200}
201
202/// Signifies that the compiler died due to a delayed bug rather than a failed
203/// assertion, etc.
204pub struct DelayedBugPanic;
205
206/// A `DiagCtxt` deals with errors and other compiler output.
207/// Certain errors (fatal, bug, unimpl) may cause immediate exit,
208/// others log errors for later reporting.
209///
210/// Note: methods should be implemented not on this type but on `DiagCtxtHandle` or
211/// `DiagCtxtInner`, whenever possible.
212pub struct DiagCtxt {
213    inner: Lock<DiagCtxtInner>,
214}
215
216#[derive(#[automatically_derived]impl<'a> ::core::marker::Copy for DiagCtxtHandle<'a> {
}Copy, #[automatically_derived]#[doc(hidden)]unsafe impl<'a>
    ::core::clone::TrivialClone for DiagCtxtHandle<'a> {
}
#[automatically_derived]impl<'a> ::core::clone::Clone for DiagCtxtHandle<'a> {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<&'a DiagCtxt>;
        let _:
                ::core::clone::AssertParamIsClone<Option<&'a Cell<Option<ErrorGuaranteed>>>>;
        *self
    }
}Clone)]
217pub struct DiagCtxtHandle<'a> {
218    dcx: &'a DiagCtxt,
219    /// Some contexts create `DiagCtxtHandle` with this field set, and thus all
220    /// errors emitted with it will automatically taint when emitting errors.
221    tainted_with_errors: Option<&'a Cell<Option<ErrorGuaranteed>>>,
222}
223
224/// This inner struct exists to keep it all behind a single lock;
225/// this is done to prevent possible deadlocks in a multi-threaded compiler,
226/// as well as inconsistent state observation.
227///
228/// Note: methods should be implemented not on this type but on `DiagCtxtHandle` whenever possible.
229/// Methods on this type should only be used e.g. when the lock is already held.
230struct DiagCtxtInner {
231    flags: DiagCtxtFlags,
232
233    /// The error guarantees from all emitted errors, each paired with the
234    /// thread that emitted it. The length gives the error count.
235    err_guars: Vec<(ErrorGuaranteed, ThreadId)>,
236    /// The error guarantee from all emitted lint errors, each paired with the
237    /// thread that emitted it. The length gives the lint error count.
238    lint_err_guars: Vec<(ErrorGuaranteed, ThreadId)>,
239    /// The delayed bugs and their error guarantees.
240    delayed_bugs: Vec<(DelayedDiagInner, ErrorGuaranteed)>,
241
242    /// The error count shown to the user at the end.
243    deduplicated_err_count: usize,
244    /// The warning count shown to the user at the end.
245    deduplicated_warn_count: usize,
246
247    emitter: Box<DynEmitter>,
248
249    /// Must we produce a diagnostic to justify the use of the expensive
250    /// `trimmed_def_paths` function? Backtrace is the location of the call.
251    must_produce_diag: Option<Backtrace>,
252
253    /// Has this diagnostic context printed any diagnostics? (I.e. has
254    /// `self.emitter.emit_diagnostic()` been called?
255    has_printed: bool,
256
257    /// This flag indicates that an expected diagnostic was emitted and suppressed.
258    /// This is used for the `must_produce_diag` check.
259    suppressed_expected_diag: bool,
260
261    /// This set contains the code of all emitted diagnostics to avoid
262    /// emitting the same diagnostic with extended help (`--teach`) twice, which
263    /// would be unnecessary repetition.
264    taught_diagnostics: FxHashSet<ErrCode>,
265
266    /// Used to suggest rustc --explain `<error code>`
267    emitted_diagnostic_codes: FxIndexSet<ErrCode>,
268
269    /// This set contains a hash of every diagnostic that has been emitted by
270    /// this `DiagCtxt`. These hashes are used to avoid emitting the same error
271    /// twice. (Because we don't store the diagnostics themselves, two
272    /// different diagnostics with the same hash value will be considered
273    /// equivalent. Such collisions should be vanishingly rare...)
274    emitted_diagnostics: FxHashSet<Hash128>,
275
276    /// We only want to emit `recursion_depth_exceeding_limit` once per
277    /// crate. Otherwise crates like `calimero-store` emit more than
278    /// a thousand warnings.
279    ///
280    /// We only check this in `TRACK_DIAGNOSTIC` meaning that the diagnostics
281    /// still get tracked by the query system, even if they don't get emitted
282    /// to users.
283    emitted_recursion_depth_exceeding_limit: bool,
284
285    /// Stashed diagnostics emitted in one stage of the compiler that may be
286    /// stolen and emitted/cancelled by other stages (e.g. to improve them and
287    /// add more information). All stashed diagnostics must be emitted with
288    /// `emit_stashed_diagnostics` by the time the `DiagCtxtInner` is dropped,
289    /// otherwise an assertion failure will occur.
290    stashed_diagnostics:
291        FxIndexMap<StashKey, FxIndexMap<Span, (DiagInner, Option<ErrorGuaranteed>, ThreadId)>>,
292
293    future_breakage_diagnostics: Vec<DiagInner>,
294
295    /// Any `expect` lint will carry the [`LintExpectationId`] of the expectation that can be
296    /// marked as fulfilled. This field is a collection of all [`LintExpectationId`]s
297    /// that have been marked as fulfilled this way.
298    ///
299    /// Emitting expectations after having stolen this field can happen. In particular, an
300    /// `#[expect(warnings)]` can easily make the `UNFULFILLED_LINT_EXPECTATIONS` lint expect
301    /// itself. To avoid needless complexity in this corner case, we tolerate failing to track
302    /// those expectations.
303    ///
304    /// [RFC-2383]: https://rust-lang.github.io/rfcs/2383-lint-reasons.html
305    fulfilled_expectations: FxIndexSet<LintExpectationId>,
306
307    /// The file where the ICE information is stored. This allows delayed_span_bug backtraces to be
308    /// stored along side the main panic backtrace.
309    ice_file: Option<PathBuf>,
310
311    /// Controlled by `-Z hint-msrv`; this allows avoiding emitting lints which would raise MSRV.
312    msrv: Option<RustcVersion>,
313}
314
315/// A key denoting where from a diagnostic was stashed.
316#[derive(#[automatically_derived]impl ::core::marker::Copy for StashKey { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for StashKey {
}
#[automatically_derived]impl ::core::clone::Clone for StashKey {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for StashKey
    {
}
#[automatically_derived]impl ::core::cmp::PartialEq for StashKey {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for StashKey { }Eq, #[automatically_derived]impl ::core::hash::Hash for StashKey {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash, #[automatically_derived]impl ::core::fmt::Debug for StashKey {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_c_like_enum_write_str(f,
            "ItemNoType EarlySyntaxWarning CallIntoMethod LifetimeIsChar MaybeFruTypo CallAssocMethod UndeterminedMacroResolution ExprInPat GenericInFieldExpr ReturnTypeNotation",
            match self {
                StashKey::ItemNoType => 0usize,
                StashKey::EarlySyntaxWarning => 11usize,
                StashKey::CallIntoMethod => 30usize,
                StashKey::LifetimeIsChar => 45usize,
                StashKey::MaybeFruTypo => 60usize,
                StashKey::CallAssocMethod => 73usize,
                StashKey::UndeterminedMacroResolution => 89usize,
                StashKey::ExprInPat => 117usize,
                StashKey::GenericInFieldExpr => 127usize,
                StashKey::ReturnTypeNotation => 146usize,
            })
    }
}Debug)]
317pub enum StashKey {
318    ItemNoType,
319    EarlySyntaxWarning,
320    CallIntoMethod,
321    /// When an invalid lifetime e.g. `'2` should be reinterpreted
322    /// as a char literal in the parser
323    LifetimeIsChar,
324    /// Maybe there was a typo where a comma was forgotten before
325    /// FRU syntax
326    MaybeFruTypo,
327    CallAssocMethod,
328    UndeterminedMacroResolution,
329    /// Used by `Parser::maybe_recover_trailing_expr`
330    ExprInPat,
331    /// If in the parser we detect a field expr with turbofish generic params it's possible that
332    /// it's a method call without parens. If later on in `hir_typeck` we find out that this is
333    /// the case we suppress this message and we give a better suggestion.
334    GenericInFieldExpr,
335    ReturnTypeNotation,
336}
337
338fn default_track_diagnostic<R>(diag: DiagInner, f: &mut dyn FnMut(DiagInner) -> R) -> R {
339    (*f)(diag)
340}
341
342/// Diagnostics emitted by `DiagCtxtInner::emit_diagnostic` are passed through this function. Used
343/// for tracking by incremental, to replay diagnostics as necessary.
344pub static TRACK_DIAGNOSTIC: AtomicRef<
345    fn(DiagInner, &mut dyn FnMut(DiagInner) -> Option<ErrorGuaranteed>) -> Option<ErrorGuaranteed>,
346> = AtomicRef::new(&(default_track_diagnostic as _));
347
348#[derive(#[automatically_derived]impl ::core::marker::Copy for DiagCtxtFlags { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for DiagCtxtFlags {
}
#[automatically_derived]impl ::core::clone::Clone for DiagCtxtFlags {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<bool>;
        let _: ::core::clone::AssertParamIsClone<Option<NonZero<usize>>>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::default::Default for DiagCtxtFlags {
    #[inline]
    fn default() -> Self {
        DiagCtxtFlags {
            can_emit_warnings: ::core::default::Default::default(),
            treat_err_as_bug: ::core::default::Default::default(),
            eagerly_emit_delayed_bugs: ::core::default::Default::default(),
            macro_backtrace: ::core::default::Default::default(),
            deduplicate_diagnostics: ::core::default::Default::default(),
            track_diagnostics: ::core::default::Default::default(),
        }
    }
}Default)]
349pub struct DiagCtxtFlags {
350    /// If false, warning-level lints are suppressed.
351    /// (rustc: see `--allow warnings` and `--cap-lints`)
352    pub can_emit_warnings: bool,
353    /// If Some, the Nth error-level diagnostic is upgraded to bug-level.
354    /// (rustc: see `-Z treat-err-as-bug`)
355    pub treat_err_as_bug: Option<NonZero<usize>>,
356    /// Eagerly emit delayed bugs as errors, so that the compiler debugger may
357    /// see all of the errors being emitted at once.
358    pub eagerly_emit_delayed_bugs: bool,
359    /// Show macro backtraces.
360    /// (rustc: see `-Z macro-backtrace`)
361    pub macro_backtrace: bool,
362    /// If true, identical diagnostics are reported only once.
363    pub deduplicate_diagnostics: bool,
364    /// Track where errors are created. Enabled with `-Ztrack-diagnostics`.
365    pub track_diagnostics: bool,
366}
367
368impl Drop for DiagCtxtInner {
369    fn drop(&mut self) {
370        // For tools using `interface::run_compiler` (e.g. rustc, rustdoc)
371        // stashed diagnostics will have already been emitted. But for others
372        // that don't use `interface::run_compiler` (e.g. rustfmt, some clippy
373        // lints) this fallback is necessary.
374        //
375        // Important: it is sound to produce an `ErrorGuaranteed` when stashing
376        // errors because they are guaranteed to be emitted here or earlier.
377        self.emit_stashed_diagnostics();
378
379        // Important: it is sound to produce an `ErrorGuaranteed` when emitting
380        // delayed bugs because they are guaranteed to be emitted here if
381        // necessary.
382        self.flush_delayed();
383
384        // Sanity check: did we use some of the expensive `trimmed_def_paths` functions
385        // unexpectedly, that is, without producing diagnostics? If so, for debugging purposes, we
386        // suggest where this happened and how to avoid it.
387        if !self.has_printed && !self.suppressed_expected_diag && !std::thread::panicking() {
388            if let Some(backtrace) = &self.must_produce_diag {
389                let suggestion = match backtrace.status() {
390                    BacktraceStatus::Disabled => String::from(
391                        "Backtraces are currently disabled: set `RUST_BACKTRACE=1` and re-run \
392                        to see where it happened.",
393                    ),
394                    BacktraceStatus::Captured => ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("This happened in the following `must_produce_diag` call\'s backtrace:\n{0}",
                backtrace))
    })format!(
395                        "This happened in the following `must_produce_diag` call's backtrace:\n\
396                        {backtrace}",
397                    ),
398                    _ => String::from("(impossible to capture backtrace where this happened)"),
399                };
400                {
    ::core::panicking::panic_fmt(format_args!("`trimmed_def_paths` called, diagnostics were expected but none were emitted. Use `with_no_trimmed_paths` for debugging. {0}",
            suggestion));
};panic!(
401                    "`trimmed_def_paths` called, diagnostics were expected but none were emitted. \
402                    Use `with_no_trimmed_paths` for debugging. {suggestion}"
403                );
404            }
405        }
406    }
407}
408
409impl DiagCtxt {
410    pub fn disable_warnings(mut self) -> Self {
411        self.inner.get_mut().flags.can_emit_warnings = false;
412        self
413    }
414
415    pub fn with_flags(mut self, flags: DiagCtxtFlags) -> Self {
416        self.inner.get_mut().flags = flags;
417        self
418    }
419
420    pub fn with_ice_file(mut self, ice_file: PathBuf) -> Self {
421        self.inner.get_mut().ice_file = Some(ice_file);
422        self
423    }
424
425    pub fn with_msrv(mut self, msrv: RustcVersion) -> Self {
426        self.inner.get_mut().msrv = Some(msrv);
427        self
428    }
429
430    pub fn new(emitter: Box<DynEmitter>) -> Self {
431        Self { inner: Lock::new(DiagCtxtInner::new(emitter)) }
432    }
433
434    pub fn handle<'a>(&'a self) -> DiagCtxtHandle<'a> {
435        DiagCtxtHandle { dcx: self, tainted_with_errors: None }
436    }
437}
438
439impl<'a> DiagCtxtHandle<'a> {
440    pub fn make_silent(&self) {
441        let mut inner = self.dcx.inner.borrow_mut();
442        inner.emitter = Box::new(emitter::SilentEmitter {});
443    }
444
445    pub fn set_emitter(&self, emitter: Box<dyn Emitter + DynSend>) {
446        self.dcx.inner.borrow_mut().emitter = emitter;
447    }
448
449    // This is here to not allow mutation of flags; as of this writing it's used in
450    // `emit_lint_base` and in tests in `rustc_interface`.
451    pub fn can_emit_warnings(&self) -> bool {
452        self.dcx.inner.borrow().flags.can_emit_warnings
453    }
454
455    /// Resets the diagnostic error count as well as the cached emitted diagnostics.
456    ///
457    /// NOTE: *do not* call this function from rustc. It is only meant to be called from external
458    /// tools that want to reuse a `Parser` cleaning the previously emitted diagnostics as well as
459    /// the overall count of emitted error diagnostics.
460    pub fn reset_err_count(&self) {
461        // Use destructuring so that if a field gets added to `DiagCtxtInner`, it's impossible to
462        // fail to update this method as well.
463        let mut inner = self.dcx.inner.borrow_mut();
464        let DiagCtxtInner {
465            flags: _,
466            err_guars,
467            lint_err_guars,
468            delayed_bugs,
469            deduplicated_err_count,
470            deduplicated_warn_count,
471            emitter: _,
472            must_produce_diag,
473            has_printed,
474            suppressed_expected_diag,
475            taught_diagnostics,
476            emitted_diagnostic_codes,
477            emitted_diagnostics,
478            emitted_recursion_depth_exceeding_limit,
479            stashed_diagnostics,
480            future_breakage_diagnostics,
481            fulfilled_expectations,
482            ice_file: _,
483            msrv: _,
484        } = inner.deref_mut();
485
486        // For the `Vec`s and `HashMap`s, we overwrite with an empty container to free the
487        // underlying memory (which `clear` would not do).
488        *err_guars = Default::default();
489        *lint_err_guars = Default::default();
490        *delayed_bugs = Default::default();
491        *deduplicated_err_count = 0;
492        *deduplicated_warn_count = 0;
493        *must_produce_diag = None;
494        *has_printed = false;
495        *suppressed_expected_diag = false;
496        *taught_diagnostics = Default::default();
497        *emitted_diagnostic_codes = Default::default();
498        *emitted_diagnostics = Default::default();
499        *emitted_recursion_depth_exceeding_limit = false;
500        *stashed_diagnostics = Default::default();
501        *future_breakage_diagnostics = Default::default();
502        *fulfilled_expectations = Default::default();
503    }
504
505    /// Link this to a taintable context so that emitting errors will automatically set
506    /// the `Option<ErrorGuaranteed>` instead of having to do that manually at every error
507    /// emission site.
508    pub fn into_taintable(
509        self,
510        tainted_with_errors: &'a Cell<Option<ErrorGuaranteed>>,
511    ) -> DiagCtxtHandle<'a> {
512        DiagCtxtHandle { dcx: self.dcx, tainted_with_errors: Some(tainted_with_errors) }
513    }
514
515    /// Stashes a diagnostic for possible later improvement in a different,
516    /// later stage of the compiler. Possible actions depend on the diagnostic
517    /// level:
518    /// - Level::Bug, Level:Fatal: not allowed, will trigger a panic.
519    /// - Level::Error: immediately counted as an error that has occurred, because it
520    ///   is guaranteed to be emitted eventually. Can be later accessed with the
521    ///   provided `span` and `key` through
522    ///   [`DiagCtxtHandle::try_steal_modify_and_emit_err`] or
523    ///   [`DiagCtxtHandle::try_steal_replace_and_emit_err`]. These do not allow
524    ///   cancellation or downgrading of the error. Returns
525    ///   `Some(ErrorGuaranteed)`.
526    /// - Level::DelayedBug: this does happen occasionally with errors that are
527    ///   downgraded to delayed bugs. It is not stashed, but immediately
528    ///   emitted as a delayed bug. This is because stashing it would cause it
529    ///   to be counted by `err_count` which we don't want. It doesn't matter
530    ///   that we cannot steal and improve it later, because it's not a
531    ///   user-facing error. Returns `Some(ErrorGuaranteed)` as is normal for
532    ///   delayed bugs.
533    /// - Level::Warning and lower (i.e. !is_error()): can be accessed with the
534    ///   provided `span` and `key` through [`DiagCtxtHandle::steal_non_err()`]. This
535    ///   allows cancelling and downgrading of the diagnostic. Returns `None`.
536    pub fn stash_diagnostic(
537        &self,
538        span: Span,
539        key: StashKey,
540        diag: DiagInner,
541    ) -> Option<ErrorGuaranteed> {
542        let guar = match diag.level {
543            Bug | Fatal => {
544                self.span_bug(
545                    span,
546                    ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("invalid level in `stash_diagnostic`: {0:?}",
                diag.level))
    })format!("invalid level in `stash_diagnostic`: {:?}", diag.level),
547                );
548            }
549            // We delay a bug here so that `-Ztreat-err-as-bug -Zeagerly-emit-delayed-bugs`
550            // can be used to create a backtrace at the stashing site instead of whenever the
551            // diagnostic context is dropped and thus delayed bugs are emitted.
552            Error => Some(self.span_delayed_bug(span, ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("stashing {0:?}", key))
    })format!("stashing {key:?}"))),
553            DelayedBug => {
554                return self.dcx.inner.borrow_mut().emit_diagnostic(diag, self.tainted_with_errors);
555            }
556            Warning(_) | Note | Help | FailureNote => None,
557        };
558
559        // FIXME(Centril, #69537): Consider reintroducing panic on overwriting a stashed diagnostic
560        // if/when we have a more robust macro-friendly replacement for `(span, key)` as a key.
561        // See the PR for a discussion.
562        self.dcx
563            .inner
564            .borrow_mut()
565            .stashed_diagnostics
566            .entry(key)
567            .or_default()
568            .insert(span.with_parent(None), (diag, guar, std::thread::current().id()));
569
570        guar
571    }
572
573    /// Steal a previously stashed non-error diagnostic with the given `Span`
574    /// and [`StashKey`] as the key. Panics if the found diagnostic is an
575    /// error.
576    pub fn steal_non_err(self, span: Span, key: StashKey) -> Option<Diag<'a>> {
577        // FIXME(#120456) - is `swap_remove` correct?
578        let (diag, guar, _) =
579            self.dcx.inner.borrow_mut().stashed_diagnostics.get_mut(&key).and_then(
580                |stashed_diagnostics| stashed_diagnostics.swap_remove(&span.with_parent(None)),
581            )?;
582        if !!diag.is_error() {
    ::core::panicking::panic("assertion failed: !diag.is_error()")
};assert!(!diag.is_error());
583        if !guar.is_none() {
    ::core::panicking::panic("assertion failed: guar.is_none()")
};assert!(guar.is_none());
584        Some(Diag::new_diagnostic(self, diag))
585    }
586
587    /// Steals a previously stashed error with the given `Span` and
588    /// [`StashKey`] as the key, modifies it, and emits it. Returns `None` if
589    /// no matching diagnostic is found. Panics if the found diagnostic's level
590    /// isn't `Level::Error`.
591    pub fn try_steal_modify_and_emit_err<F>(
592        self,
593        span: Span,
594        key: StashKey,
595        mut modify_err: F,
596    ) -> Option<ErrorGuaranteed>
597    where
598        F: FnMut(&mut Diag<'_>),
599    {
600        // FIXME(#120456) - is `swap_remove` correct?
601        let err = self.dcx.inner.borrow_mut().stashed_diagnostics.get_mut(&key).and_then(
602            |stashed_diagnostics| stashed_diagnostics.swap_remove(&span.with_parent(None)),
603        );
604        err.map(|(err, guar, _)| {
605            {
    match (&err.level, &Error) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(err.level, Error);
606            if !guar.is_some() {
    ::core::panicking::panic("assertion failed: guar.is_some()")
};assert!(guar.is_some());
607            let mut err = Diag::new_diagnostic(self, err);
608            modify_err(&mut err);
609            {
    match (&err.level, &Error) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(err.level, Error);
610            err.emit_err()
611        })
612    }
613
614    /// Steals a previously stashed error with the given `Span` and
615    /// [`StashKey`] as the key, cancels it if found, and emits `new_err`.
616    /// Panics if the found diagnostic's level isn't `Level::Error`.
617    pub fn try_steal_replace_and_emit_err(
618        self,
619        span: Span,
620        key: StashKey,
621        new_err: Diag<'_>,
622    ) -> ErrorGuaranteed {
623        // FIXME(#120456) - is `swap_remove` correct?
624        let old_err = self.dcx.inner.borrow_mut().stashed_diagnostics.get_mut(&key).and_then(
625            |stashed_diagnostics| stashed_diagnostics.swap_remove(&span.with_parent(None)),
626        );
627        match old_err {
628            Some((old_err, guar, _)) => {
629                {
    match (&old_err.level, &Error) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(old_err.level, Error);
630                if !guar.is_some() {
    ::core::panicking::panic("assertion failed: guar.is_some()")
};assert!(guar.is_some());
631                // Because `old_err` has already been counted, it can only be
632                // safely cancelled because the `new_err` supplants it.
633                Diag::new_diagnostic(self, old_err).cancel();
634            }
635            None => {}
636        };
637        new_err.emit_err()
638    }
639
640    pub fn has_stashed_diagnostic(&self, span: Span, key: StashKey) -> bool {
641        let inner = self.dcx.inner.borrow();
642        if let Some(stashed_diagnostics) = inner.stashed_diagnostics.get(&key)
643            && !stashed_diagnostics.is_empty()
644        {
645            stashed_diagnostics.contains_key(&span.with_parent(None))
646        } else {
647            false
648        }
649    }
650
651    /// Emit all stashed diagnostics.
652    pub fn emit_stashed_diagnostics(&self) -> Option<ErrorGuaranteed> {
653        self.dcx.inner.borrow_mut().emit_stashed_diagnostics()
654    }
655
656    /// This excludes delayed bugs.
657    #[inline]
658    pub fn err_count(&self) -> usize {
659        let inner = self.dcx.inner.borrow();
660        inner.err_guars.len()
661            + inner.lint_err_guars.len()
662            + inner
663                .stashed_diagnostics
664                .values()
665                .map(|a| a.values().filter(|(_, guar, _)| guar.is_some()).count())
666                .sum::<usize>()
667    }
668
669    /// The number of errors that have been emitted on the *current thread*.
670    ///
671    /// Like [`DiagCtxtHandle::err_count`], but only counts errors whose recorded
672    /// emitting thread is the calling thread.
673    pub fn err_count_on_current_thread(&self) -> usize {
674        let inner = self.dcx.inner.borrow();
675        let current = std::thread::current().id();
676        inner.err_guars.iter().filter(|(_, thread)| *thread == current).count()
677            + inner.lint_err_guars.iter().filter(|(_, thread)| *thread == current).count()
678            + inner
679                .stashed_diagnostics
680                .values()
681                .map(|a| {
682                    a.values()
683                        .filter(|(_, guar, thread)| guar.is_some() && *thread == current)
684                        .count()
685                })
686                .sum::<usize>()
687    }
688
689    /// This excludes lint errors and delayed bugs. Unless absolutely
690    /// necessary, prefer `has_errors` to this method.
691    pub fn has_errors_excluding_lint_errors(&self) -> Option<ErrorGuaranteed> {
692        self.dcx.inner.borrow().has_errors_excluding_lint_errors()
693    }
694
695    /// This excludes delayed bugs.
696    pub fn has_errors(&self) -> Option<ErrorGuaranteed> {
697        self.dcx.inner.borrow().has_errors()
698    }
699
700    /// This excludes nothing. Unless absolutely necessary, prefer `has_errors`
701    /// to this method.
702    pub fn has_errors_or_delayed_bugs(&self) -> Option<ErrorGuaranteed> {
703        self.dcx.inner.borrow().has_errors_or_delayed_bugs()
704    }
705
706    pub fn print_error_count(&self) {
707        let mut inner = self.dcx.inner.borrow_mut();
708
709        // Any stashed diagnostics should have been handled by
710        // `emit_stashed_diagnostics` by now.
711        if !inner.stashed_diagnostics.is_empty() {
    ::core::panicking::panic("assertion failed: inner.stashed_diagnostics.is_empty()")
};assert!(inner.stashed_diagnostics.is_empty());
712
713        if inner.treat_err_as_bug() {
714            return;
715        }
716
717        let warnings = match inner.deduplicated_warn_count {
718            0 => Cow::from(""),
719            1 => Cow::from("1 warning emitted"),
720            count => Cow::from(::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0} warnings emitted", count))
    })format!("{count} warnings emitted")),
721        };
722        let errors = match inner.deduplicated_err_count {
723            0 => Cow::from(""),
724            1 => Cow::from("aborting due to 1 previous error"),
725            count => Cow::from(::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("aborting due to {0} previous errors",
                count))
    })format!("aborting due to {count} previous errors")),
726        };
727
728        match (errors.len(), warnings.len()) {
729            (0, 0) => return,
730            (0, _) => {
731                // Force emission so this message always prints.
732                let diag = DiagInner::new(
733                    Warning(Some(EmissionOverride::Forced { lint_id: None })),
734                    DiagMessage::Str(warnings),
735                );
736                inner.emit_diagnostic(diag, None);
737            }
738            (_, 0) => {
739                inner.emit_diagnostic(DiagInner::new(Error, errors), self.tainted_with_errors);
740            }
741            (_, _) => {
742                inner.emit_diagnostic(
743                    DiagInner::new(Error, ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}; {1}", errors, warnings))
    })format!("{errors}; {warnings}")),
744                    self.tainted_with_errors,
745                );
746            }
747        }
748
749        let can_show_explain = inner.emitter.should_show_explain();
750        let are_there_diagnostics = !inner.emitted_diagnostic_codes.is_empty();
751        if can_show_explain && are_there_diagnostics {
752            let mut error_codes = inner
753                .emitted_diagnostic_codes
754                .iter()
755                .filter_map(|&code| {
756                    if crate::codes::try_find_description(code).is_ok() {
757                        Some(code.to_string())
758                    } else {
759                        None
760                    }
761                })
762                .collect::<Vec<_>>();
763            if !error_codes.is_empty() {
764                error_codes.sort();
765                if error_codes.len() > 1 {
766                    let limit = if error_codes.len() > 9 { 9 } else { error_codes.len() };
767                    let msg1 = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("Some errors have detailed explanations: {0}{1}",
                error_codes[..limit].join(", "),
                if error_codes.len() > 9 { "..." } else { "." }))
    })format!(
768                        "Some errors have detailed explanations: {}{}",
769                        error_codes[..limit].join(", "),
770                        if error_codes.len() > 9 { "..." } else { "." }
771                    );
772                    let msg2 = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("For more information about an error, try `rustc --explain {0}`.",
                &error_codes[0]))
    })format!(
773                        "For more information about an error, try `rustc --explain {}`.",
774                        &error_codes[0]
775                    );
776                    inner.emit_diagnostic(DiagInner::new(FailureNote, msg1), None);
777                    inner.emit_diagnostic(DiagInner::new(FailureNote, msg2), None);
778                } else {
779                    let msg = ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("For more information about this error, try `rustc --explain {0}`.",
                &error_codes[0]))
    })format!(
780                        "For more information about this error, try `rustc --explain {}`.",
781                        &error_codes[0]
782                    );
783                    inner.emit_diagnostic(DiagInner::new(FailureNote, msg), None);
784                }
785            }
786        }
787    }
788
789    /// This excludes delayed bugs. Used for early aborts after errors occurred
790    /// -- e.g. because continuing in the face of errors is likely to lead to
791    /// bad results, such as spurious/uninteresting additional errors -- when
792    /// returning an error `Result` is difficult.
793    pub fn abort_if_errors(&self) {
794        if let Some(guar) = self.has_errors() {
795            guar.raise_fatal();
796        }
797    }
798
799    /// `true` if we haven't taught a diagnostic with this code already.
800    /// The caller must then teach the user about such a diagnostic.
801    ///
802    /// Used to suppress emitting the same error multiple times with extended explanation when
803    /// calling `-Zteach`.
804    pub fn must_teach(&self, code: ErrCode) -> bool {
805        self.dcx.inner.borrow_mut().taught_diagnostics.insert(code)
806    }
807
808    pub fn emit_diagnostic(&self, diagnostic: DiagInner) -> Option<ErrorGuaranteed> {
809        self.dcx.inner.borrow_mut().emit_diagnostic(diagnostic, self.tainted_with_errors)
810    }
811
812    pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str) {
813        self.dcx.inner.borrow_mut().emitter.emit_artifact_notification(path, artifact_type);
814    }
815
816    pub fn emit_timing_section_start(&self, record: TimingRecord) {
817        self.dcx.inner.borrow_mut().emitter.emit_timing_section(record, TimingEvent::Start);
818    }
819
820    pub fn emit_timing_section_end(&self, record: TimingRecord) {
821        self.dcx.inner.borrow_mut().emitter.emit_timing_section(record, TimingEvent::End);
822    }
823
824    pub fn emit_future_breakage_report(&self) {
825        let inner = &mut *self.dcx.inner.borrow_mut();
826        let diags = mem::take(&mut inner.future_breakage_diagnostics);
827        if !diags.is_empty() {
828            inner.emitter.emit_future_breakage_report(diags);
829        }
830    }
831
832    pub fn emit_unused_externs(
833        &self,
834        lint_level: rustc_lint_defs::Level,
835        loud: bool,
836        unused_externs: &[&str],
837    ) {
838        let mut inner = self.dcx.inner.borrow_mut();
839
840        // This "error" is an odd duck.
841        // - It's only produce with JSON output.
842        // - It's not emitted the usual way, via `emit_diagnostic`.
843        // - The `$message_type` field is "unused_externs" rather than the usual
844        //   "diagnostic".
845        //
846        // We count it as a lint error because it has a lint level. The value
847        // of `loud` (which comes from "unused-externs" or
848        // "unused-externs-silent"), also affects whether it's treated like a
849        // hard error or not.
850        if loud && lint_level.is_error() {
851            // This `unchecked_error_guaranteed` is valid. It is where the
852            // `ErrorGuaranteed` for unused_extern errors originates.
853            #[allow(deprecated)]
854            let guar = ErrorGuaranteed::unchecked_error_guaranteed();
855            inner.lint_err_guars.push((guar, std::thread::current().id()));
856            inner.panic_if_treat_err_as_bug();
857        }
858
859        inner.emitter.emit_unused_externs(lint_level, unused_externs)
860    }
861
862    /// We need to make sure that submitted expectation ids are correctly fulfilled, suppressed,
863    /// and stored between compilation sessions. To avoid doing these steps manually, we create a
864    /// dummy diagnostic and emit it as usual, which will be suppressed and stored like a normal
865    /// expected lint diagnostic.
866    #[track_caller]
867    pub fn fulfill_expectation(self, expectation: impl Into<LintExpectationId>) {
868        let emission_override = Some(EmissionOverride::Expected { lint_id: expectation.into() });
869        let msg = "this is a dummy diagnostic, to submit and store an expectation";
870        Diag::new(self, Warning(emission_override), msg).emit()
871    }
872
873    /// This methods steals all [`LintExpectationId`]s that are stored inside
874    /// [`DiagCtxtInner`] and indicate that the linked expectation has been fulfilled.
875    #[must_use]
876    pub fn steal_fulfilled_expectation_ids(&self) -> FxIndexSet<LintExpectationId> {
877        mem::take(&mut self.dcx.inner.borrow_mut().fulfilled_expectations)
878    }
879
880    /// Trigger an ICE if there are any delayed bugs and no hard errors.
881    ///
882    /// This will panic if there are any stashed diagnostics. You can call
883    /// `emit_stashed_diagnostics` to emit those before calling `flush_delayed`.
884    pub fn flush_delayed(&self) {
885        self.dcx.inner.borrow_mut().flush_delayed();
886    }
887
888    /// Used when trimmed_def_paths is called and we must produce a diagnostic
889    /// to justify its cost.
890    #[track_caller]
891    pub fn set_must_produce_diag(&self) {
892        if !self.dcx.inner.borrow().must_produce_diag.is_none() {
    {
        ::core::panicking::panic_fmt(format_args!("should only need to collect a backtrace once"));
    }
};assert!(
893            self.dcx.inner.borrow().must_produce_diag.is_none(),
894            "should only need to collect a backtrace once"
895        );
896        self.dcx.inner.borrow_mut().must_produce_diag = Some(Backtrace::capture());
897    }
898}
899
900// This `impl` block contains only the public diagnostic creation/emission API.
901//
902// Functions beginning with `struct_`/`create_` create a diagnostic. Other
903// functions create and emit a diagnostic all in one go.
904impl<'a> DiagCtxtHandle<'a> {
905    #[track_caller]
906    pub fn struct_bug(self, msg: impl Into<Cow<'static, str>>) -> Diag<'a> {
907        Diag::new(self, Bug, msg.into())
908    }
909
910    #[track_caller]
911    pub fn bug(self, msg: impl Into<Cow<'static, str>>) -> ! {
912        self.struct_bug(msg).emit_bug()
913    }
914
915    #[track_caller]
916    pub fn struct_span_bug(
917        self,
918        span: impl Into<MultiSpan>,
919        msg: impl Into<Cow<'static, str>>,
920    ) -> Diag<'a> {
921        self.struct_bug(msg).with_span(span)
922    }
923
924    #[track_caller]
925    pub fn span_bug(self, span: impl Into<MultiSpan>, msg: impl Into<Cow<'static, str>>) -> ! {
926        self.struct_span_bug(span, msg.into()).emit_bug()
927    }
928
929    #[track_caller]
930    pub fn create_bug(self, bug: impl Diagnostic<'a>) -> Diag<'a> {
931        bug.into_diag(self, Bug)
932    }
933
934    #[track_caller]
935    pub fn emit_bug(self, bug: impl Diagnostic<'a>) -> ! {
936        self.create_bug(bug).emit_bug()
937    }
938
939    #[track_caller]
940    pub fn struct_fatal(self, msg: impl Into<DiagMessage>) -> Diag<'a> {
941        Diag::new(self, Fatal, msg)
942    }
943
944    #[track_caller]
945    pub fn fatal(self, msg: impl Into<DiagMessage>) -> ! {
946        self.struct_fatal(msg).emit_fatal()
947    }
948
949    #[track_caller]
950    pub fn struct_span_fatal(
951        self,
952        span: impl Into<MultiSpan>,
953        msg: impl Into<DiagMessage>,
954    ) -> Diag<'a> {
955        self.struct_fatal(msg).with_span(span)
956    }
957
958    #[track_caller]
959    pub fn span_fatal(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) -> ! {
960        self.struct_span_fatal(span, msg).emit_fatal()
961    }
962
963    #[track_caller]
964    pub fn create_fatal(self, fatal: impl Diagnostic<'a>) -> Diag<'a> {
965        fatal.into_diag(self, Fatal)
966    }
967
968    #[track_caller]
969    pub fn emit_fatal(self, fatal: impl Diagnostic<'a>) -> ! {
970        self.create_fatal(fatal).emit_fatal()
971    }
972
973    #[track_caller]
974    pub fn struct_err(self, msg: impl Into<DiagMessage>) -> Diag<'a> {
975        Diag::new(self, Error, msg)
976    }
977
978    #[track_caller]
979    pub fn err(self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed {
980        self.struct_err(msg).emit_err()
981    }
982
983    #[track_caller]
984    pub fn struct_span_err(
985        self,
986        span: impl Into<MultiSpan>,
987        msg: impl Into<DiagMessage>,
988    ) -> Diag<'a> {
989        self.struct_err(msg).with_span(span)
990    }
991
992    #[track_caller]
993    pub fn span_err(
994        self,
995        span: impl Into<MultiSpan>,
996        msg: impl Into<DiagMessage>,
997    ) -> ErrorGuaranteed {
998        self.struct_span_err(span, msg).emit_err()
999    }
1000
1001    #[track_caller]
1002    pub fn create_err(self, err: impl Diagnostic<'a>) -> Diag<'a> {
1003        err.into_diag(self, Error)
1004    }
1005
1006    #[track_caller]
1007    pub fn emit_err(self, err: impl Diagnostic<'a>) -> ErrorGuaranteed {
1008        self.create_err(err).emit_err()
1009    }
1010
1011    /// Ensures that an error is printed. See [`Level::DelayedBug`].
1012    #[track_caller]
1013    pub fn delayed_bug(self, msg: impl Into<Cow<'static, str>>) -> ErrorGuaranteed {
1014        Diag::new(self, DelayedBug, msg.into()).emit_err()
1015    }
1016
1017    /// Ensures that an error is printed. See [`Level::DelayedBug`].
1018    ///
1019    /// Note: this function used to be called `delay_span_bug`. It was renamed
1020    /// to match similar functions like `span_err`, `span_warn`, etc.
1021    #[track_caller]
1022    pub fn span_delayed_bug(
1023        self,
1024        sp: impl Into<MultiSpan>,
1025        msg: impl Into<Cow<'static, str>>,
1026    ) -> ErrorGuaranteed {
1027        Diag::new(self, DelayedBug, msg.into()).with_span(sp).emit_err()
1028    }
1029
1030    #[track_caller]
1031    pub fn struct_warn(self, msg: impl Into<DiagMessage>) -> Diag<'a> {
1032        Diag::new(self, Warning(None), msg)
1033    }
1034
1035    #[track_caller]
1036    pub fn warn(self, msg: impl Into<DiagMessage>) {
1037        self.struct_warn(msg).emit()
1038    }
1039
1040    #[track_caller]
1041    pub fn struct_span_warn(
1042        self,
1043        span: impl Into<MultiSpan>,
1044        msg: impl Into<DiagMessage>,
1045    ) -> Diag<'a> {
1046        self.struct_warn(msg).with_span(span)
1047    }
1048
1049    #[track_caller]
1050    pub fn span_warn(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
1051        self.struct_span_warn(span, msg).emit()
1052    }
1053
1054    #[track_caller]
1055    pub fn create_warn(self, warning: impl Diagnostic<'a>) -> Diag<'a> {
1056        warning.into_diag(self, Warning(None))
1057    }
1058
1059    #[track_caller]
1060    pub fn emit_warn(self, warning: impl Diagnostic<'a>) {
1061        self.create_warn(warning).emit()
1062    }
1063
1064    #[track_caller]
1065    pub fn struct_note(self, msg: impl Into<DiagMessage>) -> Diag<'a> {
1066        Diag::new(self, Note, msg)
1067    }
1068
1069    #[track_caller]
1070    pub fn note(&self, msg: impl Into<DiagMessage>) {
1071        self.struct_note(msg).emit()
1072    }
1073
1074    #[track_caller]
1075    pub fn struct_span_note(
1076        self,
1077        span: impl Into<MultiSpan>,
1078        msg: impl Into<DiagMessage>,
1079    ) -> Diag<'a> {
1080        self.struct_note(msg).with_span(span)
1081    }
1082
1083    #[track_caller]
1084    pub fn span_note(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
1085        self.struct_span_note(span, msg).emit()
1086    }
1087
1088    #[track_caller]
1089    pub fn create_note(self, note: impl Diagnostic<'a>) -> Diag<'a> {
1090        note.into_diag(self, Note)
1091    }
1092
1093    #[track_caller]
1094    pub fn emit_note(self, note: impl Diagnostic<'a>) {
1095        self.create_note(note).emit()
1096    }
1097}
1098
1099impl DiagCtxtInner {
1100    fn new(emitter: Box<DynEmitter>) -> Self {
1101        Self {
1102            flags: DiagCtxtFlags { can_emit_warnings: true, ..Default::default() },
1103            err_guars: Vec::new(),
1104            lint_err_guars: Vec::new(),
1105            delayed_bugs: Vec::new(),
1106            deduplicated_err_count: 0,
1107            deduplicated_warn_count: 0,
1108            emitter,
1109            must_produce_diag: None,
1110            has_printed: false,
1111            suppressed_expected_diag: false,
1112            taught_diagnostics: Default::default(),
1113            emitted_diagnostic_codes: Default::default(),
1114            emitted_diagnostics: Default::default(),
1115            emitted_recursion_depth_exceeding_limit: false,
1116            stashed_diagnostics: Default::default(),
1117            future_breakage_diagnostics: Vec::new(),
1118            fulfilled_expectations: Default::default(),
1119            ice_file: None,
1120            msrv: None,
1121        }
1122    }
1123
1124    /// Emit all stashed diagnostics.
1125    fn emit_stashed_diagnostics(&mut self) -> Option<ErrorGuaranteed> {
1126        let mut guar = None;
1127        let has_errors = !self.err_guars.is_empty();
1128        for (_, stashed_diagnostics) in mem::take(&mut self.stashed_diagnostics).into_iter() {
1129            for (_, (diag, _guar, _thread)) in stashed_diagnostics {
1130                // When there are errors, skip flushing of stashed unforced warnings, to avoid
1131                // warning overload. (They would have been stolen already if they were important.)
1132                if has_errors
1133                    && let Warning(emission_override) = diag.level
1134                    && !#[allow(non_exhaustive_omitted_patterns)] match emission_override {
    Some(EmissionOverride::Forced { .. }) => true,
    _ => false,
}matches!(emission_override, Some(EmissionOverride::Forced { .. }))
1135                {
1136                    continue;
1137                }
1138                guar = guar.or(self.emit_diagnostic(diag, None));
1139            }
1140        }
1141        guar
1142    }
1143
1144    // Return value is only `Some` if the level is `Error` or `DelayedBug`.
1145    fn emit_diagnostic(
1146        &mut self,
1147        mut diagnostic: DiagInner,
1148        taint: Option<&Cell<Option<ErrorGuaranteed>>>,
1149    ) -> Option<ErrorGuaranteed> {
1150        if diagnostic.has_future_breakage() {
1151            // About the `allow`/`expect` lint sub-cases of `Warning`: future breakages aren't
1152            // emitted for them, but they still need to be handled below so they'll trigger the
1153            // `must_produce_diag` check.
1154            {
    match diagnostic.level {
        Error | Warning(_) => {}
        ref left_val => {
            ::core::panicking::assert_matches_failed(left_val,
                "Error | Warning(_)", ::core::option::Option::None);
        }
    }
};assert_matches!(diagnostic.level, Error | Warning(_));
1155            self.future_breakage_diagnostics.push(diagnostic.clone());
1156        }
1157
1158        // We call TRACK_DIAGNOSTIC with an empty closure for the cases that
1159        // return early *and* have some kind of side-effect, except where
1160        // noted.
1161        match diagnostic.level {
1162            Bug => {}
1163            Fatal | Error => {
1164                if self.treat_next_err_as_bug() {
1165                    // `Fatal` and `Error` can be promoted to `Bug`.
1166                    diagnostic.level = Bug;
1167                }
1168            }
1169            DelayedBug => {
1170                // Note that because we check these conditions first,
1171                // `-Zeagerly-emit-delayed-bugs` and `-Ztreat-err-as-bug`
1172                // continue to work even after we've issued an error and
1173                // stopped recording new delayed bugs.
1174                if self.flags.eagerly_emit_delayed_bugs {
1175                    // `DelayedBug` can be promoted to `Error` or `Bug`.
1176                    if self.treat_next_err_as_bug() {
1177                        diagnostic.level = Bug;
1178                    } else {
1179                        diagnostic.level = Error;
1180                    }
1181                } else {
1182                    // If we have already emitted at least one error, we don't need
1183                    // to record the delayed bug, because it'll never be used.
1184                    return if let Some(guar) = self.has_errors() {
1185                        Some(guar)
1186                    } else {
1187                        // No `TRACK_DIAGNOSTIC` call is needed, because the
1188                        // incremental session is deleted if there is a delayed
1189                        // bug. This also saves us from cloning the diagnostic.
1190                        let backtrace = std::backtrace::Backtrace::capture();
1191                        // This `unchecked_error_guaranteed` is valid. It is where the
1192                        // `ErrorGuaranteed` for delayed bugs originates. See
1193                        // `DiagCtxtInner::drop`.
1194                        #[allow(deprecated)]
1195                        let guar = ErrorGuaranteed::unchecked_error_guaranteed();
1196                        self.delayed_bugs
1197                            .push((DelayedDiagInner::with_backtrace(diagnostic, backtrace), guar));
1198                        Some(guar)
1199                    };
1200                }
1201            }
1202            Warning(emission_override) => {
1203                match emission_override {
1204                    None => {
1205                        if !self.flags.can_emit_warnings {
1206                            // We are not emitting warnings.
1207                            if diagnostic.has_future_breakage() {
1208                                // The side-effect is at the top of this method.
1209                                TRACK_DIAGNOSTIC(diagnostic, &mut |_| None);
1210                            }
1211                            return None;
1212                        }
1213                    }
1214                    Some(EmissionOverride::Forced { lint_id: None }) => {}
1215                    Some(EmissionOverride::Forced { lint_id: Some(lint_id) }) => {
1216                        self.fulfilled_expectations.insert(lint_id);
1217                    }
1218                    Some(EmissionOverride::Allowed) => {
1219                        if !diagnostic.has_future_breakage() {
    ::core::panicking::panic("assertion failed: diagnostic.has_future_breakage()")
};assert!(diagnostic.has_future_breakage());
1220                        TRACK_DIAGNOSTIC(diagnostic, &mut |_| None);
1221                        self.suppressed_expected_diag = true;
1222                        return None;
1223                    }
1224                    Some(EmissionOverride::Expected { lint_id }) => {
1225                        self.fulfilled_expectations.insert(lint_id);
1226                        TRACK_DIAGNOSTIC(diagnostic, &mut |_| None);
1227                        self.suppressed_expected_diag = true;
1228                        return None;
1229                    }
1230                }
1231            }
1232            Note | Help | FailureNote => {}
1233        }
1234
1235        if let (Some(msrv), Some(diag_msrv)) = (self.msrv, diagnostic.rust_version())
1236            && diag_msrv > msrv
1237        {
1238            return None;
1239        }
1240
1241        TRACK_DIAGNOSTIC(diagnostic, &mut |mut diagnostic| {
1242            if let Some(code) = diagnostic.code {
1243                self.emitted_diagnostic_codes.insert(code);
1244            }
1245
1246            let already_emitted = !self.emitted_diagnostics.insert(diagnostic.dedup_hash());
1247
1248            let is_error = diagnostic.is_error();
1249            let is_lint = diagnostic.is_lint.is_some();
1250            // We only emit the first occurrence of `recursion_depth_exceeding_limit`.
1251            let silence_recursion_depth_exceeded_limit =
1252                diagnostic.is_lint.as_ref().is_some_and(|lint| {
1253                    lint.name.eq_ignore_ascii_case(
1254                        rustc_lint_defs::builtin::RECURSION_DEPTH_EXCEEDING_LIMIT.name,
1255                    ) && mem::replace(&mut self.emitted_recursion_depth_exceeding_limit, true)
1256                });
1257
1258            // Only emit the diagnostic if deduplication is disabled or we
1259            // haven't already emitted an equivalent diagnostic.
1260            if !silence_recursion_depth_exceeded_limit
1261                && !(self.flags.deduplicate_diagnostics && already_emitted)
1262            {
1263                {
    use ::tracing::__macro_support::Callsite as _;
    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
        {
            static META: ::tracing::Metadata<'static> =
                {
                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/63931fb6b6bc05c38a5111ed7b32fe7648d22b1c/compiler/rustc_errors/src/lib.rs:1263",
                        "rustc_errors", ::tracing::Level::DEBUG,
                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/63931fb6b6bc05c38a5111ed7b32fe7648d22b1c/compiler/rustc_errors/src/lib.rs"),
                        ::tracing_core::__macro_support::Option::Some(1263u32),
                        ::tracing_core::__macro_support::Option::Some("rustc_errors"),
                        ::tracing_core::field::FieldSet::new(&[{
                                            const NAME:
                                                ::tracing::__macro_support::FieldName<{
                                                    ::tracing::__macro_support::FieldName::len("diagnostic")
                                                }> =
                                                ::tracing::__macro_support::FieldName::new("diagnostic");
                                            NAME.as_str()
                                        }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                        ::tracing::metadata::Kind::EVENT)
                };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
    let enabled =
        ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() &&
            {
                let interest = __CALLSITE.interest();
                !interest.is_never() &&
                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                        interest)
            };
    if enabled {
        (|value_set: ::tracing::field::ValueSet|
                    {
                        let meta = __CALLSITE.metadata();
                        ::tracing::Event::dispatch(meta, &value_set);
                        ;
                    })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&diagnostic)
                                            as &dyn ::tracing::field::Value))])
            });
    } else { ; }
};debug!(?diagnostic);
1264                {
    use ::tracing::__macro_support::Callsite as _;
    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
        {
            static META: ::tracing::Metadata<'static> =
                {
                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/63931fb6b6bc05c38a5111ed7b32fe7648d22b1c/compiler/rustc_errors/src/lib.rs:1264",
                        "rustc_errors", ::tracing::Level::DEBUG,
                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/63931fb6b6bc05c38a5111ed7b32fe7648d22b1c/compiler/rustc_errors/src/lib.rs"),
                        ::tracing_core::__macro_support::Option::Some(1264u32),
                        ::tracing_core::__macro_support::Option::Some("rustc_errors"),
                        ::tracing_core::field::FieldSet::new(&[{
                                            const NAME:
                                                ::tracing::__macro_support::FieldName<{
                                                    ::tracing::__macro_support::FieldName::len("self.emitted_diagnostics")
                                                }> =
                                                ::tracing::__macro_support::FieldName::new("self.emitted_diagnostics");
                                            NAME.as_str()
                                        }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                        ::tracing::metadata::Kind::EVENT)
                };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
    let enabled =
        ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() &&
            {
                let interest = __CALLSITE.interest();
                !interest.is_never() &&
                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                        interest)
            };
    if enabled {
        (|value_set: ::tracing::field::ValueSet|
                    {
                        let meta = __CALLSITE.metadata();
                        ::tracing::Event::dispatch(meta, &value_set);
                        ;
                    })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&self.emitted_diagnostics)
                                            as &dyn ::tracing::field::Value))])
            });
    } else { ; }
};debug!(?self.emitted_diagnostics);
1265
1266                let show_sub = |sub: &Subdiag| {
1267                    {
    use ::tracing::__macro_support::Callsite as _;
    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
        {
            static META: ::tracing::Metadata<'static> =
                {
                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/63931fb6b6bc05c38a5111ed7b32fe7648d22b1c/compiler/rustc_errors/src/lib.rs:1267",
                        "rustc_errors", ::tracing::Level::DEBUG,
                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/63931fb6b6bc05c38a5111ed7b32fe7648d22b1c/compiler/rustc_errors/src/lib.rs"),
                        ::tracing_core::__macro_support::Option::Some(1267u32),
                        ::tracing_core::__macro_support::Option::Some("rustc_errors"),
                        ::tracing_core::field::FieldSet::new(&[{
                                            const NAME:
                                                ::tracing::__macro_support::FieldName<{
                                                    ::tracing::__macro_support::FieldName::len("sub")
                                                }> =
                                                ::tracing::__macro_support::FieldName::new("sub");
                                            NAME.as_str()
                                        }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                        ::tracing::metadata::Kind::EVENT)
                };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
    let enabled =
        ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() &&
            {
                let interest = __CALLSITE.interest();
                !interest.is_never() &&
                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                        interest)
            };
    if enabled {
        (|value_set: ::tracing::field::ValueSet|
                    {
                        let meta = __CALLSITE.metadata();
                        ::tracing::Event::dispatch(meta, &value_set);
                        ;
                    })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&sub)
                                            as &dyn ::tracing::field::Value))])
            });
    } else { ; }
};debug!(?sub);
1268                    match sub.level {
1269                        Sublevel::Error | Sublevel::Warning | Sublevel::Note | Sublevel::Help => {
1270                            true
1271                        }
1272                        Sublevel::OnceNote | Sublevel::OnceHelp => {
1273                            self.emitted_diagnostics.insert(sub.dedup_hash())
1274                        }
1275                    }
1276                };
1277                diagnostic.children.retain(show_sub);
1278                if already_emitted {
1279                    let msg = "duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`";
1280                    diagnostic.sub(Sublevel::Note, msg, MultiSpan::new());
1281                }
1282
1283                if is_error {
1284                    self.deduplicated_err_count += 1;
1285                } else if #[allow(non_exhaustive_omitted_patterns)] match diagnostic.level {
    Warning(_) => true,
    _ => false,
}matches!(diagnostic.level, Warning(_)) {
1286                    self.deduplicated_warn_count += 1;
1287                }
1288                self.has_printed = true;
1289
1290                self.emitter.emit_diagnostic(diagnostic);
1291            }
1292
1293            if is_error {
1294                // If we have any delayed bugs recorded, we can discard them
1295                // because they won't be used. (This should only occur if there
1296                // have been no errors previously emitted, because we don't add
1297                // new delayed bugs once the first error is emitted.)
1298                if !self.delayed_bugs.is_empty() {
1299                    {
    match (&(self.lint_err_guars.len() + self.err_guars.len()), &0) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(self.lint_err_guars.len() + self.err_guars.len(), 0);
1300                    self.delayed_bugs.clear();
1301                    self.delayed_bugs.shrink_to_fit();
1302                }
1303
1304                // This `unchecked_error_guaranteed` is valid. It is where the
1305                // `ErrorGuaranteed` for errors and lint errors originates.
1306                #[allow(deprecated)]
1307                let guar = ErrorGuaranteed::unchecked_error_guaranteed();
1308                let thread = std::thread::current().id();
1309                if is_lint {
1310                    self.lint_err_guars.push((guar, thread));
1311                } else {
1312                    if let Some(taint) = taint {
1313                        taint.set(Some(guar));
1314                    }
1315                    self.err_guars.push((guar, thread));
1316                }
1317                self.panic_if_treat_err_as_bug();
1318                Some(guar)
1319            } else {
1320                None
1321            }
1322        })
1323    }
1324
1325    fn treat_err_as_bug(&self) -> bool {
1326        self.flags
1327            .treat_err_as_bug
1328            .is_some_and(|c| self.err_guars.len() + self.lint_err_guars.len() >= c.get())
1329    }
1330
1331    // Use this one before incrementing `err_count`.
1332    fn treat_next_err_as_bug(&self) -> bool {
1333        self.flags
1334            .treat_err_as_bug
1335            .is_some_and(|c| self.err_guars.len() + self.lint_err_guars.len() + 1 >= c.get())
1336    }
1337
1338    fn has_errors_excluding_lint_errors(&self) -> Option<ErrorGuaranteed> {
1339        self.err_guars.get(0).map(|(guar, _)| *guar).or_else(|| {
1340            if let Some((_diag, guar, _)) = self
1341                .stashed_diagnostics
1342                .values()
1343                .flat_map(|stashed_diagnostics| stashed_diagnostics.values())
1344                .find(|(diag, guar, _)| guar.is_some() && diag.is_lint.is_none())
1345            {
1346                *guar
1347            } else {
1348                None
1349            }
1350        })
1351    }
1352
1353    fn has_errors(&self) -> Option<ErrorGuaranteed> {
1354        self.err_guars
1355            .get(0)
1356            .map(|(guar, _)| *guar)
1357            .or_else(|| self.lint_err_guars.get(0).map(|(guar, _)| *guar))
1358            .or_else(|| {
1359                self.stashed_diagnostics.values().find_map(|stashed_diagnostics| {
1360                    stashed_diagnostics.values().find_map(|(_, guar, _)| *guar)
1361                })
1362            })
1363    }
1364
1365    fn has_errors_or_delayed_bugs(&self) -> Option<ErrorGuaranteed> {
1366        self.has_errors().or_else(|| self.delayed_bugs.get(0).map(|(_, guar)| guar).copied())
1367    }
1368
1369    fn flush_delayed(&mut self) {
1370        // Stashed diagnostics must be emitted before delayed bugs are flushed.
1371        // Otherwise, we might ICE prematurely when errors would have
1372        // eventually happened.
1373        if !self.stashed_diagnostics.is_empty() {
    ::core::panicking::panic("assertion failed: self.stashed_diagnostics.is_empty()")
};assert!(self.stashed_diagnostics.is_empty());
1374
1375        if !self.err_guars.is_empty() {
1376            // If an error happened already. We shouldn't expose delayed bugs.
1377            return;
1378        }
1379
1380        if self.delayed_bugs.is_empty() {
1381            // Nothing to do.
1382            return;
1383        }
1384
1385        let bugs: Vec<_> = mem::take(&mut self.delayed_bugs).into_iter().map(|(b, _)| b).collect();
1386
1387        let backtrace = std::env::var_os("RUST_BACKTRACE").as_deref() != Some(OsStr::new("0"));
1388        let decorate = backtrace || self.ice_file.is_none();
1389        let mut out = self
1390            .ice_file
1391            .as_ref()
1392            .and_then(|file| std::fs::File::options().create(true).append(true).open(file).ok());
1393
1394        // Put the overall explanation before the `DelayedBug`s, to frame them
1395        // better (e.g. separate warnings from them). Also, use notes, which
1396        // don't count as errors, to avoid possibly triggering
1397        // `-Ztreat-err-as-bug`, which we don't want.
1398        let note1 = "no errors encountered even though delayed bugs were created";
1399        let note2 = "those delayed bugs will now be shown as internal compiler errors";
1400        self.emit_diagnostic(DiagInner::new(Note, note1), None);
1401        self.emit_diagnostic(DiagInner::new(Note, note2), None);
1402
1403        for bug in bugs {
1404            if let Some(out) = &mut out {
1405                _ = out.write_fmt(format_args!("delayed bug: {0}\n{1}\n",
        bug.inner.messages.iter().filter_map(|(msg, _)|
                    msg.as_str()).collect::<String>(), &bug.note))write!(
1406                    out,
1407                    "delayed bug: {}\n{}\n",
1408                    bug.inner
1409                        .messages
1410                        .iter()
1411                        .filter_map(|(msg, _)| msg.as_str())
1412                        .collect::<String>(),
1413                    &bug.note
1414                );
1415            }
1416
1417            let mut bug = if decorate { bug.decorate() } else { bug.inner };
1418
1419            // "Undelay" the delayed bugs into plain bugs.
1420            if bug.level != DelayedBug {
1421                // NOTE(eddyb) not panicking here because we're already producing
1422                // an ICE, and the more information the merrier.
1423                //
1424                // We are at the `DiagInner`/`DiagCtxtInner` level rather than
1425                // the usual `Diag`/`DiagCtxt` level, so we must augment `bug`
1426                // in a lower-level fashion.
1427                let msg = rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed("`flushed_delayed` got diagnostic with level {$level}, instead of the expected `DelayedBug`"))msg!(
1428                    "`flushed_delayed` got diagnostic with level {$level}, instead of the expected `DelayedBug`"
1429                ).arg("level", bug.level).format();
1430                bug.sub(Sublevel::Note, msg, bug.span.primary_span().unwrap().into());
1431            }
1432            bug.level = Bug;
1433
1434            self.emit_diagnostic(bug, None);
1435        }
1436
1437        // Panic with `DelayedBugPanic` to avoid "unexpected panic" messages.
1438        panic::panic_any(DelayedBugPanic);
1439    }
1440
1441    fn panic_if_treat_err_as_bug(&self) {
1442        if self.treat_err_as_bug() {
1443            let n = self.flags.treat_err_as_bug.map(|c| c.get()).unwrap();
1444            {
    match (&n, &(self.err_guars.len() + self.lint_err_guars.len())) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(kind, &*left_val,
                    &*right_val, ::core::option::Option::None);
            }
        }
    }
};assert_eq!(n, self.err_guars.len() + self.lint_err_guars.len());
1445            if n == 1 {
1446                {
    ::core::panicking::panic_fmt(format_args!("aborting due to `-Z treat-err-as-bug=1`"));
};panic!("aborting due to `-Z treat-err-as-bug=1`");
1447            } else {
1448                {
    ::core::panicking::panic_fmt(format_args!("aborting after {0} errors due to `-Z treat-err-as-bug={0}`",
            n));
};panic!("aborting after {n} errors due to `-Z treat-err-as-bug={n}`");
1449            }
1450        }
1451    }
1452}
1453
1454struct DelayedDiagInner {
1455    inner: DiagInner,
1456    note: Backtrace,
1457}
1458
1459impl DelayedDiagInner {
1460    fn with_backtrace(diagnostic: DiagInner, backtrace: Backtrace) -> Self {
1461        DelayedDiagInner { inner: diagnostic, note: backtrace }
1462    }
1463
1464    fn decorate(self) -> DiagInner {
1465        // We are at the `DiagInner`/`DiagCtxtInner` level rather than the
1466        // usual `Diag`/`DiagCtxt` level, so we must construct `diag` in a
1467        // lower-level fashion.
1468        let mut diag = self.inner;
1469        let msg = match self.note.status() {
1470            BacktraceStatus::Captured => rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed("delayed at {$emitted_at}\n                {$note}"))msg!(
1471                "delayed at {$emitted_at}
1472                {$note}"
1473            ),
1474            // Avoid the needless newline when no backtrace has been captured,
1475            // the display impl should just be a single line.
1476            _ => rustc_errors::DiagMessage::Inline(std::borrow::Cow::Borrowed("delayed at {$emitted_at} - {$note}"))msg!("delayed at {$emitted_at} - {$note}"),
1477        }
1478        .arg("emitted_at", diag.emitted_at.clone())
1479        .arg("note", self.note)
1480        .format();
1481        diag.sub(Sublevel::Note, msg, diag.span.primary_span().unwrap_or(DUMMY_SP).into());
1482        diag
1483    }
1484}
1485
1486/// Special emission behaviours on warning diagnostics. Combines with `DiagInner::is_lint` in the
1487/// following ways.
1488///
1489/// | case                              | is_lint | `Option<EmissionOverride>` field in `Warning`
1490/// | ----                              | ------- | ---------------------------------------------
1491/// | ordinary non-lint diagnostic      | None    | None
1492/// | warning-count summary             | None    | Some(Forced { lint_id: None })
1493/// | N/A                               | None    | Some(Forced { lint_id: Some(lint_id) })
1494/// | dummy expectation fulfillment     | None    | Some(Expected { lint_id })
1495/// | N/A                               | None    | Some(Allowed)
1496/// | ordinary `warn` lint              | Some    | None
1497/// | `warn` lint at `force-warn`       | Some    | Some(Forced { lint_id: None })
1498/// | `expect` lint at `force-warn`     | Some    | Some(Forced { lint_id: Some(lint_id) })
1499/// | `expect` lint                     | Some    | Some(Expected { lint_id })
1500/// | `allow` lint with future breakage | Some    | Some(Allowed)
1501///
1502#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for EmissionOverride {
}
#[automatically_derived]impl ::core::clone::Clone for EmissionOverride {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<Option<LintExpectationId>>;
        let _: ::core::clone::AssertParamIsClone<LintExpectationId>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::marker::Copy for EmissionOverride { }Copy, #[automatically_derived]impl ::core::fmt::Debug for EmissionOverride {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::Forced { lint_id: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Forced lint_id", &__self_0),
            Self::Allowed => ::core::fmt::Formatter::write_str(f, "Allowed"),
            Self::Expected { lint_id: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Expected lint_id", &__self_0),
        }
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    EmissionOverride {
}
#[automatically_derived]impl ::core::cmp::PartialEq for EmissionOverride {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Forced { lint_id: __self_0 }, Self::Forced {
                    lint_id: __arg1_0 }) => __self_0 == __arg1_0,
                (Self::Expected { lint_id: __self_0 }, Self::Expected {
                    lint_id: __arg1_0 }) => __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for EmissionOverride {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<Option<LintExpectationId>>;
        let _: ::core::cmp::AssertParamIsEq<LintExpectationId>;
    }
}Eq, #[automatically_derived]impl ::core::hash::Hash for EmissionOverride {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state);
        match self {
            Self::Forced { lint_id: __self_0 } =>
                ::core::hash::Hash::hash(__self_0, state),
            Self::Expected { lint_id: __self_0 } =>
                ::core::hash::Hash::hash(__self_0, state),
            _ => {}
        }
    }
}Hash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for EmissionOverride {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        EmissionOverride::Forced { lint_id: ref __binding_0 } => {
                            0usize
                        }
                        EmissionOverride::Allowed => { 1usize }
                        EmissionOverride::Expected { lint_id: ref __binding_0 } => {
                            2usize
                        }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    EmissionOverride::Forced { lint_id: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    EmissionOverride::Allowed => {}
                    EmissionOverride::Expected { lint_id: ref __binding_0 } => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for EmissionOverride {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => {
                        EmissionOverride::Forced {
                            lint_id: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    1usize => { EmissionOverride::Allowed }
                    2usize => {
                        EmissionOverride::Expected {
                            lint_id: ::rustc_serialize::Decodable::decode(__decoder),
                        }
                    }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `EmissionOverride`, expected 0..3, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable)]
1503pub enum EmissionOverride {
1504    /// Cases where emission is forced.
1505    Forced { lint_id: Option<LintExpectationId> },
1506
1507    /// Used for `allow` lints with future breakage. (Allow lints without future breakage are
1508    /// ignored and therefore never need an `EmissionOverride` value.)
1509    Allowed,
1510
1511    /// Used for `expect` lints.
1512    Expected { lint_id: LintExpectationId },
1513}
1514
1515/// | Level        | is_error | usable emit fns  | Top-level | Used in lints?
1516/// | -----        | -------- | ---------------  | --------- | --------------
1517/// | Bug          | yes      | emit, emit_bug   | yes       | -
1518/// | Fatal        | yes      | emit, emit_fatal | yes       | -
1519/// | Error        | yes      | emit, emit_err   | yes       | yes
1520/// | DelayedBug   | yes      | emit, emit_err   | yes       | -
1521/// | Warning      | -        | emit             | yes       | yes
1522/// | Note         | -        | emit             | rare      | -
1523/// | Help         | -        | emit             | don't use | -
1524/// | FailureNote  | -        | emit             | rare      | -
1525///
1526#[derive(#[automatically_derived]impl ::core::marker::Copy for Level { }Copy, #[automatically_derived]impl ::core::marker::StructuralPartialEq for Level { }
#[automatically_derived]impl ::core::cmp::PartialEq for Level {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
                ::core::intrinsics::discriminant_value(other) &&
            match (self, other) {
                (Self::Warning(__self_0), Self::Warning(__arg1_0)) =>
                    __self_0 == __arg1_0,
                _ => true,
            }
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for Level {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_fields_are_eq(&self) {
        let _: ::core::cmp::AssertParamIsEq<Option<EmissionOverride>>;
    }
}Eq, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for Level {
}
#[automatically_derived]impl ::core::clone::Clone for Level {
    #[inline]
    fn clone(&self) -> Self {
        let _: ::core::clone::AssertParamIsClone<Option<EmissionOverride>>;
        *self
    }
}Clone, #[automatically_derived]impl ::core::hash::Hash for Level {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state);
        match self {
            Self::Warning(__self_0) =>
                ::core::hash::Hash::hash(__self_0, state),
            _ => {}
        }
    }
}Hash, #[automatically_derived]impl ::core::fmt::Debug for Level {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Self::Bug => ::core::fmt::Formatter::write_str(f, "Bug"),
            Self::Fatal => ::core::fmt::Formatter::write_str(f, "Fatal"),
            Self::Error => ::core::fmt::Formatter::write_str(f, "Error"),
            Self::DelayedBug =>
                ::core::fmt::Formatter::write_str(f, "DelayedBug"),
            Self::Warning(__self_0) =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Warning", &__self_0),
            Self::Note => ::core::fmt::Formatter::write_str(f, "Note"),
            Self::Help => ::core::fmt::Formatter::write_str(f, "Help"),
            Self::FailureNote =>
                ::core::fmt::Formatter::write_str(f, "FailureNote"),
        }
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for Level {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        Level::Bug => { 0usize }
                        Level::Fatal => { 1usize }
                        Level::Error => { 2usize }
                        Level::DelayedBug => { 3usize }
                        Level::Warning(ref __binding_0) => { 4usize }
                        Level::Note => { 5usize }
                        Level::Help => { 6usize }
                        Level::FailureNote => { 7usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
                match *self {
                    Level::Bug => {}
                    Level::Fatal => {}
                    Level::Error => {}
                    Level::DelayedBug => {}
                    Level::Warning(ref __binding_0) => {
                        ::rustc_serialize::Encodable::<__E>::encode(__binding_0,
                            __encoder);
                    }
                    Level::Note => {}
                    Level::Help => {}
                    Level::FailureNote => {}
                }
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for Level {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { Level::Bug }
                    1usize => { Level::Fatal }
                    2usize => { Level::Error }
                    3usize => { Level::DelayedBug }
                    4usize => {
                        Level::Warning(::rustc_serialize::Decodable::decode(__decoder))
                    }
                    5usize => { Level::Note }
                    6usize => { Level::Help }
                    7usize => { Level::FailureNote }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `Level`, expected 0..8, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable)]
1527pub enum Level {
1528    /// For bugs in the compiler. Manifests as an ICE (internal compiler error) panic.
1529    Bug,
1530
1531    /// An error that causes an immediate abort. Used for things like configuration errors,
1532    /// internal overflows, some file operation errors.
1533    Fatal,
1534
1535    /// An error in the code being compiled, which prevents compilation from finishing. This is the
1536    /// most common case.
1537    Error,
1538
1539    /// This is a strange one: lets you register an error without emitting it. If compilation ends
1540    /// without any other errors occurring, this will be emitted as a bug. Otherwise, it will be
1541    /// silently dropped. I.e. "expect other errors are emitted" semantics. Useful on code paths
1542    /// that should only be reached when compiling erroneous code.
1543    DelayedBug,
1544
1545    /// A warning about the code being compiled. Does not prevent compilation from finishing.
1546    /// Might not be emitted, depending on the value of `EmissionOverride` and `can_emit_warnings`.
1547    Warning(Option<EmissionOverride>),
1548
1549    /// A rarely-used level for output that isn't an error or a warning.
1550    Note,
1551
1552    /// A message suggesting how to fix something.
1553    ///
1554    /// FIXME(nnethercote) Do not use this! Currently only exists to support `proc_macro::Help`,
1555    /// part of the unstable `proc_macro_diagnostic` feature (see #54140). Should be removed
1556    /// because help messages are fine as subdiagnostics but are silly as top-level diagnostics.
1557    Help,
1558
1559    /// Similar to `Note`, but even rarer. Lacks the a trailing blank line that all other
1560    /// diagnostics have. Also, when printed for human consumption it doesn't have a `note:` label.
1561    FailureNote,
1562}
1563
1564impl fmt::Display for Level {
1565    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1566        self.to_str().fmt(f)
1567    }
1568}
1569
1570impl Level {
1571    pub fn to_str(self) -> &'static str {
1572        match self {
1573            Bug | DelayedBug => "error: internal compiler error",
1574            Fatal | Error => "error",
1575            Warning(_) => "warning",
1576            Note => "note",
1577            Help => "help",
1578            FailureNote => "failure-note",
1579        }
1580    }
1581
1582    pub fn is_failure_note(self) -> bool {
1583        #[allow(non_exhaustive_omitted_patterns)] match self {
    FailureNote => true,
    _ => false,
}matches!(self, FailureNote)
1584    }
1585}
1586
1587impl IntoDiagArg for Level {
1588    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
1589        DiagArgValue::Str(Cow::from(self.to_string()))
1590    }
1591}
1592
1593/// The level for a subdiagnostic.
1594#[derive(#[automatically_derived]impl ::core::marker::Copy for Sublevel { }Copy, #[automatically_derived]impl ::core::marker::StructuralPartialEq for Sublevel
    {
}
#[automatically_derived]impl ::core::cmp::PartialEq for Sublevel {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for Sublevel { }Eq, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for Sublevel {
}
#[automatically_derived]impl ::core::clone::Clone for Sublevel {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::hash::Hash for Sublevel {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash, #[automatically_derived]impl ::core::fmt::Debug for Sublevel {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_c_like_enum_write_str(f,
            "Error Warning Note OnceNote Help OnceHelp",
            match self {
                Sublevel::Error => 0usize,
                Sublevel::Warning => 6usize,
                Sublevel::Note => 14usize,
                Sublevel::OnceNote => 19usize,
                Sublevel::Help => 28usize,
                Sublevel::OnceHelp => 33usize,
            })
    }
}Debug, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for Sublevel {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        Sublevel::Error => { 0usize }
                        Sublevel::Warning => { 1usize }
                        Sublevel::Note => { 2usize }
                        Sublevel::OnceNote => { 3usize }
                        Sublevel::Help => { 4usize }
                        Sublevel::OnceHelp => { 5usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for Sublevel {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { Sublevel::Error }
                    1usize => { Sublevel::Warning }
                    2usize => { Sublevel::Note }
                    3usize => { Sublevel::OnceNote }
                    4usize => { Sublevel::Help }
                    5usize => { Sublevel::OnceHelp }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `Sublevel`, expected 0..6, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable)]
1595pub enum Sublevel {
1596    /// See `Level::Error`.
1597    ///
1598    /// The compiler never uses this level in a subdiagnostic, but it can be produced by proc
1599    /// macros. See tests/ui/proc-macro/sub-error-diag.rs for details.
1600    Error,
1601
1602    /// See `Level::Warning`.
1603    Warning,
1604
1605    /// A message giving additional context.
1606    Note,
1607
1608    /// A note that is only emitted once.
1609    OnceNote,
1610
1611    /// A message suggesting how to fix something.
1612    Help,
1613
1614    /// A help that is only emitted once.
1615    OnceHelp,
1616}
1617
1618impl Sublevel {
1619    pub fn to_str(self) -> &'static str {
1620        match self {
1621            Sublevel::Error => "error",
1622            Sublevel::Warning => "warning",
1623            Sublevel::Note | Sublevel::OnceNote => "note",
1624            Sublevel::Help | Sublevel::OnceHelp => "help",
1625        }
1626    }
1627}
1628
1629#[derive(#[automatically_derived]impl ::core::marker::Copy for Style { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for Style {
}
#[automatically_derived]impl ::core::clone::Clone for Style {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for Style {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                Style::NoStyle => "NoStyle",
                Style::Highlight => "Highlight",
            })
    }
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for Style { }
#[automatically_derived]impl ::core::cmp::PartialEq for Style {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for Style { }Eq, #[automatically_derived]impl ::core::hash::Hash for Style {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash, const _: () =
    {
        impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
            for Style {
            fn encode(&self, __encoder: &mut __E) {
                let disc =
                    match *self {
                        Style::NoStyle => { 0usize }
                        Style::Highlight => { 1usize }
                    };
                ::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
            }
        }
    };Encodable, const _: () =
    {
        impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
            for Style {
            fn decode(__decoder: &mut __D) -> Self {
                match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
                    {
                    0usize => { Style::NoStyle }
                    1usize => { Style::Highlight }
                    n => {
                        ::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `Style`, expected 0..2, actual {0}",
                                n));
                    }
                }
            }
        }
    };Decodable)]
1630pub enum Style {
1631    NoStyle,
1632    Highlight,
1633}
1634
1635// FIXME(eddyb) this doesn't belong here AFAICT, should be moved to callsite.
1636pub fn elided_lifetime_in_path_suggestion(
1637    source_map: &SourceMap,
1638    n: usize,
1639    path_span: Span,
1640    incl_angl_brckt: bool,
1641    insertion_span: Span,
1642) -> ElidedLifetimeInPathSubdiag {
1643    let expected = ExpectedLifetimeParameter { span: path_span, count: n };
1644    // Do not try to suggest anything if generated by a proc-macro.
1645    let indicate = source_map.is_span_accessible(insertion_span).then(|| {
1646        let anon_lts = ::alloc::vec::from_elem_global("'_", n)vec!["'_"; n].join(", ");
1647        let suggestion =
1648            if incl_angl_brckt { ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("<{0}>", anon_lts))
    })format!("<{anon_lts}>") } else { ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("{0}, ", anon_lts))
    })format!("{anon_lts}, ") };
1649
1650        IndicateAnonymousLifetime { span: insertion_span.shrink_to_hi(), count: n, suggestion }
1651    });
1652
1653    ElidedLifetimeInPathSubdiag { expected, indicate }
1654}
1655
1656/// Grammatical tool for displaying messages to end users in a nice form.
1657///
1658/// Returns "an" if the given string starts with a vowel, and "a" otherwise.
1659pub fn a_or_an(s: &str) -> &'static str {
1660    let mut chars = s.chars();
1661    let Some(mut first_alpha_char) = chars.next() else {
1662        return "a";
1663    };
1664    if first_alpha_char == '`' {
1665        let Some(next) = chars.next() else {
1666            return "a";
1667        };
1668        first_alpha_char = next;
1669    }
1670    if ["a", "e", "i", "o", "u", "&"].contains(&&first_alpha_char.to_lowercase().to_string()[..]) {
1671        "an"
1672    } else {
1673        "a"
1674    }
1675}
1676
1677#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
    for TerminalUrl {
}
#[automatically_derived]impl ::core::clone::Clone for TerminalUrl {
    #[inline]
    fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for TerminalUrl { }Copy, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
    TerminalUrl {
}
#[automatically_derived]impl ::core::cmp::PartialEq for TerminalUrl {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        ::core::intrinsics::discriminant_value(self) ==
            ::core::intrinsics::discriminant_value(other)
    }
}PartialEq, #[automatically_derived]impl ::core::hash::Hash for TerminalUrl {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
        ::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
            state)
    }
}Hash, #[automatically_derived]impl ::core::fmt::Debug for TerminalUrl {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::write_str(f,
            match self {
                TerminalUrl::No => "No",
                TerminalUrl::Yes => "Yes",
                TerminalUrl::Auto => "Auto",
            })
    }
}Debug)]
1678pub enum TerminalUrl {
1679    No,
1680    Yes,
1681    Auto,
1682}