mirror of
https://github.com/rust-lang/rust.git
synced 2025-04-29 11:37:39 +00:00
11ebe6512b
Track where diagnostics were created.
This implements the `-Ztrack-diagnostics` flag, which uses `#[track_caller]` to track where diagnostics are created. It is meant as a debugging tool much like `-Ztreat-err-as-bug`.
For example, the following code...
```rust
struct A;
struct B;
fn main(){
let _: A = B;
}
```
...now emits the following error message:
```
error[E0308]: mismatched types
--> src\main.rs:5:16
|
5 | let _: A = B;
| - ^ expected struct `A`, found struct `B`
| |
| expected due to this
-Ztrack-diagnostics: created at compiler\rustc_infer\src\infer\error_reporting\mod.rs:2275:31
```
104 lines
3.0 KiB
Rust
104 lines
3.0 KiB
Rust
use rustc_errors::{fluent, ErrorGuaranteed, Handler, IntoDiagnostic};
|
|
use rustc_macros::Diagnostic;
|
|
use rustc_middle::ty::{self, PolyTraitRef, Ty};
|
|
use rustc_session::Limit;
|
|
use rustc_span::{Span, Symbol};
|
|
|
|
#[derive(Diagnostic)]
|
|
#[diag(trait_selection_dump_vtable_entries)]
|
|
pub struct DumpVTableEntries<'a> {
|
|
#[primary_span]
|
|
pub span: Span,
|
|
pub trait_ref: PolyTraitRef<'a>,
|
|
pub entries: String,
|
|
}
|
|
|
|
#[derive(Diagnostic)]
|
|
#[diag(trait_selection_unable_to_construct_constant_value)]
|
|
pub struct UnableToConstructConstantValue<'a> {
|
|
#[primary_span]
|
|
pub span: Span,
|
|
pub unevaluated: ty::UnevaluatedConst<'a>,
|
|
}
|
|
|
|
#[derive(Diagnostic)]
|
|
#[help]
|
|
#[diag(trait_selection_auto_deref_reached_recursion_limit, code = "E0055")]
|
|
pub struct AutoDerefReachedRecursionLimit<'a> {
|
|
#[primary_span]
|
|
#[label]
|
|
pub span: Span,
|
|
pub ty: Ty<'a>,
|
|
pub suggested_limit: Limit,
|
|
pub crate_name: Symbol,
|
|
}
|
|
|
|
#[derive(Diagnostic)]
|
|
#[diag(trait_selection_empty_on_clause_in_rustc_on_unimplemented, code = "E0232")]
|
|
pub struct EmptyOnClauseInOnUnimplemented {
|
|
#[primary_span]
|
|
#[label]
|
|
pub span: Span,
|
|
}
|
|
|
|
#[derive(Diagnostic)]
|
|
#[diag(trait_selection_invalid_on_clause_in_rustc_on_unimplemented, code = "E0232")]
|
|
pub struct InvalidOnClauseInOnUnimplemented {
|
|
#[primary_span]
|
|
#[label]
|
|
pub span: Span,
|
|
}
|
|
|
|
#[derive(Diagnostic)]
|
|
#[diag(trait_selection_no_value_in_rustc_on_unimplemented, code = "E0232")]
|
|
#[note]
|
|
pub struct NoValueInOnUnimplemented {
|
|
#[primary_span]
|
|
#[label]
|
|
pub span: Span,
|
|
}
|
|
|
|
pub struct NegativePositiveConflict<'a> {
|
|
pub impl_span: Span,
|
|
pub trait_desc: &'a str,
|
|
pub self_desc: &'a Option<String>,
|
|
pub negative_impl_span: Result<Span, Symbol>,
|
|
pub positive_impl_span: Result<Span, Symbol>,
|
|
}
|
|
|
|
impl IntoDiagnostic<'_> for NegativePositiveConflict<'_> {
|
|
#[track_caller]
|
|
fn into_diagnostic(
|
|
self,
|
|
handler: &Handler,
|
|
) -> rustc_errors::DiagnosticBuilder<'_, ErrorGuaranteed> {
|
|
let mut diag = handler.struct_err(fluent::trait_selection_negative_positive_conflict);
|
|
diag.set_arg("trait_desc", self.trait_desc);
|
|
diag.set_arg(
|
|
"self_desc",
|
|
self.self_desc.clone().map_or_else(|| String::from("none"), |ty| ty),
|
|
);
|
|
diag.set_span(self.impl_span);
|
|
diag.code(rustc_errors::error_code!(E0751));
|
|
match self.negative_impl_span {
|
|
Ok(span) => {
|
|
diag.span_label(span, fluent::negative_implementation_here);
|
|
}
|
|
Err(cname) => {
|
|
diag.note(fluent::negative_implementation_in_crate);
|
|
diag.set_arg("negative_impl_cname", cname.to_string());
|
|
}
|
|
}
|
|
match self.positive_impl_span {
|
|
Ok(span) => {
|
|
diag.span_label(span, fluent::positive_implementation_here);
|
|
}
|
|
Err(cname) => {
|
|
diag.note(fluent::positive_implementation_in_crate);
|
|
diag.set_arg("positive_impl_cname", cname.to_string());
|
|
}
|
|
}
|
|
diag
|
|
}
|
|
}
|